@rebasepro/client 0.23.0 → 0.24.0

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, PUBLIC_STORAGE_PREFIX, RebaseApiError, RebaseApiError as RebaseApiError$1, RebaseClientError, RebaseClientError as RebaseClientError$1, SCHEMA_VERSION_HEADER, Vector, hasFieldOperation, isPublicStoragePath, isUnsupported, parseRelationAggregateSort, sortKeyToString, toCanonicalOp, unsupportedMethod } from "@rebasepro/types";
+import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, IMPERSONATE_HEADER, PUBLIC_STORAGE_PREFIX, RebaseApiError, RebaseApiError as RebaseApiError$1, RebaseClientError, RebaseClientError as RebaseClientError$1, SCHEMA_VERSION_HEADER, STORAGE_REFERENCE_SCHEME, Vector, hasFieldOperation, isPublicStoragePath, isStorageReference, isUnsupported, parseRelationAggregateSort, parseStorageReference, resolveStorageReferences, sortKeyToString, storageObjectPath, storageReference, toCanonicalOp, unsupportedMethod } from "@rebasepro/types";
 import { COMPOSITE_ID_SEPARATOR, QueryBuilder, RESERVED_QUERY_KEYS, RebasePaginationError, and, buildCompositeId, collectAllPages, cond, mergeIncludeSpecs, normalizeOrderBy, not, or, paginateFind, resolveFindWindow, serializeFilter, serializeInclude, serializeLogicalCondition, serializeOrderBy } from "@rebasepro/common";
 import { splitSearchTerms, toSnakeCase, unref } from "@rebasepro/utils";
 //#region src/reviver.ts
@@ -165,6 +165,7 @@ function buildAggregateQueryString(params) {
 	parts.push(`select=${encodeURIComponent(select)}`);
 	if (params.groupBy && params.groupBy.length > 0) parts.push(`groupBy=${encodeURIComponent(params.groupBy.join(","))}`);
 	if (params.limit != null) parts.push(`limit=${params.limit}`);
+	if (params.offset != null) parts.push(`offset=${params.offset}`);
 	if (params.searchString) parts.push(`searchString=${encodeURIComponent(params.searchString)}`);
 	if (params.logical) {
 		const root = params.logical;
@@ -175,6 +176,35 @@ function buildAggregateQueryString(params) {
 	return "?" + parts.join("&");
 }
 /**
+* The 401 codes that mean "the credential on this request is no good", which a
+* refreshed token can fix.
+*
+* The rest of the 401s are answers about something the caller *sent*: a wrong
+* current password (`INVALID_CREDENTIALS`), a mistyped MFA code (`INVALID_CODE`,
+* `CHALLENGE_EXHAUSTED`), a sign-in that needs a second factor
+* (`MFA_REQUIRED`). Refreshing and resending one of those rotated the session
+* for nothing, sent the same wrong answer twice — and an MFA challenge claims
+* an attempt before it judges the code, so every typo cost two of its five.
+*/
+var TOKEN_REFUSAL_CODES = /* @__PURE__ */ new Set([
+	"UNAUTHORIZED",
+	"INVALID_TOKEN",
+	"TOKEN_EXPIRED",
+	"SESSION_REVOKED"
+]);
+/**
+* Whether a 401's body says the token was the problem.
+*
+* A 401 with no code at all counts: it is what an older server, a proxy or
+* anything not speaking the envelope sends, and there the token is the
+* likeliest cause — refreshing is what this client always did with it.
+*/
+function isTokenRefusal(body) {
+	const error = body?.error;
+	const code = error && typeof error === "object" ? error.code : void 0;
+	return typeof code !== "string" || code === "" || TOKEN_REFUSAL_CODES.has(code);
+}
+/**
 * The base every request and every caller-built URL resolves against.
 *
 * `baseUrl` is optional because the common production shape is a Rebase
@@ -263,7 +293,8 @@ function createTransport(config, environment) {
 	}
 	const defaultHeaders = {
 		...config.headers ?? {},
-		...config.schemaVersion ? { [SCHEMA_VERSION_HEADER]: config.schemaVersion } : {}
+		...config.schemaVersion ? { [SCHEMA_VERSION_HEADER]: config.schemaVersion } : {},
+		...config.impersonate !== void 0 ? { [IMPERSONATE_HEADER]: config.impersonate } : {}
 	};
 	function getHeaders(activeToken, init) {
 		const headers = {
@@ -379,7 +410,7 @@ function createTransport(config, environment) {
 		} catch (e) {
 			unreadableBody = true;
 		}
-		if (res.status === 401 && onUnauthorizedHandler) {
+		if (res.status === 401 && onUnauthorizedHandler && isTokenRefusal(body)) {
 			if (await onUnauthorizedHandler()) {
 				let retryToken = token;
 				if (tokenGetter) try {
@@ -466,6 +497,7 @@ function mapRawUser(raw) {
 		providerId: raw.providerId ?? "password",
 		isAnonymous: raw.isAnonymous ?? false,
 		emailVerified: raw.emailVerified,
+		...raw.pendingEmail !== void 0 ? { pendingEmail: raw.pendingEmail } : {},
 		roles: raw.roles,
 		metadata: raw.metadata
 	};
@@ -547,13 +579,56 @@ function createAuth(transport, options) {
 	function getFetch() {
 		return transport.fetchFn || globalThis.fetch;
 	}
-	function throwApiError(status, body, statusText) {
-		throw new RebaseApiError(body?.error?.message || body?.message || statusText, {
+	/**
+	* The body of a request that presents the refresh token — `/refresh` and
+	* `/logout`.
+	*
+	* Empty in cookie mode. The token is in an HttpOnly cookie the browser
+	* attaches, and this client never holds it: what it holds is the `""` the
+	* server answers in its place. Sending that back was sending a blank token
+	* beside the cookie, and a server that refused the blank (0.10.0 through
+	* 0.23, with 400 INVALID_INPUT) never read the cookie — so no tab that outlived
+	* its access token could renew it, while a reload, which had no session in
+	* memory and so sent no field, could.
+	*/
+	function refreshTokenBody() {
+		return JSON.stringify(authFlowMode === "cookie" ? {} : { refreshToken: currentSession?.refreshToken });
+	}
+	/**
+	* The refresh token a new session keeps, given the one an answer carried.
+	*
+	* In cookie mode, none: the server answers `refreshToken: ""` because the
+	* cookie holds it, and that `""` is "not held here", not a token to carry
+	* forward or present. Otherwise the answer's token, or — from a server
+	* that omits it on a rotation it did not make — the one already held.
+	*/
+	function heldRefreshToken(received) {
+		if (authFlowMode === "cookie") return "";
+		return received || currentSession?.refreshToken || "";
+	}
+	/**
+	* Whether the server refused a refresh as malformed: a 400, which says the
+	* request this client built is not one that server accepts.
+	*
+	* That is a client/server contract mismatch, not a blip. The identical
+	* request is refused identically however often it is sent, so retrying it
+	* on a backoff only hides the error behind six identical ones — which is
+	* how a cookie-mode tab, refused this way after every wake from sleep,
+	* quietly ended on its login screen.
+	*/
+	function isMalformedRefreshError(err) {
+		return err instanceof RebaseApiError && err.status === 400;
+	}
+	function apiError(status, body, statusText) {
+		return new RebaseApiError(body?.error?.message || body?.message || statusText, {
 			status,
 			code: body?.error?.code || body?.code,
 			details: body?.error?.details || body?.details
 		});
 	}
+	function throwApiError(status, body, statusText) {
+		throw apiError(status, body, statusText);
+	}
 	function emit(event, session) {
 		for (const fn of listeners) try {
 			fn(event, session);
@@ -663,6 +738,7 @@ function createAuth(transport, options) {
 				abandonSessionLocally();
 				return;
 			}
+			if (isMalformedRefreshError(err)) return;
 			if (attempt >= MAX_REFRESH_RETRIES) {
 				if (err instanceof RebaseApiError && (err.status === 401 || err.status === 403)) abandonSessionLocally();
 				return;
@@ -721,7 +797,7 @@ function createAuth(transport, options) {
 		const user = mapRawUser(data.user);
 		const session = {
 			accessToken: data.tokens.accessToken,
-			refreshToken: data.tokens.refreshToken || currentSession?.refreshToken || "",
+			refreshToken: heldRefreshToken(data.tokens.refreshToken),
 			expiresAt: data.tokens.accessTokenExpiresAt,
 			user
 		};
@@ -766,8 +842,15 @@ function createAuth(transport, options) {
 		});
 		const body = await res.json().catch(() => ({}));
 		if (!res.ok) throwApiError(res.status, body, res.statusText);
+		if (body && typeof body === "object" && "confirmationRequired" in body && body.confirmationRequired === true) return {
+			confirmationRequired: true,
+			user: null,
+			accessToken: null,
+			refreshToken: null
+		};
 		const session = handleAuthResponse(body, "SIGNED_IN");
 		return {
+			confirmationRequired: false,
 			user: session.user,
 			accessToken: session.accessToken,
 			refreshToken: session.refreshToken
@@ -905,7 +988,7 @@ function createAuth(transport, options) {
 			if (authFlowMode === "cookie" || currentSession?.refreshToken) await fetchFn(authUrl("/logout"), {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ refreshToken: currentSession?.refreshToken }),
+				body: refreshTokenBody(),
 				credentials: authFlowMode === "cookie" ? "include" : void 0
 			});
 		} catch (e) {}
@@ -1028,12 +1111,16 @@ function createAuth(transport, options) {
 		const res = await getFetch()(authUrl("/refresh"), {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ refreshToken: currentSession?.refreshToken }),
+			body: refreshTokenBody(),
 			credentials: authFlowMode === "cookie" ? "include" : void 0
 		});
 		const body = await res.json().catch(() => ({}));
 		if (epoch !== sessionEpoch) return supersededRefresh();
-		if (!res.ok) throwApiError(res.status, body, res.statusText);
+		if (!res.ok) {
+			const err = apiError(res.status, body, res.statusText);
+			if (isMalformedRefreshError(err)) console.error(`[rebase] POST ${authPath}/refresh was refused as malformed (${res.status}${err.code ? ` ${err.code}` : ""}): ${err.message}. The client and server disagree on the refresh request, so this session cannot be renewed and retrying will not help. Check that @rebasepro/client and @rebasepro/server are on compatible versions, and that \`authFlowMode\` matches the server's \`cookieAuth\`.`);
+			throw err;
+		}
 		const accessToken = body.tokens.accessToken;
 		transport.setToken(accessToken);
 		let user = currentSession?.user;
@@ -1046,7 +1133,7 @@ function createAuth(transport, options) {
 		}
 		const session = {
 			accessToken,
-			refreshToken: body.tokens.refreshToken || currentSession?.refreshToken || "",
+			refreshToken: heldRefreshToken(body.tokens.refreshToken),
 			expiresAt: body.tokens.accessTokenExpiresAt,
 			user: user ?? EMPTY_USER
 		};
@@ -1110,14 +1197,36 @@ function createAuth(transport, options) {
 		if (!res.ok) throwApiError(res.status, body, res.statusText);
 		return body;
 	}
+	/**
+	* Change the signed-in account's password. Every other session ends; this
+	* one is replaced by the fresh session the server answers with, so the
+	* client stays signed in.
+	*/
 	async function changePassword(oldPassword, newPassword) {
-		return transport.request(authPath + "/change-password", {
+		if (currentSession && currentSession.expiresAt <= Date.now() + 1e4) await refreshSession().catch(() => void 0);
+		const res = await getFetch()(authUrl("/change-password"), {
 			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...currentSession?.accessToken ? { Authorization: `Bearer ${currentSession.accessToken}` } : {}
+			},
 			body: JSON.stringify({
 				oldPassword,
 				newPassword
-			})
+			}),
+			credentials: authFlowMode === "cookie" ? "include" : void 0
 		});
+		const body = await res.json().catch(() => ({}));
+		if (!res.ok) throwApiError(res.status, body, res.statusText);
+		const result = body;
+		if (result.tokens && result.user) handleAuthResponse({
+			tokens: result.tokens,
+			user: result.user
+		}, "TOKEN_REFRESHED");
+		return {
+			success: result.success,
+			message: result.message
+		};
 	}
 	/**
 	* Link an OAuth provider to the **currently signed-in** account.
@@ -1146,14 +1255,113 @@ function createAuth(transport, options) {
 	async function sendVerificationEmail() {
 		return transport.request(authPath + "/send-verification", { method: "POST" });
 	}
-	async function verifyEmail(token) {
-		const res = await getFetch()(authUrl("/verify-email?token=" + encodeURIComponent(token)), {
-			method: "GET",
-			headers: { "Content-Type": "application/json" }
+	/**
+	* Verify the address with the token from the link.
+	*
+	* The link proves the inbox, not who registered the address, so the
+	* server keeps only what this call also proves: the current session (sent
+	* when this client is signed in as that account) or `password`. An account
+	* carrying a password or identity neither proves is refused with
+	* `PROOF_REQUIRED` and the token is left unspent — ask for the password,
+	* or pass `removeUnproven: true` to verify without it. With `password`,
+	* the call also signs in.
+	*/
+	async function verifyEmail(token, options) {
+		const fetchFn = getFetch();
+		const headers = { "Content-Type": "application/json" };
+		if (currentSession?.accessToken) headers.Authorization = `Bearer ${currentSession.accessToken}`;
+		const res = await fetchFn(authUrl("/verify-email"), {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				token,
+				...options
+			}),
+			credentials: authFlowMode === "cookie" ? "include" : void 0
 		});
 		const body = await res.json().catch(() => ({}));
 		if (!res.ok) throwApiError(res.status, body, res.statusText);
-		return body;
+		const result = body;
+		const session = result.tokens && result.user ? handleAuthResponse({
+			tokens: result.tokens,
+			user: result.user
+		}, "SIGNED_IN") : null;
+		return {
+			success: result.success,
+			passwordRemoved: result.passwordRemoved,
+			removedProviders: result.removedProviders ?? [],
+			session
+		};
+	}
+	/**
+	* Move the signed-in account to `newEmail`. The server mails a link to the
+	* new address and a notice to the current one; nothing changes until the
+	* link is followed and {@link confirmEmailChange} is called with its
+	* token. A new request replaces the last.
+	*
+	* Rejects with `EMAIL_EXISTS` or `UNDELIVERABLE_ADDRESS` (409),
+	* `EMAIL_UNCHANGED` (400), `AAL2_REQUIRED` when the account has a second
+	* factor this session did not present, and `ANONYMOUS_USER` for a guest.
+	*/
+	async function changeEmail(newEmail) {
+		const data = await transport.request(authPath + "/change-email", {
+			method: "POST",
+			body: JSON.stringify({ newEmail })
+		});
+		if (currentSession) {
+			currentSession = {
+				...currentSession,
+				user: {
+					...currentSession.user,
+					pendingEmail: data.pendingEmail
+				}
+			};
+			saveSession(currentSession);
+			emit("USER_UPDATED", currentSession);
+		}
+		return {
+			pendingEmail: data.pendingEmail,
+			expiresAt: data.expiresAt
+		};
+	}
+	/**
+	* Follow an address-change link: the token from
+	* `<frontend>/confirm-email-change?token=…`. Needs no session — the link
+	* proves the new inbox — and when this client is signed in as the account
+	* it moved, its user is updated and `USER_UPDATED` is emitted.
+	*
+	* `removedProviders` names the sign-in providers detached because they
+	* vouched for the old address. Rejects with `INVALID_TOKEN` for a spent,
+	* replaced or expired link and `EMAIL_EXISTS` when the address was taken
+	* while the link waited.
+	*/
+	async function confirmEmailChange(token) {
+		const res = await getFetch()(authUrl("/confirm-email-change"), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ token })
+		});
+		const body = await res.json().catch(() => ({}));
+		if (!res.ok) throwApiError(res.status, body, res.statusText);
+		const result = body;
+		if (currentSession && currentSession.user.uid === result.user.uid) {
+			currentSession = {
+				...currentSession,
+				user: {
+					...currentSession.user,
+					email: result.user.email,
+					emailVerified: true,
+					pendingEmail: null
+				}
+			};
+			saveSession(currentSession);
+			emit("USER_UPDATED", currentSession);
+		}
+		return {
+			uid: result.user.uid,
+			email: result.user.email,
+			removedProviders: result.removedProviders ?? []
+		};
 	}
 	async function sendMagicLink(email) {
 		const res = await getFetch()(authUrl("/magic-link"), {
@@ -1289,8 +1497,11 @@ function createAuth(transport, options) {
 		* Start enrolling a TOTP factor.
 		*
 		* Returns the secret and an `otpauth://` URI to render as a QR code,
-		* plus ten single-use recovery codes. **Show the recovery codes once
-		* and never again** — only their hashes are stored.
+		* plus — with the account's first factor — ten single-use recovery
+		* codes. **Show the recovery codes once and never again**: only their
+		* hashes are stored. Adding another factor keeps the codes the account
+		* has, and `recoveryCodes` is then `null`; `regenerateRecoveryCodes()`
+		* replaces them.
 		*
 		* The factor is not usable until `verify` confirms the user's
 		* authenticator produced a correct code from it.
@@ -1319,6 +1530,14 @@ function createAuth(transport, options) {
 		* Remove a factor. Requires an `aal2` session — one that has already
 		* answered a challenge — so a stolen `aal1` token cannot turn MFA off.
 		*/
+		/**
+		* Replace the account's recovery codes with ten new ones, shown once.
+		* Needs an `aal2` session. Adding a second factor keeps the codes the
+		* account already has; this is how to get new ones.
+		*/
+		async regenerateRecoveryCodes() {
+			return transport.request(authPath + "/mfa/recovery-codes", { method: "POST" });
+		},
 		async unenroll(factorId) {
 			return transport.request(authPath + "/mfa/unenroll", {
 				method: "DELETE",
@@ -1436,7 +1655,7 @@ function createAuth(transport, options) {
 					transport.setToken(null);
 				} else {
 					transport.setToken(currentSession.accessToken);
-					if (autoRefresh) scheduleRetry(0);
+					if (autoRefresh && !isMalformedRefreshError(err)) scheduleRetry(0);
 				}
 				resolveInitialized();
 			});
@@ -1480,6 +1699,8 @@ function createAuth(transport, options) {
 		linkProvider,
 		sendVerificationEmail,
 		verifyEmail,
+		changeEmail,
+		confirmEmailChange,
 		sendMagicLink,
 		verifyMagicLink,
 		sendEmailOtp,
@@ -1563,6 +1784,10 @@ function createAdmin(transport, options) {
 			body: JSON.stringify(data)
 		});
 	}
+	/**
+	* Change an account. `disabled: true` switches it off — no sign-in, no
+	* refresh, and every token it holds refused at once — without deleting it.
+	*/
 	async function updateUser(userId, data) {
 		return transport.request(adminPath + "/users/" + encodeURIComponent(userId), {
 			method: "PUT",
@@ -1572,6 +1797,14 @@ function createAdmin(transport, options) {
 	async function deleteUser(userId) {
 		return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "DELETE" });
 	}
+	/**
+	* Remove every second factor and recovery code the account has, and end
+	* its sessions — for someone who lost their authenticator and their
+	* codes. Needs `users:write`.
+	*/
+	async function resetMfa(userId) {
+		return transport.request(adminPath + "/users/" + encodeURIComponent(userId) + "/mfa", { method: "DELETE" });
+	}
 	async function resetPassword(userId, options) {
 		return transport.request(adminPath + "/users/" + encodeURIComponent(userId) + "/reset-password", {
 			method: "POST",
@@ -1591,6 +1824,7 @@ function createAdmin(transport, options) {
 		createUser,
 		updateUser,
 		deleteUser,
+		resetMfa,
 		resetPassword,
 		listRoles,
 		bootstrap
@@ -1665,7 +1899,8 @@ function createBackups(transport, options) {
 //#endregion
 //#region src/api-keys.ts
 /**
-* Creates a client for managing API keys via the admin routes.
+* Creates a client for the project's service keys, via the admin routes.
+* Needs `keys:read` / `keys:write`.
 *
 * @param transport - The shared HTTP transport created by `createTransport`.
 * @param options   - Optional overrides (e.g. a custom base path).
@@ -1706,6 +1941,43 @@ function createApiKeys(transport, options) {
 		revokeKey
 	};
 }
+/**
+* Creates a client for the signed-in account's own API keys — each acts as the
+* account and holds no scope it does not. Answers `PERSONAL_KEYS_DISABLED`
+* unless the backend sets `personalKeys: true` on the users collection.
+*/
+function createPersonalKeys(transport, options) {
+	const keysPath = options?.personalKeysPath || "/auth/keys";
+	const scopesPath = options?.scopesPath || "/auth/scopes";
+	/** List this account's keys (masked). */
+	async function listKeys() {
+		return transport.request(keysPath, { method: "GET" });
+	}
+	/** Create a key for this account. The full secret is included in the response. */
+	async function createKey(data) {
+		return transport.request(keysPath, {
+			method: "POST",
+			body: JSON.stringify(data)
+		});
+	}
+	/** Revoke one of this account's keys. */
+	async function revokeKey(id) {
+		return transport.request(keysPath + "/" + encodeURIComponent(id), { method: "DELETE" });
+	}
+	/**
+	* Every scope the backend knows, described, and the ones the caller holds —
+	* what a screen offering scopes for a key needs.
+	*/
+	async function listScopes() {
+		return transport.request(scopesPath, { method: "GET" });
+	}
+	return {
+		listKeys,
+		createKey,
+		revokeKey,
+		listScopes
+	};
+}
 //#endregion
 //#region src/sdk_query_builder.ts
 /**
@@ -2145,14 +2417,27 @@ function createCollectionClient(transport, slug, ws) {
 		* One statement server-side (`INSERT ... ON CONFLICT DO UPDATE`), so
 		* unlike a `findById` followed by `create`-or-`update` it cannot lose
 		* the race between the two.
+		*
+		* Sent as a one-row bulk write with `upsert: true`, which is what the
+		* in-process accessor and the offline queue already send. It used to be
+		* `POST /data/<slug>` with `?on_conflict=` only when a target was
+		* named — and the route reads that POST without the parameter as the
+		* plain insert a `create` is, so the documented default ("on the
+		* primary key") never happened online: re-upserting an existing row
+		* answered 409, while the same call succeeded offline and in a
+		* function.
 		*/
 		async upsert(data, options) {
-			const query = options?.onConflict?.length ? `?on_conflict=${encodeURIComponent(options.onConflict.join(","))}` : "";
-			return await transport.request(`${basePath}${query}`, {
+			const raw = await transport.request(`${basePath}/bulk`, {
 				method: "POST",
-				body: JSON.stringify(data),
+				body: JSON.stringify({
+					rows: [data],
+					upsert: true,
+					...options?.onConflict?.length ? { onConflict: options.onConflict } : {}
+				}),
 				...writeHeaders(options)
 			});
+			return options?.returning === false ? void 0 : raw?.data?.[0];
 		},
 		async createMany(data, options) {
 			if (!Array.isArray(data)) throw new TypeError("createMany expects an array of records.");
@@ -2346,7 +2631,13 @@ function createCollectionClient(transport, slug, ws) {
 		*/
 		async aggregate(params) {
 			const qs = buildAggregateQueryString(params);
-			return (await transport.request(`${basePath}/aggregate${qs}`, { method: "GET" })).data || [];
+			const raw = await transport.request(`${basePath}/aggregate${qs}`, { method: "GET" });
+			const rows = raw.data || [];
+			if (raw.meta) Object.defineProperty(rows, "meta", {
+				value: raw.meta,
+				enumerable: false
+			});
+			return rows;
 		},
 		listen: unsupportedMethod(NO_SOCKET),
 		listenById: unsupportedMethod(NO_SOCKET)
@@ -2512,7 +2803,10 @@ function createStorage(transport, storageId) {
 			formData.append("property", context.property);
 		}
 		let effectiveKey = key;
-		if (isPublic && effectiveKey && !isPublicStoragePath(effectiveKey)) effectiveKey = `${PUBLIC_STORAGE_PREFIX}${effectiveKey.replace(/^\/+/, "")}`;
+		if (isPublic) {
+			effectiveKey ||= file instanceof File && file.name ? file.name : "blob";
+			if (!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);
@@ -2532,9 +2826,7 @@ function createStorage(transport, storageId) {
 			if (!cachedEntry.expiresAt || cachedEntry.expiresAt > Date.now()) return cachedEntry.config;
 			urlsCache.delete(cacheKey);
 		}
-		let filePath = keyOrUrl;
-		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
-		if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
+		const filePath = storageObjectPath(keyOrUrl, bucket);
 		if (!filePath || filePath.trim() === "" || filePath === "/") return {
 			url: null,
 			fileNotFound: true
@@ -2585,9 +2877,7 @@ function createStorage(transport, storageId) {
 		return new File([blob], fileName, { type: blob.type });
 	}
 	async function deleteObject(key, bucket) {
-		let filePath = key;
-		if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
-		if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
+		const filePath = storageObjectPath(key, bucket);
 		if (!filePath || filePath.trim() === "" || filePath === "/") return;
 		try {
 			await transport.request(withStorageId(`/storage/file/${encodeStorageKey(filePath)}`), { method: "DELETE" });
@@ -2670,6 +2960,87 @@ var ClientStorageSourceRegistry = class ClientStorageSourceRegistry {
 	}
 };
 //#endregion
+//#region src/sql-script.ts
+/**
+* Read an `EXECUTE_SQL_SUCCESS` payload for a script run as a
+* {@link SqlScriptResult}, checking every field rather than trusting the frame.
+*
+* A server from before scripts existed answers `{ result }` alone, with parsed
+* values. Its rows are kept, as text, and no column is said to come from
+* anywhere — the console edits no cell of a result it cannot trace.
+*/
+function readSqlScriptResult(payload) {
+	const record = asRecord(payload);
+	const rows = Array.isArray(record?.result) ? record.result.map(asRecord).filter(isDefined).map(textRow) : [];
+	const result = {
+		rows,
+		columns: Array.isArray(record?.columns) ? record.columns.map(readColumn).filter(isDefined) : Object.keys(rows[0] ?? {}).map((name) => ({ name })),
+		tables: Array.isArray(record?.tables) ? record.tables.map(readTable).filter(isDefined) : [],
+		notices: Array.isArray(record?.notices) ? record.notices.map(readNotice).filter(isDefined) : []
+	};
+	if (typeof record?.command === "string") result.command = record.command;
+	if (typeof record?.rowCount === "number") result.rowCount = record.rowCount;
+	if (typeof record?.effectiveRole === "string") result.effectiveRole = record.effectiveRole;
+	return result;
+}
+function isDefined(value) {
+	return value !== void 0;
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : void 0;
+}
+function textRow(row) {
+	return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, asText(value)]));
+}
+function asText(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string") return value;
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+function readColumn(value) {
+	const record = asRecord(value);
+	if (typeof record?.name !== "string") return void 0;
+	const column = { name: record.name };
+	if (typeof record.type === "string") column.type = record.type;
+	const source = asRecord(record.source);
+	if (typeof source?.schema === "string" && typeof source.table === "string" && typeof source.column === "string") column.source = {
+		schema: source.schema,
+		table: source.table,
+		column: source.column
+	};
+	return column;
+}
+var TABLE_KINDS = [
+	"table",
+	"partitioned table",
+	"view",
+	"materialized view",
+	"foreign table",
+	"other"
+];
+function readTable(value) {
+	const record = asRecord(value);
+	if (typeof record?.schema !== "string" || typeof record.table !== "string") return void 0;
+	const kind = TABLE_KINDS.find((candidate) => candidate === record.kind) ?? "other";
+	const primaryKey = Array.isArray(record.primaryKey) && record.primaryKey.every((column) => typeof column === "string") ? record.primaryKey : [];
+	return {
+		schema: record.schema,
+		table: record.table,
+		kind,
+		primaryKey,
+		hasInheritors: record.hasInheritors !== false
+	};
+}
+function readNotice(value) {
+	const record = asRecord(value);
+	if (typeof record?.message !== "string") return void 0;
+	return {
+		severity: typeof record.severity === "string" ? record.severity : "NOTICE",
+		message: record.message
+	};
+}
+//#endregion
 //#region src/websocket.ts
 /**
 * Extract error message and code from a WebSocket message payload.
@@ -2700,6 +3071,33 @@ function frameError(message) {
 	});
 }
 /**
+* A request whose socket closed after it was written and before the server
+* answered. The server may have run it. It is not re-sent — see `onclose`.
+*/
+function connectionLostError() {
+	return new RebaseApiError$1("The realtime connection closed before the server answered. The request may or may not have been applied, and it was not sent again.", { code: "CONNECTION_LOST" });
+}
+/**
+* A request that got no answer within `requestTimeoutMs` of the call — whether
+* it waited in the queue for a socket the whole time, or was written and never
+* answered (a half-open connection looks exactly like that).
+*/
+function requestTimeoutError(written) {
+	return new RebaseApiError$1(written ? "The server did not answer the realtime request in time. It may or may not have been applied." : "The realtime request timed out before it could be sent. It was not applied.", { code: "REQUEST_TIMEOUT" });
+}
+/**
+* What a live subscription or a joined channel is told, once, when the
+* connection has been down for longer than a blip. The registration is kept and
+* resumes when the socket is back.
+*/
+function realtimeLostError() {
+	return new RebaseApiError$1("The realtime connection is down, so live data is not updating. The client keeps reconnecting and refreshes this subscription when the connection is back.", { code: "CONNECTION_LOST" });
+}
+/** The ceiling of the reconnect backoff. */
+var MAX_RECONNECT_DELAY_MS = 3e4;
+/** Each reconnect delay is drawn from the last fifth below its step. */
+var RECONNECT_JITTER = .2;
+/**
 * Broadcast and presence frames.
 *
 * Fire-and-forget (the server sends no response envelope), and exempt from the
@@ -2794,16 +3192,56 @@ var RebaseWebSocketClient = class {
 	/** Set by `close()`. Blocks any later operation from silently redialling. */
 	closedByCaller = false;
 	/**
-	* Set when the backoff budget ran out, cleared by anything that earns a
-	* fresh one.
+	* Set when the backoff budget ran out with nothing registered, cleared by
+	* anything that earns a fresh one.
 	*
-	* Unlike {@link closedByCaller} this is not final — nobody *asked* for the
-	* socket to stay down. Five attempts with exponential backoff is about a
-	* minute, which a laptop lid, a wifi handover or a backend rollout all
-	* exceed routinely; treating that as permanent meant realtime silently
-	* stopped for the rest of the page's life, with a reload the only cure.
+	* Only reachable with nothing registered: while a subscription or a joined
+	* channel exists the client never stops retrying (see `attemptReconnect`).
+	* And it is not final like {@link closedByCaller} — nobody *asked* for the
+	* socket to stay down, so the next subscribe dials again.
 	*/
 	gaveUp = false;
+	/** See {@link state}. */
+	connectionState = "idle";
+	stateListeners = /* @__PURE__ */ new Set();
+	/**
+	* Whether the current outage has been reported to the registrations as
+	* `CONNECTION_LOST`. Once per outage: cleared when a socket opens.
+	*/
+	outageReported = false;
+	/**
+	* Where the connection is.
+	*
+	* - `idle` — no socket, and none wanted yet (the connection is lazy), or
+	*   the last one was dropped by a sign-out.
+	* - `connecting` — dialling, with no outage in progress.
+	* - `connected` — the socket is open.
+	* - `reconnecting` — the socket dropped and the client is redialling. A
+	*   blip, so far: nothing has been reported.
+	* - `disconnected` — the outage has outlasted the blip budget. Every
+	*   subscription and joined channel has been told `CONNECTION_LOST` once;
+	*   the client keeps redialling (every 30 s at most) while any exists.
+	* - `closed` — `client.close()`. Final.
+	*/
+	get state() {
+		return this.connectionState;
+	}
+	/** Called on every change of {@link state}. Returns the unsubscribe. */
+	onStateChange(listener) {
+		this.stateListeners.add(listener);
+		return () => {
+			this.stateListeners.delete(listener);
+		};
+	}
+	setState(next) {
+		if (next === this.connectionState) return;
+		this.connectionState = next;
+		for (const listener of [...this.stateListeners]) try {
+			listener(next);
+		} catch (error) {
+			console.error("Error in realtime state listener:", error);
+		}
+	}
 	/**
 	* Whether a socket exists at all (open or still opening).
 	*
@@ -2830,6 +3268,18 @@ var RebaseWebSocketClient = class {
 	onReconnect(handler) {
 		return this.on("reconnect", handler);
 	}
+	/**
+	* Notified once per outage that outlasted a blip, with the
+	* `CONNECTION_LOST` error — so a joined channel can tell its `onError`
+	* handlers, as subscriptions are told through theirs.
+	*/
+	onConnectionLost(handler) {
+		this.connectionLostHandlers.add(handler);
+		return () => {
+			this.connectionLostHandlers.delete(handler);
+		};
+	}
+	connectionLostHandlers = /* @__PURE__ */ new Set();
 	on(event, cb) {
 		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
 		this.listeners.get(event).add(cb);
@@ -2844,8 +3294,19 @@ var RebaseWebSocketClient = class {
 	backendToEntityKey = /* @__PURE__ */ new Map();
 	pendingRequests = /* @__PURE__ */ new Map();
 	reconnectAttempts = 0;
+	/**
+	* With nothing registered, how many failed redials before the client stops
+	* trying until something asks for the connection. With a registration it
+	* never stops.
+	*/
 	maxReconnectAttempts = 5;
 	/**
+	* How many failed redials make a blip an outage: the point at which every
+	* registration is told `CONNECTION_LOST` and {@link state} reads
+	* `disconnected`. Three is 2 + 4 + 8 s of backoff, about 14 s down.
+	*/
+	lostAfterAttempts = 3;
+	/**
 	* Whether a socket of this client has ever opened — what makes the next
 	* open a *reconnect*, whose server has forgotten every subscription and
 	* channel membership and must be told them again.
@@ -2866,10 +3327,12 @@ var RebaseWebSocketClient = class {
 	WebSocketConstructor;
 	onUnauthorized;
 	refreshInProgress = null;
+	impersonate;
 	constructor(config) {
 		this.websocketUrl = config.websocketUrl;
 		this.getAuthToken = config.getAuthToken;
 		this.onUnauthorized = config.onUnauthorized;
+		this.impersonate = config.impersonate;
 		this.WebSocketConstructor = config.WebSocket || (typeof WebSocket !== "undefined" ? WebSocket : void 0);
 	}
 	/**
@@ -2888,29 +3351,58 @@ var RebaseWebSocketClient = class {
 			}
 			return;
 		}
-		this.installOnlineListener();
+		this.installNetworkListeners();
 		if (this.ws || this.reconnectTimeout) return;
 		if (this.gaveUp) {
 			this.gaveUp = false;
 			this.reconnectAttempts = 0;
+			this.outageReported = false;
+		}
+		if (!this.outageReported) this.setState("connecting");
+		this.initWebSocket();
+	}
+	/**
+	* Dial now rather than at the next backoff step — the browser says the
+	* network is back, or the tab is in front of the user again. Both are the
+	* usual end of an outage; neither fires for a server restart, which the
+	* backoff covers.
+	*/
+	retryNow(reason) {
+		if (this.closedByCaller) return;
+		if (this.connectionState !== "reconnecting" && this.connectionState !== "disconnected") return;
+		if (this.ws) return;
+		console.debug(`${reason} — retrying the realtime connection`);
+		if (this.reconnectTimeout) {
+			clearTimeout(this.reconnectTimeout);
+			this.reconnectTimeout = null;
 		}
+		this.gaveUp = false;
+		this.reconnectAttempts = 0;
 		this.initWebSocket();
 	}
 	/**
-	* The browser says the network is back — the usual reason the budget ran
-	* out in the first place. Registered lazily so a Node client, or a page
-	* that never subscribes, adds no listener.
+	* `online` and `visibilitychange`. Registered lazily so a Node client, or a
+	* page that never subscribes, adds no listener.
 	*/
-	installOnlineListener() {
+	installNetworkListeners() {
 		if (this.onlineListener || typeof window === "undefined" || typeof window.addEventListener !== "function") return;
-		this.onlineListener = () => {
-			if (this.closedByCaller || !this.gaveUp) return;
-			console.debug("Network is back — retrying the realtime connection");
-			this.ensureConnected();
-		};
+		this.onlineListener = () => this.retryNow("Network is back");
 		window.addEventListener("online", this.onlineListener);
+		if (typeof document !== "undefined" && typeof document.addEventListener === "function") {
+			this.visibilityListener = () => {
+				if (document.visibilityState === "visible") this.retryNow("Tab is visible again");
+			};
+			document.addEventListener("visibilitychange", this.visibilityListener);
+		}
+	}
+	removeNetworkListeners() {
+		if (this.onlineListener && typeof window !== "undefined") window.removeEventListener("online", this.onlineListener);
+		if (this.visibilityListener && typeof document !== "undefined") document.removeEventListener("visibilitychange", this.visibilityListener);
+		this.onlineListener = null;
+		this.visibilityListener = null;
 	}
 	onlineListener = null;
+	visibilityListener = null;
 	/**
 	* Authenticate the WebSocket connection
 	*/
@@ -2935,7 +3427,10 @@ var RebaseWebSocketClient = class {
 			const message = {
 				type: "AUTHENTICATE",
 				requestId,
-				payload: { token }
+				payload: this.impersonate !== void 0 ? {
+					token,
+					impersonate: this.impersonate
+				} : { token }
 			};
 			if (!this.isConnected || !this.ws) this.messageQueue.unshift(message);
 			else this.ws.send(JSON.stringify(message));
@@ -2968,16 +3463,17 @@ var RebaseWebSocketClient = class {
 	*/
 	disconnect(permanent = false) {
 		if (permanent) this.closedByCaller = true;
-		if (permanent && this.onlineListener && typeof window !== "undefined") {
-			window.removeEventListener("online", this.onlineListener);
-			this.onlineListener = null;
-		}
+		if (permanent) this.removeNetworkListeners();
 		this.isAuthenticated = false;
 		this.authPromise = null;
 		if (this.reconnectTimeout) {
 			clearTimeout(this.reconnectTimeout);
 			this.reconnectTimeout = null;
 		}
+		this.reconnectAttempts = 0;
+		this.outageReported = false;
+		this.gaveUp = false;
+		this.setState(permanent ? "closed" : "idle");
 		this.suspendSubscribeWatchdogs();
 		this.forgetCachedData();
 		if (this.ws) {
@@ -3006,6 +3502,9 @@ var RebaseWebSocketClient = class {
 				this.hadConnection = true;
 				this.isConnected = true;
 				this.reconnectAttempts = 0;
+				this.outageReported = false;
+				this.gaveUp = false;
+				this.setState("connected");
 				if (this.getAuthToken && !this.isAuthenticated) try {
 					const token = await this.getAuthToken();
 					if (token) {
@@ -3037,14 +3536,11 @@ var RebaseWebSocketClient = class {
 				this.suspendSubscribeWatchdogs();
 				this.emit("disconnect");
 				for (const [reqId, request] of this.pendingRequests.entries()) {
-					if (reqId.startsWith("auth_")) request.reject(/* @__PURE__ */ new Error("Connection closed during authentication"));
-					else if (request.message) {
-						request.message._queuedResolve = request.resolve;
-						request.message._queuedReject = request.reject;
-						this.messageQueue.push(request.message);
-					} else request.reject(new RebaseApiError$1("Connection closed"));
 					this.pendingRequests.delete(reqId);
+					if (reqId.startsWith("auth_")) request.reject(/* @__PURE__ */ new Error("Connection closed during authentication"));
+					else request.reject(connectionLostError());
 				}
+				this.setState(this.outageReported ? "disconnected" : "reconnecting");
 				this.attemptReconnect();
 			};
 			this.ws.onerror = (error) => {
@@ -3098,14 +3594,16 @@ var RebaseWebSocketClient = class {
 		return true;
 	}
 	attemptReconnect() {
-		if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-			console.error("Max reconnection attempts reached");
+		if (this.closedByCaller) return;
+		if (this.reconnectAttempts >= this.lostAfterAttempts) this.reportConnectionLost();
+		if (this.reconnectAttempts >= this.maxReconnectAttempts && !this.hasRegistrations()) {
+			console.warn("[Rebase] Realtime: the server is unreachable and nothing is subscribed. Not retrying until something asks for the connection.");
 			this.gaveUp = true;
-			this.failAllPendingSubscriptions(new RebaseApiError$1("Connection lost", { code: "CONNECTION_LOST" }));
 			return;
 		}
-		this.reconnectAttempts++;
-		const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+		this.reconnectAttempts = Math.min(this.reconnectAttempts + 1, 30);
+		const ceiling = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), MAX_RECONNECT_DELAY_MS);
+		const delay = ceiling - Math.floor(Math.random() * ceiling * RECONNECT_JITTER);
 		console.debug(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
 		if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
 		this.reconnectTimeout = setTimeout(() => {
@@ -3113,6 +3611,60 @@ var RebaseWebSocketClient = class {
 			this.initWebSocket();
 		}, delay);
 	}
+	/**
+	* Whether anything depends on the socket coming back: a subscription, a
+	* joined channel, or a request whose caller is still waiting for a socket.
+	*/
+	hasRegistrations() {
+		return this.collectionSubscriptions.size > 0 || this.singleSubscriptions.size > 0 || this.channelHandlers.size > 0 || this.messageQueue.some((frame) => typeof frame._queuedReject === "function");
+	}
+	/**
+	* Tell every subscription and joined channel, once per outage, that the
+	* connection is down and their data is not updating.
+	*
+	* Registrations are kept — that is the difference from a subscribe that
+	* failed. When the socket is back they are re-subscribed, and the fresh
+	* `onUpdate` is the recovery.
+	*/
+	reportConnectionLost() {
+		if (this.outageReported) return;
+		this.outageReported = true;
+		this.setState("disconnected");
+		const error = realtimeLostError();
+		for (const subscription of this.collectionSubscriptions.values()) this.notifyError(subscription.callbacks, error);
+		for (const subscription of this.singleSubscriptions.values()) this.notifyError(subscription.callbacks, error);
+		for (const handler of [...this.connectionLostHandlers]) try {
+			handler(error);
+		} catch (handlerError) {
+			console.error("Error in connection-lost handler:", handlerError);
+		}
+	}
+	notifyError(callbacks, error) {
+		for (const callback of [...callbacks.values()]) {
+			if (!callback.onError) continue;
+			try {
+				callback.onError(error);
+			} catch (callbackError) {
+				console.error("Error in subscription error callback:", callbackError);
+			}
+		}
+	}
+	/**
+	* A listener attaching while an outage is being reported is told at once:
+	* its subscribe waits for a socket that may be minutes away, and nothing
+	* else would say so.
+	*/
+	reportOutageTo(onError) {
+		if (!this.outageReported || !onError) return;
+		queueMicrotask(() => {
+			if (!this.outageReported) return;
+			try {
+				onError(realtimeLostError());
+			} catch (callbackError) {
+				console.error("Error in subscription error callback:", callbackError);
+			}
+		});
+	}
 	isAuthError(message) {
 		if (message.type === "AUTH_ERROR") return true;
 		const { errorMessage, errorCode } = extractMessageError(message);
@@ -3359,20 +3911,62 @@ var RebaseWebSocketClient = class {
 	*/
 	sendMessage(message) {
 		const queuedMsg = message;
-		if (queuedMsg._queuedResolve && queuedMsg._queuedReject) return this.doSendMessage(message, queuedMsg._queuedResolve, queuedMsg._queuedReject);
-		if (!this.isConnected || !this.ws) {
-			this.ensureConnected();
-			return new Promise((resolve, reject) => {
-				const queueable = message;
-				queueable._queuedResolve = resolve;
-				queueable._queuedReject = reject;
-				this.messageQueue.push(message);
-			});
+		if (queuedMsg._queuedResolve && queuedMsg._queuedReject) {
+			const resolve = queuedMsg._queuedResolve;
+			const reject = queuedMsg._queuedReject;
+			delete queuedMsg._queuedResolve;
+			delete queuedMsg._queuedReject;
+			return this.doSendMessage(message, resolve, reject);
 		}
 		return new Promise((resolve, reject) => {
-			this.doSendMessage(message, resolve, reject);
+			let settled = false;
+			let deadline;
+			const onResolve = (value) => {
+				if (settled) return;
+				settled = true;
+				if (deadline) clearTimeout(deadline);
+				resolve(value);
+			};
+			const onReject = (error) => {
+				if (settled) return;
+				settled = true;
+				if (deadline) clearTimeout(deadline);
+				this.abandonedFrames.add(message);
+				reject(error);
+			};
+			if (this.expectsResponse(message)) deadline = setTimeout(() => {
+				const queuedAt = this.messageQueue.indexOf(message);
+				if (queuedAt >= 0) this.messageQueue.splice(queuedAt, 1);
+				let written = false;
+				for (const [requestId, pending] of this.pendingRequests) {
+					if (pending.message !== message) continue;
+					this.pendingRequests.delete(requestId);
+					written = true;
+				}
+				onReject(requestTimeoutError(written));
+			}, this.requestTimeoutMs);
+			if (!this.isConnected || !this.ws) {
+				this.ensureConnected();
+				queuedMsg._queuedResolve = onResolve;
+				queuedMsg._queuedReject = onReject;
+				this.messageQueue.push(message);
+				return;
+			}
+			this.doSendMessage(message, onResolve, onReject);
 		});
 	}
+	/**
+	* Frames whose caller has already been answered — timed out, or rejected
+	* by a close. One can still be on its way to the socket (awaiting
+	* authentication), and must not be written after its caller was told it
+	* failed.
+	*/
+	abandonedFrames = /* @__PURE__ */ new WeakSet();
+	/** Whether the server answers this frame with a response envelope. */
+	expectsResponse(message) {
+		const type = message.type;
+		return !(SUBSCRIPTION_MESSAGE_TYPES.has(type) || CHANNEL_MESSAGE_TYPES.has(type));
+	}
 	async doSendMessage(message, resolve, reject) {
 		const isSubscriptionFrame = SUBSCRIPTION_MESSAGE_TYPES.has(message.type);
 		if (message.type !== "AUTHENTICATE" && !CHANNEL_MESSAGE_TYPES.has(message.type) && this.getAuthToken && !this.isAuthenticated) try {
@@ -3383,28 +3977,23 @@ var RebaseWebSocketClient = class {
 				return;
 			}
 		}
+		if (this.abandonedFrames.has(message)) return;
+		if (!this.isConnected || !this.ws) {
+			const queueable = message;
+			queueable._queuedResolve = resolve;
+			queueable._queuedReject = reject;
+			this.messageQueue.push(message);
+			this.ensureConnected();
+			return;
+		}
 		const requestId = message.requestId || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 		message.requestId = requestId;
-		const expectsResponse = !(isSubscriptionFrame || CHANNEL_MESSAGE_TYPES.has(message.type));
-		if (expectsResponse && !this.pendingRequests.has(requestId)) {
-			const timeoutHandle = setTimeout(() => {
-				if (this.pendingRequests.has(requestId)) {
-					this.pendingRequests.delete(requestId);
-					reject(new RebaseApiError$1("Request timed out"));
-				}
-			}, this.requestTimeoutMs);
-			this.pendingRequests.set(requestId, {
-				resolve: (value) => {
-					clearTimeout(timeoutHandle);
-					resolve(value);
-				},
-				reject: (error) => {
-					clearTimeout(timeoutHandle);
-					reject(error);
-				},
-				message
-			});
-		}
+		const expectsResponse = this.expectsResponse(message);
+		if (expectsResponse && !this.pendingRequests.has(requestId)) this.pendingRequests.set(requestId, {
+			resolve,
+			reject,
+			message
+		});
 		try {
 			this.ws.send(JSON.stringify(message));
 			if (!expectsResponse) resolve(void 0);
@@ -3446,6 +4035,25 @@ var RebaseWebSocketClient = class {
 			}
 		})).result || [];
 	}
+	/**
+	* Run a script a person wrote — the Studio console — and get back what its
+	* last statement returned, every value as the database's text, with the
+	* table column each result column was read from. See
+	* `SQLAdmin.runSqlScript`.
+	*/
+	async runSqlScript(sql, options) {
+		return readSqlScriptResult(await this.sendMessage({
+			type: "EXECUTE_SQL",
+			payload: {
+				sql,
+				options: {
+					database: options?.database,
+					role: options?.role
+				},
+				mode: "script"
+			}
+		}));
+	}
 	async fetchAvailableDatabases() {
 		return (await this.sendMessage({
 			type: "FETCH_DATABASES",
@@ -3627,6 +4235,7 @@ var RebaseWebSocketClient = class {
 				onUpdate,
 				onError
 			});
+			this.reportOutageTo(onError);
 			if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) try {
 				onUpdate(existingSubscription.latestData, existingSubscription.latestMeta);
 			} catch (error) {
@@ -3654,6 +4263,7 @@ var RebaseWebSocketClient = class {
 			onUpdate,
 			onError
 		});
+		this.reportOutageTo(onError);
 		this.collectionSubscriptions.set(subscriptionKey, {
 			backendSubscriptionId,
 			callbacks: callbackMap,
@@ -3689,6 +4299,7 @@ var RebaseWebSocketClient = class {
 				onUpdate,
 				onError
 			});
+			this.reportOutageTo(onError);
 			if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) try {
 				onUpdate(existingSubscription.latestData);
 			} catch (error) {
@@ -3716,6 +4327,7 @@ var RebaseWebSocketClient = class {
 			onUpdate,
 			onError
 		});
+		this.reportOutageTo(onError);
 		this.singleSubscriptions.set(subscriptionKey, {
 			backendSubscriptionId,
 			callbacks: callbackMap,
@@ -3899,20 +4511,6 @@ var RebaseWebSocketClient = class {
 		}, this.subscriptionTimeoutMs);
 	}
 	/**
-	* Fail every subscription that never received data. Called when reconnection
-	* is given up on, so views surface an error instead of spinning forever.
-	*/
-	failAllPendingSubscriptions(error) {
-		for (const key of [...this.collectionSubscriptions.keys()]) {
-			const sub = this.collectionSubscriptions.get(key);
-			if (sub && !sub.isInitialDataReceived) this.failCollectionSubscription(key, error);
-		}
-		for (const key of [...this.singleSubscriptions.keys()]) {
-			const sub = this.singleSubscriptions.get(key);
-			if (sub && !sub.isInitialDataReceived) this.failEntitySubscription(key, error);
-		}
-	}
-	/**
 	* Re-send all active subscriptions to the backend after a reconnect.
 	* The server wipes subscription state when a client disconnects, so
 	* we need to re-register everything to resume receiving updates.
@@ -4100,6 +4698,8 @@ var RebaseRealtimeChannel = class {
 		this.unsubscribers.push(this.transport.onReconnect(() => {
 			this.rejoin();
 		}));
+		const onConnectionLost = this.transport.onConnectionLost?.((error) => this.emitError(error));
+		if (onConnectionLost) this.unsubscribers.push(onConnectionLost);
 		await this.send("join_channel");
 		await this.send("presence_state");
 		if (this.wantsHistory) await this.requestHistory();
@@ -4630,12 +5230,18 @@ var ConnectivityMonitor = class {
 	clearTimer;
 	/** Called when the backoff window expires, to drive an automatic retry. */
 	onRetryDue;
+	/**
+	* Called when the browser says the connection is back. Its own hook rather
+	* than {@link onRetryDue}: a client with automatic retries off sets no retry
+	* callback, and the `online` event has to wake it all the same.
+	*/
+	onOnline;
 	handleOnline = () => {
 		this.retryAt = 0;
 		this.backoffMs = this.initialBackoffMs;
 		this.clearPendingTimer();
 		this.setState("online");
-		this.onRetryDue?.();
+		(this.onOnline ?? this.onRetryDue)?.();
 	};
 	handleOffline = () => {
 		this.setState("offline");
@@ -4710,6 +5316,7 @@ var ConnectivityMonitor = class {
 		this.clearPendingTimer();
 		this.listeners.clear();
 		this.onRetryDue = void 0;
+		this.onOnline = void 0;
 	}
 	scheduleRetry(delay) {
 		this.clearPendingTimer();
@@ -5110,12 +5717,44 @@ function matchesOperator(rowValue, op, filterValue) {
 function isTuple(value) {
 	return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && toCanonicalOp(value[0]) !== void 0;
 }
+/**
+* One field's condition, as the tuples this evaluator can read.
+*
+* The single reading of a condition, for {@link matchesWhere} and
+* {@link isExactlyEvaluable} both. Each used to have its own, and only the
+* first was hardened: `{ status: undefined }` (a skipped filter) and the bare
+* wire string `"eq.active"` both reached `.filter` on a non-array in the
+* second and threw.
+*
+* `unreadable` is set when the condition is there but yields nothing this
+* build understands — a wire string, an operator from a newer server. Such a
+* condition filters nothing locally while the server does filter on it, so an
+* answer that ignored it would be wider than the server's.
+*/
+function conditionTuples(condition) {
+	if (condition === void 0) return {
+		tuples: [],
+		unreadable: false
+	};
+	if (isTuple(condition)) return {
+		tuples: [condition],
+		unreadable: false
+	};
+	if (!Array.isArray(condition)) return {
+		tuples: [],
+		unreadable: true
+	};
+	const tuples = condition.filter(isTuple);
+	return {
+		tuples,
+		unreadable: tuples.length !== condition.length || tuples.length === 0
+	};
+}
 /** Evaluate a `where` clause: every field, and every tuple on a field, AND-ed. */
 function matchesWhere(row, where) {
 	if (!where) return true;
 	for (const [field, condition] of Object.entries(where)) {
-		if (condition === void 0) continue;
-		const tuples = isTuple(condition) ? [condition] : Array.isArray(condition) ? condition.filter(isTuple) : [];
+		const { tuples } = conditionTuples(condition);
 		for (const [rawOp, value] of tuples) {
 			const op = toCanonicalOp(rawOp) ?? rawOp;
 			if (!matchesOperator(row[field], op, value)) return false;
@@ -5229,10 +5868,18 @@ var ORDERING_OPS = /* @__PURE__ */ new Set([
 	">",
 	">="
 ]);
-/** Does any condition in this `where` clause order its operands? */
-function whereOrders(where) {
+/**
+* Does any condition in this `where` clause order its operands — or say
+* something this evaluator cannot read at all? Either way the local answer is
+* not the server's.
+*/
+function whereNotExact(where) {
 	if (!where) return false;
-	for (const condition of Object.values(where)) if ((isTuple(condition) ? [condition] : condition.filter(isTuple)).some(([op]) => ORDERING_OPS.has(op))) return true;
+	for (const condition of Object.values(where)) {
+		const { tuples, unreadable } = conditionTuples(condition);
+		if (unreadable) return true;
+		if (tuples.some(([op]) => ORDERING_OPS.has(toCanonicalOp(op) ?? op))) return true;
+	}
 	return false;
 }
 /** The same question, through an `and(...)`/`or(...)` tree. */
@@ -5289,7 +5936,7 @@ function isExactlyEvaluable(params) {
 	if (hasAnyInclude(params.include)) return false;
 	if (params.searchString) return false;
 	if (params.vectorSearch) return false;
-	if (whereOrders(params.where)) return false;
+	if (whereNotExact(params.where)) return false;
 	if (logicalOrders(params.logical)) return false;
 	if (whereReachesThroughRelation(params.where)) return false;
 	if (logicalReachesThroughRelation(params.logical)) return false;
@@ -5370,6 +6017,27 @@ function offlineError(message) {
 		code: "OFFLINE"
 	});
 }
+/**
+* What a write discarded because an earlier write it depends on was refused is
+* reported with. It was never sent; the refusal that doomed it is its `cause`.
+*/
+function dependencyRejected(refused, error) {
+	return new RebaseApiError(`Not sent: an earlier queued write to the same row was refused (${error.message}).`, {
+		status: error instanceof RebaseApiError ? error.status : void 0,
+		code: "DEPENDENCY_REJECTED",
+		details: { rejectedMutationId: refused.mutationId },
+		cause: error
+	});
+}
+/**
+* A refusal about what a write contains — a field the collection no longer
+* has, one the caller may not write, a value a constraint refuses — rather
+* than about the row or the caller as a whole.
+*/
+function isFieldRefusal(error) {
+	if (!(error instanceof RebaseApiError)) return false;
+	return error.status === 400 || error.status === 403 || error.status === 422;
+}
 function generateOfflineStringId() {
 	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
 	return `off-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
@@ -5458,6 +6126,8 @@ var MISSING = "\0missing";
 * blocking the queue behind it indefinitely.
 */
 var IN_PROGRESS_MIN_RETRIES = 12;
+/** The scope of whatever is cached and queued while nobody is signed in. */
+var SIGNED_OUT_SCOPE = "anon";
 var OfflineManager = class {
 	store;
 	maxCachedQueries;
@@ -5467,7 +6137,27 @@ var OfflineManager = class {
 	createInner;
 	inners = /* @__PURE__ */ new Map();
 	connectivity;
-	scope = "anon";
+	scope = SIGNED_OUT_SCOPE;
+	/**
+	* Set while the manager does not know whose data it holds: from
+	* {@link holdScope} until the next {@link setScope}. `scope` is not
+	* consulted meanwhile — no operation gets a {@link ScopeTicket}, and
+	* nothing reads or writes the store.
+	*/
+	scopeHold;
+	/**
+	* Bumped by every change of user, and by `clear()`.
+	*
+	* The load paths always re-checked the scope after their awaits; the write
+	* paths did not. A `find` sent for user A that answered after B had signed
+	* in wrote A's RLS-filtered rows into B's local database, under B's keys,
+	* and showed them to B's observers; a replay acknowledged after the switch
+	* dequeued a key under B's scope that did not exist, so A's write stayed
+	* queued and was sent again when A came back. Every write now carries the
+	* {@link ScopeTicket} its operation started under, and one that is stale
+	* touches nothing that belongs to the new user.
+	*/
+	scopeEpoch = 0;
 	/** The local database: normalized rows and query snapshots per collection. */
 	collections = /* @__PURE__ */ new Map();
 	/** In-memory mirror of the current scope's queue, in replay order. */
@@ -5524,6 +6214,9 @@ var OfflineManager = class {
 		if (maxBackoffMs > 0) this.connectivity.onRetryDue = () => {
 			this.sync().catch(() => void 0);
 		};
+		this.connectivity.onOnline = () => {
+			this.sync().catch(() => void 0);
+		};
 		this.connectivity.onChange((online) => {
 			this.patchStatus({ online });
 			if (online) this.revalidateAll();
@@ -5536,7 +6229,12 @@ var OfflineManager = class {
 		} catch {}
 		this.api = {
 			sync: () => this.sync(),
-			pending: async () => {
+			pending: async (options) => {
+				if (options?.orphaned) {
+					await this.scopeKnown();
+					if (this.scope === SIGNED_OUT_SCOPE) return [];
+					return await this.store.listQueue(`${SIGNED_OUT_SCOPE}|`);
+				}
 				await this.ensureQueueLoaded();
 				return this.queue.map((m) => structuredClone(m));
 			},
@@ -5545,7 +6243,15 @@ var OfflineManager = class {
 				this.statusListeners.add(listener);
 				return () => this.statusListeners.delete(listener);
 			},
-			clear: async () => {
+			clear: async (options) => {
+				await this.scopeKnown();
+				if (options?.orphaned) {
+					if (this.scope === SIGNED_OUT_SCOPE) return;
+					await this.store.clear(`${SIGNED_OUT_SCOPE}|`);
+					this.broadcast({ type: "queue" }, SIGNED_OUT_SCOPE);
+					return;
+				}
+				this.scopeEpoch++;
 				await this.store.clear(`${this.scope}|`);
 				this.queue = [];
 				this.resetCollections();
@@ -5569,9 +6275,45 @@ var OfflineManager = class {
 	* across a sign-out/sign-in on a shared browser.
 	*/
 	setScope(uid) {
-		const next = uid || "anon";
-		if (next === this.scope) return;
+		const next = uid || SIGNED_OUT_SCOPE;
+		const hold = this.scopeHold;
+		if (!hold && next === this.scope) return;
 		this.scope = next;
+		this.scopeHold = void 0;
+		this.leaveScope();
+		hold?.release();
+		this.revalidateAll();
+		this.sync().catch(() => void 0);
+	}
+	/**
+	* Forget whose data this is until the next {@link setScope}.
+	*
+	* For the time before the client knows who is signed in — a session being
+	* restored on load. Taking that time for "signed out" would put the user's
+	* own writes in the signed-out queue, which no sign-in replays, and show
+	* them the signed-out local database instead of theirs.
+	*
+	* Meanwhile the manager has no scope at all. Every operation — a read, a
+	* write, a replay, `pending()`, `clear()` — waits for one and then runs
+	* for whoever it turns out to be, and nothing reads or writes the store.
+	* A realtime frame arriving in between is handed on as the server sent it
+	* and kept nowhere.
+	*/
+	holdScope() {
+		if (this.scopeHold) return;
+		let release;
+		const known = new Promise((resolve) => {
+			release = resolve;
+		});
+		this.scopeHold = {
+			known,
+			release
+		};
+		this.leaveScope();
+	}
+	/** Let go of the current user's rows and queue: in memory, and on screen. */
+	leaveScope() {
+		this.scopeEpoch++;
 		this.queueLoad = void 0;
 		this.queue = [];
 		this.resetCollections();
@@ -5581,8 +6323,34 @@ var OfflineManager = class {
 		});
 		this.notifyQueue();
 		for (const slug of this.observers.keys()) this.notifyCollection(slug, false);
-		this.revalidateAll();
-		this.sync().catch(() => void 0);
+	}
+	/** Settles once the manager knows whose data it holds — see {@link holdScope}. */
+	async scopeKnown() {
+		while (this.scopeHold) await this.scopeHold.known;
+	}
+	/**
+	* The user an operation is running for — see {@link scopeEpoch} — or
+	* nothing while that is not known ({@link holdScope}). An operation takes
+	* it as `this.ticket() ?? await this.nextTicket()`, before its first await.
+	*/
+	ticket() {
+		if (this.scopeHold) return void 0;
+		return {
+			scope: this.scope,
+			epoch: this.scopeEpoch
+		};
+	}
+	/** The ticket of whoever the held scope turns out to be. */
+	async nextTicket() {
+		await this.scopeKnown();
+		return {
+			scope: this.scope,
+			epoch: this.scopeEpoch
+		};
+	}
+	/** Whether an operation's user is still the signed-in one. */
+	isCurrent(ticket) {
+		return ticket.epoch === this.scopeEpoch;
 	}
 	/**
 	* Throw away every local row, for a scope change or an explicit clear.
@@ -5620,12 +6388,15 @@ var OfflineManager = class {
 		this.inners.set(slug, inner);
 		const wrapped = {
 			find: async (params) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				const state = await this.ensureCollection(slug);
 				if (this.connectivity.shouldAttempt()) try {
 					const res = await inner.find(params);
 					this.connectivity.markSuccess();
-					await this.ingest(slug, res.data ?? [], isProjection(params));
-					const snapshot = this.recordSnapshot(slug, params, res);
+					if (!this.isCurrent(ticket)) return res;
+					await this.ingest(slug, res.data ?? [], ticket, isProjection(params));
+					if (!this.isCurrent(ticket)) return res;
+					const snapshot = this.recordSnapshot(slug, params, res, ticket);
 					const answer = this.answer(slug, params, snapshot);
 					this.notifyCollection(slug, false);
 					return {
@@ -5655,12 +6426,14 @@ var OfflineManager = class {
 			iterate: (params) => paginateFind((p) => wrapped.find(p), params, slug),
 			findAll: (params) => collectAllPages((p) => wrapped.find(p), params, slug),
 			findById: async (id) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				if (this.connectivity.shouldAttempt()) try {
 					const row = await inner.findById(id);
 					this.connectivity.markSuccess();
-					if (row !== void 0) await this.ingest(slug, [row]);
-					else if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, true);
+					if (!this.isCurrent(ticket)) return row;
+					if (row !== void 0) await this.ingest(slug, [row], ticket);
+					else if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
 					this.notifyCollection(slug, false);
 					return this.localRow(slug, id);
 				} catch (error) {
@@ -5681,6 +6454,7 @@ var OfflineManager = class {
 				return row;
 			},
 			create: async (data, id, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
 				let sent = false;
@@ -5690,7 +6464,7 @@ var OfflineManager = class {
 						idempotencyKey
 					});
 					this.connectivity.markSuccess();
-					await this.ingest(slug, [row]);
+					await this.ingest(slug, [row], ticket);
 					this.notifyCollection(slug);
 					this.scheduleRefresh(slug);
 					return row;
@@ -5714,12 +6488,13 @@ var OfflineManager = class {
 						id
 					} } : {},
 					rollback: { rows: { [String(rowId)]: this.rawLocalRow(slug, rowId) ?? null } }
-				});
-				this.setLocalRow(slug, rowId, row);
+				}, ticket);
+				this.setLocalRow(slug, rowId, row, ticket);
 				this.notifyCollection(slug);
 				return row;
 			},
 			createMany: async (data, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				if (!Array.isArray(data)) throw new TypeError("createMany expects an array of records.");
 				if (data.length === 0) return [];
@@ -5731,7 +6506,7 @@ var OfflineManager = class {
 						idempotencyKey
 					});
 					this.connectivity.markSuccess();
-					await this.ingest(slug, rows);
+					await this.ingest(slug, rows, ticket);
 					this.notifyCollection(slug);
 					this.scheduleRefresh(slug);
 					return rows;
@@ -5758,8 +6533,8 @@ var OfflineManager = class {
 						...options?.onConflict?.length ? { onConflict: [...options.onConflict] } : {}
 					} } : {},
 					rollback: { rows: rollback }
-				});
-				for (const row of rows) this.setLocalRow(slug, row.id, row);
+				}, ticket);
+				for (const row of rows) this.setLocalRow(slug, row.id, row, ticket);
 				this.notifyCollection(slug);
 				return rows;
 			},
@@ -5775,11 +6550,12 @@ var OfflineManager = class {
 			* queue drains — the exact outcome upsert exists to prevent.
 			*/
 			upsert: async (data, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				if (this.connectivity.shouldAttempt()) try {
 					const row = await inner.upsert(data, options);
 					this.connectivity.markSuccess();
-					await this.ingest(slug, [row]);
+					await this.ingest(slug, [row], ticket);
 					this.notifyCollection(slug);
 					this.scheduleRefresh(slug);
 					return row;
@@ -5796,12 +6572,13 @@ var OfflineManager = class {
 					data: [row],
 					upsert: true,
 					rollback: { rows: { [String(rowId)]: this.rawLocalRow(slug, rowId) ?? null } }
-				});
-				this.setLocalRow(slug, rowId, row);
+				}, ticket);
+				this.setLocalRow(slug, rowId, row, ticket);
 				this.notifyCollection(slug);
 				return row;
 			},
 			updateMany: async (updates, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				if (!Array.isArray(updates)) throw new TypeError("updateMany expects an array of { id, data } entries.");
 				if (updates.length === 0) return [];
@@ -5809,7 +6586,7 @@ var OfflineManager = class {
 				if (this.connectivity.shouldAttempt() && !anyPending) try {
 					const rows = await inner.updateMany(updates, options);
 					this.connectivity.markSuccess();
-					await this.ingest(slug, rows);
+					await this.ingest(slug, rows, ticket);
 					this.notifyCollection(slug);
 					return rows;
 				} catch (error) {
@@ -5834,12 +6611,13 @@ var OfflineManager = class {
 						data: u.data
 					})),
 					rollback: { rows: rollback }
-				});
-				for (const row of optimistic) this.setLocalRow(slug, row.id, row);
+				}, ticket);
+				for (const row of optimistic) this.setLocalRow(slug, row.id, row, ticket);
 				this.notifyCollection(slug);
 				return optimistic;
 			},
 			deleteMany: async (ids, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				if (!Array.isArray(ids)) throw new TypeError("deleteMany expects an array of ids.");
 				if (ids.length === 0) return;
@@ -5847,7 +6625,7 @@ var OfflineManager = class {
 				if (this.connectivity.shouldAttempt() && !anyPending) try {
 					await inner.deleteMany(ids, options);
 					this.connectivity.markSuccess();
-					for (const id of ids) this.removeLocalRow(slug, id, true);
+					for (const id of ids) this.removeLocalRow(slug, id, ticket, true);
 					this.notifyCollection(slug);
 					this.scheduleRefresh(slug);
 					return;
@@ -5862,11 +6640,12 @@ var OfflineManager = class {
 					type: "deleteMany",
 					ids,
 					rollback: { rows: rollback }
-				});
-				for (const id of ids) this.removeLocalRow(slug, id, false);
+				}, ticket);
+				for (const id of ids) this.removeLocalRow(slug, id, ticket, false);
 				this.notifyCollection(slug);
 			},
 			update: async (id, data, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
 				let sent = false;
@@ -5877,7 +6656,7 @@ var OfflineManager = class {
 						idempotencyKey
 					});
 					this.connectivity.markSuccess();
-					await this.ingest(slug, [row]);
+					await this.ingest(slug, [row], ticket);
 					this.notifyCollection(slug);
 					return row;
 				} catch (error) {
@@ -5903,16 +6682,17 @@ var OfflineManager = class {
 					data,
 					...sent ? { sent: { idempotencyKey } } : {},
 					rollback: { rows: { [String(id)]: base ?? null } }
-				});
+				}, ticket);
 				const optimistic = optimisticRow({
 					...base ?? {},
 					...data
 				}, id);
-				this.setLocalRow(slug, id, optimistic);
+				this.setLocalRow(slug, id, optimistic, ticket);
 				this.notifyCollection(slug);
 				return optimistic;
 			},
 			delete: async (id, options) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
 				let sent = false;
@@ -5922,7 +6702,7 @@ var OfflineManager = class {
 						idempotencyKey
 					});
 					this.connectivity.markSuccess();
-					this.removeLocalRow(slug, id, true);
+					this.removeLocalRow(slug, id, ticket, true);
 					this.notifyCollection(slug);
 					this.scheduleRefresh(slug);
 					return;
@@ -5937,15 +6717,17 @@ var OfflineManager = class {
 					id,
 					...sent ? { sent: { idempotencyKey } } : {},
 					rollback: { rows: { [String(id)]: this.rawLocalRow(slug, id) ?? null } }
-				});
-				this.removeLocalRow(slug, id);
+				}, ticket);
+				this.removeLocalRow(slug, id, ticket);
 				this.notifyCollection(slug);
 			},
 			count: async (params) => {
+				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
 				if (this.connectivity.shouldAttempt()) try {
 					const n = await inner.count(params);
 					this.connectivity.markSuccess();
+					if (!this.isCurrent(ticket)) return n;
 					this.writeCache(this.countKey(slug, params), n);
 					return Math.max(0, n + this.pendingDelta(slug, params));
 				} catch (error) {
@@ -5979,12 +6761,40 @@ var OfflineManager = class {
 			listenById: inner.listenById
 		};
 		if (!isUnsupported(inner.listen)) wrapped.listen = (params, onUpdate, onError) => inner.listen(params, (response) => {
-			this.ingest(slug, response.data ?? [], isProjection(params)).then(() => this.notifyCollection(slug, false));
-			onUpdate(response);
+			const ticket = this.ticket();
+			if (!ticket) {
+				onUpdate(response);
+				return;
+			}
+			this.ingest(slug, response.data ?? [], ticket, isProjection(params)).then(() => {
+				if (!this.isCurrent(ticket)) return;
+				const snapshot = this.recordSnapshot(slug, params, response, ticket);
+				const answer = this.answer(slug, params, snapshot);
+				this.notifyCollection(slug, false);
+				onUpdate({
+					...response,
+					data: answer.data,
+					meta: answer.meta
+				});
+			});
 		}, onError);
 		if (!isUnsupported(inner.listenById)) wrapped.listenById = (id, onUpdate, onError) => inner.listenById(id, (row) => {
-			if (row) this.ingest(slug, [row]).then(() => this.notifyCollection(slug, false));
-			onUpdate(row);
+			const ticket = this.ticket();
+			if (!ticket) {
+				onUpdate(row);
+				return;
+			}
+			if (!row) {
+				if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
+				this.notifyCollection(slug, false);
+				onUpdate(row);
+				return;
+			}
+			this.ingest(slug, [row], ticket).then(() => {
+				if (!this.isCurrent(ticket)) return;
+				this.notifyCollection(slug, false);
+				onUpdate(this.localRow(slug, id) ?? row);
+			});
 		}, onError);
 		return wrapped;
 	}
@@ -6028,8 +6838,10 @@ var OfflineManager = class {
 			if (!closed) observer.emit();
 		})();
 		if (options?.realtime !== false && !isUnsupported(inner.listen)) unlisten = inner.listen(params, (response) => {
-			this.ingest(slug, response.data ?? [], isProjection(params)).then(() => {
-				this.recordSnapshot(slug, params, response);
+			const ticket = this.ticket();
+			if (!ticket) return;
+			this.ingest(slug, response.data ?? [], ticket, isProjection(params)).then(() => {
+				this.recordSnapshot(slug, params, response, ticket);
 				this.notifyCollection(slug, false);
 			});
 		}, onError);
@@ -6080,12 +6892,14 @@ var OfflineManager = class {
 			if (!closed) observer.emit();
 		})();
 		if (options?.realtime !== false && !isUnsupported(inner.listenById)) unlisten = inner.listenById(id, (row) => {
+			const ticket = this.ticket();
+			if (!ticket) return;
 			if (!row) {
-				if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, true);
+				if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
 				this.notifyCollection(slug, false);
 				return;
 			}
-			this.ingest(slug, [row]).then(() => this.notifyCollection(slug, false));
+			this.ingest(slug, [row], ticket).then(() => this.notifyCollection(slug, false));
 		}, onError);
 		return () => {
 			closed = true;
@@ -6141,6 +6955,7 @@ var OfflineManager = class {
 		return state;
 	}
 	ensureCollection(slug) {
+		if (this.scopeHold) return this.scopeKnown().then(() => this.ensureCollection(slug));
 		const state = this.collectionState(slug);
 		if (!state.loaded) {
 			const scope = this.scope;
@@ -6361,7 +7176,8 @@ var OfflineManager = class {
 	localRow(slug, id) {
 		return this.collections.get(slug)?.rows.get(String(id))?.row;
 	}
-	setLocalRow(slug, id, row) {
+	setLocalRow(slug, id, row, ticket) {
+		if (!this.isCurrent(ticket)) return;
 		const state = this.collectionState(slug);
 		const key = String(id);
 		const cachedAt = Date.now();
@@ -6381,7 +7197,8 @@ var OfflineManager = class {
 	* it, opening a deleted row while offline would report a missing local
 	* database instead of a missing row.
 	*/
-	removeLocalRow(slug, id, known = false) {
+	removeLocalRow(slug, id, ticket, known = false) {
+		if (!this.isCurrent(ticket)) return;
 		const state = this.collectionState(slug);
 		const key = String(id);
 		const existed = state.rows.delete(key);
@@ -6411,9 +7228,10 @@ var OfflineManager = class {
 	* wrote the narrowed copy to disk, so a list lost its columns because a
 	* dropdown elsewhere asked for titles.
 	*/
-	async ingest(slug, rows, projection = false) {
-		if (rows.length === 0) return;
+	async ingest(slug, rows, ticket, projection = false) {
+		if (rows.length === 0 || !this.isCurrent(ticket)) return;
 		const state = await this.ensureCollection(slug);
+		if (!this.isCurrent(ticket)) return;
 		const cachedAt = Date.now();
 		const writes = [];
 		const deletes = [];
@@ -6486,7 +7304,7 @@ var OfflineManager = class {
 		}
 		return row;
 	}
-	recordSnapshot(slug, params, result) {
+	recordSnapshot(slug, params, result, ticket) {
 		const window = resolvePagination(params);
 		const meta = result.meta ?? {
 			total: result.data?.length ?? 0,
@@ -6501,6 +7319,7 @@ var OfflineManager = class {
 			hasMore: meta.hasMore ?? false,
 			...isProjection(params) ? { rows: (result.data ?? []).map((row) => ({ ...row })) } : {}
 		};
+		if (!this.isCurrent(ticket)) return snapshot;
 		const state = this.collectionState(slug);
 		const key = buildQueryString(params);
 		state.snapshots.set(key, snapshot);
@@ -6556,6 +7375,7 @@ var OfflineManager = class {
 		this.deleteCache(doomed.map((key) => `${this.scope}|q|${slug}|${key}`));
 	}
 	ensureQueueLoaded() {
+		if (this.scopeHold) return this.scopeKnown().then(() => this.ensureQueueLoaded());
 		if (!this.queueLoad) {
 			const scope = this.scope;
 			this.queueLoad = this.store.listQueue(`${scope}|`).then((queue) => {
@@ -6567,12 +7387,22 @@ var OfflineManager = class {
 		}
 		return this.queueLoad;
 	}
-	enqueue(mutation) {
+	enqueue(mutation, ticket) {
 		const result = this.enqueueChain.then(async () => {
 			await this.ensureQueueLoaded();
+			if (!this.isCurrent(ticket)) {
+				const orphan = {
+					...mutation,
+					mutationId: createMutationId(),
+					queuedAt: Date.now()
+				};
+				await this.store.enqueue(`${ticket.scope}|${orphan.mutationId}`, orphan);
+				return;
+			}
 			if (mutation.type === "update") {
 				const tail = this.queue[this.queue.length - 1];
 				if (tail && tail.mutationId !== this.inFlightId && tail.sent === void 0 && tail.collection === mutation.collection && (tail.type === "create" || tail.type === "update") && tail.id === mutation.id) {
+					if (tail.type === "update") tail.parts = [...tail.parts ?? [{ ...tail.data }], { ...mutation.data }];
 					tail.data = {
 						...tail.data,
 						...mutation.data,
@@ -6639,12 +7469,14 @@ var OfflineManager = class {
 	}
 	sync() {
 		if (this.flushPromise) return this.flushPromise;
-		this.flushPromise = this.withLock(() => this.flush()).finally(() => {
+		const run = () => this.withLock(() => this.flush());
+		this.flushPromise = (this.scopeHold ? this.scopeKnown().then(run) : run()).finally(() => {
 			this.flushPromise = void 0;
 		});
 		return this.flushPromise;
 	}
 	async flush() {
+		const ticket = this.ticket() ?? await this.nextTicket();
 		await this.ensureQueueLoaded();
 		await this.reloadQueue();
 		if (this.queue.length === 0) return {
@@ -6656,13 +7488,13 @@ var OfflineManager = class {
 		const queuedAtStart = this.queue.length;
 		let flushed = 0;
 		try {
-			while (this.queue.length > 0 && !this.disposed) {
+			while (this.queue.length > 0 && !this.disposed && this.isCurrent(ticket)) {
 				const op = this.queue[0];
 				touched.add(op.collection);
 				this.inFlightId = op.mutationId;
 				try {
 					try {
-						await this.replay(op);
+						await this.replay(op, ticket);
 					} catch (error) {
 						if (isNetworkError(error)) {
 							this.connectivity.markFailure();
@@ -6672,16 +7504,20 @@ var OfflineManager = class {
 						op.lastError = error?.message ?? String(error);
 						const limit = isIdempotencyInProgressError(error) ? Math.max(this.maxRetries, IN_PROGRESS_MIN_RETRIES) : this.maxRetries;
 						if (isRetryableError(error) && op.attempts < limit) {
-							await this.store.enqueue(this.queueKey(op), op).catch(() => void 0);
+							await this.store.enqueue(`${ticket.scope}|${op.mutationId}`, op).catch(() => void 0);
 							this.connectivity.deferRetry();
 							this.patchStatus({ lastError: op.lastError });
 							break;
 						}
-						await this.rejectMutation(op, error);
+						if (isFieldRefusal(error) && (op.parts?.length ?? 0) > 1) {
+							await this.splitCoalesced(op, ticket);
+							continue;
+						}
+						await this.rejectMutation(op, error, ticket);
 						continue;
 					}
 					this.connectivity.markSuccess();
-					await this.drop(op);
+					await this.drop(op, ticket);
 					flushed++;
 				} finally {
 					this.inFlightId = null;
@@ -6690,6 +7526,10 @@ var OfflineManager = class {
 		} finally {
 			this.patchStatus({ syncing: false });
 		}
+		if (!this.isCurrent(ticket)) return {
+			flushed,
+			remaining: this.queue.length
+		};
 		if (this.queue.length !== queuedAtStart) {
 			for (const slug of touched) {
 				this.notifyCollection(slug);
@@ -6703,7 +7543,7 @@ var OfflineManager = class {
 			remaining: this.queue.length
 		};
 	}
-	async replay(op) {
+	async replay(op, ticket) {
 		const inner = this.innerFor(op.collection);
 		if (op.type === "create") {
 			let row;
@@ -6711,10 +7551,10 @@ var OfflineManager = class {
 				row = await this.sendQueuedWrite(op, (idempotencyKey) => inner.create(op.data, void 0, { idempotencyKey }), (sent) => inner.create(sent.data, sent.id, { idempotencyKey: sent.idempotencyKey }));
 			} catch (error) {
 				if (!(op.generatedId === true && isDuplicateKeyError(error))) throw error;
-				row = await inner.findById(op.id).catch(() => void 0);
-				if (!row) return;
+				row = await inner.findById(op.id);
+				if (!row) throw error;
 			}
-			await this.adoptServerRow(op, op.id, row);
+			await this.adoptServerRow(op, op.id, row, ticket);
 		} else if (op.type === "createMany") {
 			const queued = op.data ?? [];
 			const asSent = (sent) => inner.createMany(sent.data, {
@@ -6726,24 +7566,24 @@ var OfflineManager = class {
 				...op.upsert ? { upsert: true } : {},
 				idempotencyKey
 			}), asSent);
-			for (let i = 0; i < rows.length; i++) await this.adoptServerRow(op, queued[i]?.id, rows[i]);
+			for (let i = 0; i < rows.length; i++) await this.adoptServerRow(op, queued[i]?.id, rows[i], ticket);
 		} else if (op.type === "updateMany") {
 			const queued = op.updates ?? [];
 			const rows = await inner.updateMany(queued.map((u) => ({
 				id: u.id,
 				data: u.data
 			})), { idempotencyKey: op.mutationId });
-			for (let i = 0; i < rows.length; i++) await this.ingestReplaced(op, queued[i].id, rows[i]);
+			for (let i = 0; i < rows.length; i++) await this.ingestReplaced(op, queued[i].id, rows[i], ticket);
 		} else if (op.type === "update") {
 			const row = await inner.update(op.id, op.data, op.sent ? { idempotencyKey: op.sent.idempotencyKey } : void 0);
-			await this.ingestReplaced(op, op.id, row);
+			await this.ingestReplaced(op, op.id, row, ticket);
 		} else if (op.type === "deleteMany") {
 			const ids = op.ids ?? [];
 			await inner.deleteMany(ids, { idempotencyKey: op.mutationId });
-			for (const id of ids) this.removeLocalRow(op.collection, id, true);
+			for (const id of ids) this.removeLocalRow(op.collection, id, ticket, true);
 		} else if (op.type === "delete") {
 			await inner.delete(op.id, { idempotencyKey: op.sent?.idempotencyKey ?? op.mutationId });
-			this.removeLocalRow(op.collection, op.id, true);
+			this.removeLocalRow(op.collection, op.id, ticket, true);
 		}
 	}
 	/**
@@ -6772,14 +7612,15 @@ var OfflineManager = class {
 	* has to move with it, including queued writes that were made against it
 	* before it was ever sent.
 	*/
-	async adoptServerRow(op, localId, row) {
+	async adoptServerRow(op, localId, row, ticket) {
 		if (!row) return;
 		const slug = op.collection;
 		const serverId = row.id;
 		if (localId !== void 0 && serverId !== void 0 && String(serverId) !== String(localId)) {
 			const oldKey = String(localId);
-			this.removeLocalRow(slug, localId);
-			for (const queued of this.queue) {
+			this.removeLocalRow(slug, localId, ticket);
+			const queue = this.isCurrent(ticket) ? this.queue : await this.store.listQueue(`${ticket.scope}|`).catch(() => []);
+			for (const queued of queue) {
 				if (queued.collection !== slug) continue;
 				let dirty = false;
 				if (queued.id !== void 0 && String(queued.id) === oldKey) {
@@ -6793,10 +7634,10 @@ var OfflineManager = class {
 					delete rollbackRows[oldKey];
 					dirty = true;
 				}
-				if (dirty) await this.store.enqueue(this.queueKey(queued), queued).catch(() => void 0);
+				if (dirty) await this.store.enqueue(`${ticket.scope}|${queued.mutationId}`, queued).catch(() => void 0);
 			}
 		}
-		await this.ingestReplaced(op, serverId ?? localId, row);
+		await this.ingestReplaced(op, serverId ?? localId, row, ticket);
 	}
 	/**
 	* Write a server row over the local one, ignoring the mutation that just
@@ -6806,13 +7647,15 @@ var OfflineManager = class {
 	* back to the server's version in front of the user, only to change again
 	* when they replay a moment later.
 	*/
-	async ingestReplaced(op, id, row) {
+	async ingestReplaced(op, id, row, ticket) {
+		if (!this.isCurrent(ticket)) return;
 		const slug = op.collection;
 		const state = await this.ensureCollection(slug);
+		if (!this.isCurrent(ticket)) return;
 		const key = String(id);
 		const merged = this.applyPendingToRow(slug, key, { ...row }, op.mutationId);
 		if (merged === void 0) {
-			this.removeLocalRow(slug, key);
+			this.removeLocalRow(slug, key, ticket);
 			return;
 		}
 		const cachedAt = Date.now();
@@ -6836,7 +7679,8 @@ var OfflineManager = class {
 	* of it, so both stand on their own and are kept — dropping them would
 	* silently lose writes the server would have accepted.
 	*/
-	async rejectMutation(op, error) {
+	async rejectMutation(op, error, ticket) {
+		if (!this.isCurrent(ticket)) return;
 		const ids = new Set(Object.keys(op.rollback?.rows ?? {}));
 		if (op.id !== void 0) ids.add(String(op.id));
 		const doomed = [op];
@@ -6849,24 +7693,61 @@ var OfflineManager = class {
 			if (later.type === "update") doomed.push(later);
 			else for (const id of hit) orphaned.delete(id);
 		}
-		for (const dropped of doomed) await this.drop(dropped);
+		for (const dropped of doomed) await this.drop(dropped, ticket);
+		if (!this.isCurrent(ticket)) return;
 		for (const [idKey, previous] of Object.entries(op.rollback?.rows ?? {})) {
 			const restored = this.applyPendingToRow(op.collection, idKey, previous ?? void 0);
-			if (restored === void 0) this.removeLocalRow(op.collection, idKey);
-			else this.setLocalRow(op.collection, idKey, restored);
+			if (restored === void 0) this.removeLocalRow(op.collection, idKey, ticket);
+			else this.setLocalRow(op.collection, idKey, restored, ticket);
 		}
 		this.patchStatus({ lastError: error.message });
 		this.notifyCollection(op.collection);
 		this.scheduleRefresh(op.collection);
-		for (const dropped of doomed) this.onSyncError?.(error, dropped);
+		for (const dropped of doomed) this.onSyncError?.(dropped === op ? error : dependencyRejected(op, error), dropped);
+	}
+	/**
+	* Put the separate edits a coalesced `update` was made of back in the
+	* queue, in its place and in their order, each with the row as it stood
+	* before it as its rollback — so a refusal undoes that edit alone.
+	*
+	* Their ids extend the merged op's, which sorts them after it and before
+	* whatever was queued next, so the queue's order survives a reload.
+	*/
+	async splitCoalesced(op, ticket) {
+		const parts = op.parts ?? [];
+		const idKey = String(op.id);
+		let before = op.rollback?.rows?.[idKey] ?? null;
+		const pieces = parts.map((part, index) => {
+			const piece = {
+				mutationId: `${op.mutationId}:${index}`,
+				collection: op.collection,
+				type: "update",
+				id: op.id,
+				data: { ...part },
+				queuedAt: op.queuedAt,
+				rollback: { rows: { [idKey]: before === null ? null : { ...before } } }
+			};
+			if (before !== null) before = {
+				...before,
+				...part
+			};
+			return piece;
+		});
+		for (const piece of pieces) await this.store.enqueue(`${ticket.scope}|${piece.mutationId}`, piece).catch(() => void 0);
+		await this.store.dequeue(`${ticket.scope}|${op.mutationId}`).catch(() => void 0);
+		if (!this.isCurrent(ticket)) return;
+		const position = this.queue.indexOf(op);
+		this.queue.splice(position < 0 ? 0 : position, position < 0 ? 0 : 1, ...pieces);
+		this.afterQueueChange(false);
 	}
 	/** Every row id a mutation writes to. */
 	idsOf(op) {
 		if (op.type === "createMany") return (op.data ?? []).map((r) => String(r.id));
 		return op.id === void 0 ? [] : [String(op.id)];
 	}
-	async drop(op) {
-		await this.store.dequeue(this.queueKey(op)).catch(() => void 0);
+	async drop(op, ticket) {
+		await this.store.dequeue(`${ticket.scope}|${op.mutationId}`).catch(() => void 0);
+		if (!this.isCurrent(ticket)) return;
 		this.queue = this.queue.filter((m) => m.mutationId !== op.mutationId);
 		this.afterQueueChange(false);
 	}
@@ -6888,12 +7769,12 @@ var OfflineManager = class {
 			return fn();
 		}
 	}
-	broadcast(message) {
+	broadcast(message, scope = this.scope) {
 		if (!this.channel) return;
 		try {
 			this.channel.postMessage({
 				...message,
-				scope: this.scope,
+				scope,
 				sender: this.tabId
 			});
 		} catch {}
@@ -6901,14 +7782,14 @@ var OfflineManager = class {
 	onBroadcast(message) {
 		if (this.disposed || !message || typeof message !== "object") return;
 		const msg = message;
-		if (msg.sender === this.tabId || msg.scope !== this.scope) return;
+		if (this.scopeHold || msg.sender === this.tabId || msg.scope !== this.scope) return;
 		if (msg.type === "rows") for (const slug of msg.slugs ?? []) this.reloadCollection(slug);
 		else if (msg.type === "queue") this.reloadQueue();
 	}
 	/** Re-read one collection from the store, replacing what is in memory. */
 	async reloadCollection(slug) {
 		const state = this.collections.get(slug);
-		if (!state?.loaded) return;
+		if (!state?.loaded || this.scopeHold) return;
 		await this.reloadQueue();
 		const scope = this.scope;
 		const [rows, snapshots, absent] = await Promise.all([
@@ -6941,6 +7822,7 @@ var OfflineManager = class {
 		this.notifyCollection(slug, false);
 	}
 	async reloadQueue() {
+		if (this.scopeHold) return;
 		const scope = this.scope;
 		const queue = await this.store.listQueue(`${scope}|`).catch(() => void 0);
 		if (!queue || this.scope !== scope) return;
@@ -7042,6 +7924,7 @@ function createRebaseClient(options) {
 	const cron = createCron(transport, options.cron);
 	const backups = createBackups(transport);
 	const apiKeys = createApiKeys(transport, options.apiKeys);
+	const personalKeys = createPersonalKeys(transport, options.personalKeys);
 	const storage = createStorage(transport);
 	const functions = createFunctionsClient(transport);
 	const createStorageSource = (storageId) => storageId === DEFAULT_STORAGE_SOURCE_KEY ? storage : createStorage(transport, storageId);
@@ -7081,7 +7964,8 @@ function createRebaseClient(options) {
 				}
 				return session?.accessToken || options.token || "";
 			},
-			onUnauthorized: options.onUnauthorized || (() => auth.handleUnauthorized())
+			onUnauthorized: options.onUnauthorized || (() => auth.handleUnauthorized()),
+			impersonate: options.impersonate
 		});
 		let realtimeUid = auth.getSession()?.user?.uid ?? null;
 		auth.onAuthStateChange((event, session) => {
@@ -7142,10 +8026,11 @@ function createRebaseClient(options) {
 	}
 	const offlineManager = options.offline ? new OfflineManager(typeof options.offline === "object" ? options.offline : {}, (slug) => createCollectionClient(transport, slug)) : void 0;
 	if (offlineManager) {
-		offlineManager.setScope(auth.getSession()?.user?.uid);
+		offlineManager.holdScope();
 		auth.onAuthStateChange((event, session) => {
 			offlineManager.setScope(event === "SIGNED_OUT" ? void 0 : session?.user?.uid);
 		});
+		auth.isInitialized().then(() => offlineManager.setScope(auth.getSession()?.user?.uid));
 	}
 	const collectionClients = /* @__PURE__ */ new Map();
 	let untypedWarned = false;
@@ -7188,6 +8073,7 @@ function createRebaseClient(options) {
 		cron,
 		backups,
 		apiKeys,
+		personalKeys,
 		functions,
 		storage,
 		storageRegistry,
@@ -7240,18 +8126,27 @@ channel: (name, options) => {
 				body: payload !== void 0 ? JSON.stringify(payload) : void 0
 			});
 		},
-		batch: async (operations, options) => {
+		batch: async (operations, batchOptions) => {
 			if (!Array.isArray(operations)) throw new TypeError("batch expects an array of operations.");
 			if (operations.length === 0) return {
 				data: [],
 				meta: { operations: 0 }
 			};
 			const headers = {};
-			if (options?.idempotencyKey) headers["Idempotency-Key"] = options.idempotencyKey;
-			if (options?.returning === false) headers.Prefer = "return=minimal";
+			if (batchOptions?.idempotencyKey) headers["Idempotency-Key"] = batchOptions.idempotencyKey;
+			if (batchOptions?.returning === false) headers.Prefer = "return=minimal";
+			const dictionary = options.collections;
+			const wire = dictionary ? operations.map((operation) => {
+				if (!operation || typeof operation !== "object") return operation;
+				const name = operation.collection;
+				return typeof name === "string" && Object.hasOwn(dictionary, name) ? {
+					...operation,
+					collection: dictionary[name]
+				} : operation;
+			}) : operations;
 			return transport.request("/data/_batch", {
 				method: "POST",
-				body: JSON.stringify({ operations }),
+				body: JSON.stringify({ operations: wire }),
 				...Object.keys(headers).length > 0 ? { headers } : {}
 			});
 		},
@@ -7260,6 +8155,6 @@ channel: (name, options) => {
 	};
 }
 //#endregion
-export { MemoryOfflineStore, QueryBuilder, RebaseApiError, RebaseClientError, RebasePaginationError, RebaseRealtimeChannel, RebaseWebSocketClient, and, cond, createBackups, createCookieStorage, createMemoryStorage, createRebaseClient, etagOf, isOfflineError, not, or };
+export { MemoryOfflineStore, QueryBuilder, RebaseApiError, RebaseClientError, RebasePaginationError, RebaseRealtimeChannel, RebaseWebSocketClient, STORAGE_REFERENCE_SCHEME, and, cond, createBackups, createCookieStorage, createMemoryStorage, createRebaseClient, etagOf, isOfflineError, isStorageReference, not, or, parseStorageReference, resolveStorageReferences, storageReference };
 
 //# sourceMappingURL=index.es.js.map