@rebasepro/server 0.9.1-canary.f2f61da → 0.9.1-canary.faee831

package/dist/index.es.js

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "module";
 import process from "process";
 __createRequire(import.meta.url);
-import { a as getAccessTokenExpiry, d as require_jsonwebtoken, f as __commonJSMin, h as __toESM, i as generateRefreshToken, l as verifyAccessToken, m as __require, n as generateAccessToken, o as getRefreshTokenExpiry, p as __exportAll, r as generateDownloadToken, s as hashRefreshToken, t as configureJwt, u as verifyDownloadToken } from "./jwt-BJzQOa8a.js";
+import { a as getAccessTokenExpiry, d as require_jsonwebtoken, f as __commonJSMin, h as __toESM, i as generateRefreshToken, l as verifyAccessToken, m as __require, n as generateAccessToken, o as getRefreshTokenExpiry, p as __exportAll, r as generateDownloadToken, s as hashRefreshToken, t as configureJwt, u as verifyDownloadToken } from "./jwt-B3zjddCa.js";
 import { _ as RebaseApiError, a as policy, c as isPostgresCollectionConfig, d as REST_TO_CANONICAL, f as toCanonicalOp, g as Vector, h as GeoPoint, i as isSQLAdmin, l as CANONICAL_TO_REST, m as EntityRelation, o as getCollectionDataPath, p as EntityReference, r as getDataSourceCapabilities, s as getDeclaredSubcollections, t as DEFAULT_STORAGE_SOURCE_KEY, u as NULL_OPS, v as RebaseClientError } from "./src-CsHhSKbi.js";
 import { t as logger } from "./logger-BYU66ENZ.js";
 import { t as nativeDynamicImport } from "./dynamic-import-Dvh-K5fl.js";
@@ -3305,7 +3305,7 @@ var BackendCollectionRegistry = class extends CollectionRegistry {
 //#endregion
 //#region src/collections/loader.ts
 function isCollectionFile(file) {
-	return (file.endsWith(".ts") || file.endsWith(".js")) && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js";
+	return (file.endsWith(".ts") || file.endsWith(".js")) && !file.startsWith(".") && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js";
 }
 async function importModule(filePath) {
 	return await import(pathToFileURL(filePath).href);
@@ -4472,10 +4472,10 @@ async function validateApiKey(c, token, options) {
 		message: "API key has expired",
 		code: "UNAUTHORIZED"
 	} }, 401);
-	const userId = `api-key:${apiKey.id}`;
+	const uid = `api-key:${apiKey.id}`;
 	const roles = apiKey.admin ? ["admin", "service"] : ["service"];
 	c.set("user", {
-		userId,
+		uid,
 		roles
 	});
 	const masked = {
@@ -4495,7 +4495,7 @@ async function validateApiKey(c, token, options) {
 	c.set("apiKey", masked);
 	try {
 		const scopedDriver = await scopeDataDriver(driver, {
-			uid: userId,
+			uid,
 			roles
 		});
 		c.set("driver", scopedDriver);
@@ -4663,7 +4663,7 @@ function createRequireAuth(options) {
 		const token = authHeader.substring(7);
 		if (safeCompare(token, key)) {
 			c.set("user", {
-				userId: "service",
+				uid: "service",
 				roles: ["admin"]
 			});
 			return next();
@@ -4742,11 +4742,11 @@ function createAuthMiddleware(options) {
 		if (validator) try {
 			const authResult = await validator(c);
 			if (authResult && typeof authResult === "object") {
-				const id = ("userId" in authResult ? authResult.userId : void 0) || ("uid" in authResult ? authResult.uid : void 0);
+				const id = ("uid" in authResult ? authResult.uid : void 0) || ("userId" in authResult ? authResult.userId : void 0);
 				if (id) {
 					const roles = authResult.roles || [];
 					c.set("user", {
-						userId: id,
+						uid: id,
 						roles
 					});
 					const user = {
@@ -4761,7 +4761,7 @@ function createAuthMiddleware(options) {
 				}));
 			} else if (authResult === true) {
 				c.set("user", {
-					userId: "default",
+					uid: "default",
 					roles: []
 				});
 				c.set("driver", await scopeDataDriver(driver, {
@@ -4784,7 +4784,7 @@ function createAuthMiddleware(options) {
 				const token = authHeader.substring(7);
 				if (serviceKey && safeCompare(token, serviceKey)) {
 					c.set("user", {
-						userId: "service",
+						uid: "service",
 						roles: ["admin"]
 					});
 					try {
@@ -4811,7 +4811,7 @@ function createAuthMiddleware(options) {
 						c.set("user", payload);
 						try {
 							const user = {
-								uid: payload.userId,
+								uid: payload.uid,
 								roles: payload.roles
 							};
 							c.set("driver", await scopeDataDriver(driver, user));
@@ -4892,7 +4892,7 @@ var publicObjectAuth = async (c, next) => {
 	const idx = fullPath.indexOf(prefix);
 	const rawPath = idx < 0 ? "" : fullPath.substring(idx + prefix.length + 1);
 	if (rawPath && isPublicStoragePath(decodeURIComponent(rawPath))) c.set("user", {
-		userId: "public",
+		uid: "public",
 		roles: ["public"]
 	});
 	return next();
@@ -4958,7 +4958,7 @@ var fileTokenAuth = async (c, next) => {
 				const { bucket, resolvedPath } = parseBucketPath(decodeURIComponent(rawPath));
 				if (isPathMatch(`${bucket}/${resolvedPath}`, payload.path)) {
 					c.set("user", {
-						userId: "download-token",
+						uid: "download-token",
 						roles: ["reader"]
 					});
 					return next();
@@ -4982,7 +4982,7 @@ var fileTokenAuth = async (c, next) => {
 				const { bucket, resolvedPath } = parseBucketPath(decodeURIComponent(rawPath));
 				if (isPathMatch(`${bucket}/${resolvedPath}`, payload.path)) {
 					c.set("user", {
-						userId: "download-token",
+						uid: "download-token",
 						roles: ["reader"]
 					});
 					return next();
@@ -5031,7 +5031,7 @@ function createAdapterAuthMiddleware(options) {
 		}
 		if (authenticatedUser) {
 			c.set("user", {
-				userId: authenticatedUser.uid,
+				uid: authenticatedUser.uid,
 				email: authenticatedUser.email,
 				roles: authenticatedUser.roles
 			});
@@ -5914,14 +5914,14 @@ function createDataRateLimiter(config = {}) {
 			const key = c.get("apiKey");
 			if (key) return `api-key:${key.id}`;
 			const user = c.get("user");
-			if (user?.userId && user.userId !== "anon") return `user:${user.userId}`;
+			if (user?.uid && user.uid !== "anon") return `user:${user.uid}`;
 			return `ip:${defaultKeyGenerator(c)}`;
 		},
 		resolveLimit: (c) => {
 			const key = c.get("apiKey");
 			if (key) return key.rate_limit ?? apiKeyLimit;
 			const user = c.get("user");
-			if (user?.userId && user.userId !== "anon") return userLimit;
+			if (user?.uid && user.uid !== "anon") return userLimit;
 			return anonLimit;
 		}
 	});
@@ -9773,7 +9773,7 @@ function mountMfaRoutes(router, config, ops, parseBody, applyTransformHook) {
 		const body = await c.req.json().catch(() => ({}));
 		const friendlyName = typeof body.friendlyName === "string" ? body.friendlyName : void 0;
 		const issuer = typeof body.issuer === "string" ? body.issuer : emailConfig?.appName || "Rebase";
-		const user = await authRepo.getUserById(userCtx.userId);
+		const user = await authRepo.getUserById(userCtx.uid);
 		if (!user) throw ApiError.notFound("User not found");
 		const { secret, uri } = generateTotpSecret(issuer, user.email);
 		const encryptedSecret = encryptTotpSecret(secret);
@@ -9807,7 +9807,7 @@ function mountMfaRoutes(router, config, ops, parseBody, applyTransformHook) {
 			code: string().length(6, "Code must be 6 digits")
 		}), await c.req.json());
 		const factor = await authRepo.getMfaFactorById(factorId);
-		if (!factor || factor.userId !== userCtx.userId) throw ApiError.notFound("MFA factor not found");
+		if (!factor || factor.userId !== userCtx.uid) throw ApiError.notFound("MFA factor not found");
 		if (factor.verified) throw ApiError.badRequest("Factor is already verified", "ALREADY_VERIFIED");
 		if (!verifyTotp(base32Decode(decryptTotpSecret(factor.secretEncrypted)), code)) throw ApiError.unauthorized("Invalid TOTP code", "INVALID_CODE");
 		await authRepo.verifyMfaFactor(factorId);
@@ -9825,7 +9825,7 @@ function mountMfaRoutes(router, config, ops, parseBody, applyTransformHook) {
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
 		const { factorId } = parseBody(object({ factorId: string().min(1, "Factor ID is required") }), await c.req.json());
 		const factor = await authRepo.getMfaFactorById(factorId);
-		if (!factor || factor.userId !== userCtx.userId) throw ApiError.notFound("MFA factor not found");
+		if (!factor || factor.userId !== userCtx.uid) throw ApiError.notFound("MFA factor not found");
 		if (!factor.verified) throw ApiError.badRequest("MFA factor is not yet verified", "FACTOR_NOT_VERIFIED");
 		const ipAddress = c.req.header("x-forwarded-for") || "unknown";
 		const challenge = await authRepo.createMfaChallenge(factorId, ipAddress);
@@ -9849,19 +9849,19 @@ function mountMfaRoutes(router, config, ops, parseBody, applyTransformHook) {
 		const challenge = await authRepo.getMfaChallengeById(challengeId);
 		if (!challenge) throw ApiError.badRequest("Invalid or expired challenge", "INVALID_CHALLENGE");
 		const factor = await authRepo.getMfaFactorById(challenge.factorId);
-		if (!factor || factor.userId !== userCtx.userId) throw ApiError.notFound("MFA factor not found");
+		if (!factor || factor.userId !== userCtx.uid) throw ApiError.notFound("MFA factor not found");
 		let isValid = verifyTotp(base32Decode(decryptTotpSecret(factor.secretEncrypted)), code);
 		if (!isValid) {
 			const codeHash = hashRecoveryCode(code);
-			isValid = await authRepo.useRecoveryCode(userCtx.userId, codeHash);
+			isValid = await authRepo.useRecoveryCode(userCtx.uid, codeHash);
 		}
 		if (!isValid) throw ApiError.unauthorized("Invalid verification code", "INVALID_CODE");
 		await authRepo.verifyMfaChallenge(challengeId);
-		const roleIds = (await authRepo.getUserRoles(userCtx.userId)).map((r) => r.id);
-		const accessToken = generateAccessToken(userCtx.userId, roleIds, "aal2");
+		const roleIds = (await authRepo.getUserRoles(userCtx.uid)).map((r) => r.id);
+		const accessToken = generateAccessToken(userCtx.uid, roleIds, "aal2");
 		const refreshToken = generateRefreshToken();
-		await authRepo.createRefreshToken(userCtx.userId, hashRefreshToken(refreshToken), getRefreshTokenExpiry(), c.req.header("user-agent") || "unknown", c.req.header("x-forwarded-for") || "unknown");
-		if (ops.onMfaVerified) ops.onMfaVerified(userCtx.userId, factor.id).catch((err) => {
+		await authRepo.createRefreshToken(userCtx.uid, hashRefreshToken(refreshToken), getRefreshTokenExpiry(), c.req.header("user-agent") || "unknown", c.req.header("x-forwarded-for") || "unknown");
+		if (ops.onMfaVerified) ops.onMfaVerified(userCtx.uid, factor.id).catch((err) => {
 			logger.error("[AuthHooks] onMfaVerified error", { error: err instanceof Error ? err.message : err });
 		});
 		let mfaResponse = { tokens: {
@@ -9869,7 +9869,7 @@ function mountMfaRoutes(router, config, ops, parseBody, applyTransformHook) {
 			refreshToken,
 			accessTokenExpiresAt: getAccessTokenExpiry()
 		} };
-		if (applyTransformHook) mfaResponse = await applyTransformHook(mfaResponse, "mfa", c.req.raw, userCtx.userId);
+		if (applyTransformHook) mfaResponse = await applyTransformHook(mfaResponse, "mfa", c.req.raw, userCtx.uid);
 		return c.json(mfaResponse);
 	});
 	/**
@@ -9879,7 +9879,7 @@ function mountMfaRoutes(router, config, ops, parseBody, applyTransformHook) {
 	router.get("/mfa/factors", requireAuth, async (c) => {
 		const userCtx = c.get("user");
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
-		const factors = await authRepo.getMfaFactors(userCtx.userId);
+		const factors = await authRepo.getMfaFactors(userCtx.uid);
 		return c.json({ factors: factors.map((f) => ({
 			id: f.id,
 			factorType: f.factorType,
@@ -9898,9 +9898,9 @@ function mountMfaRoutes(router, config, ops, parseBody, applyTransformHook) {
 		if (userCtx.aal !== "aal2") throw ApiError.forbidden("MFA verification required to unenroll. Please re-authenticate with your second factor.", "AAL2_REQUIRED");
 		const { factorId } = parseBody(object({ factorId: string().min(1, "Factor ID is required") }), await c.req.json());
 		const factor = await authRepo.getMfaFactorById(factorId);
-		if (!factor || factor.userId !== userCtx.userId) throw ApiError.notFound("MFA factor not found");
-		await authRepo.deleteMfaFactor(factorId, userCtx.userId);
-		if (!await authRepo.hasVerifiedMfaFactors(userCtx.userId)) await authRepo.deleteAllRecoveryCodes(userCtx.userId);
+		if (!factor || factor.userId !== userCtx.uid) throw ApiError.notFound("MFA factor not found");
+		await authRepo.deleteMfaFactor(factorId, userCtx.uid);
+		if (!await authRepo.hasVerifiedMfaFactors(userCtx.uid)) await authRepo.deleteAllRecoveryCodes(userCtx.uid);
 		return c.json({
 			success: true,
 			message: "MFA factor removed"
@@ -10002,9 +10002,9 @@ function mountSessionRoutes(opts) {
 		clearRefreshCookie(c, config.cookieAuth);
 		const authHeader = c.req.header("authorization");
 		if (ops.afterLogout && authHeader?.startsWith("Bearer ")) {
-			const { verifyAccessToken } = await import("./jwt-BJzQOa8a.js").then((n) => n.c);
+			const { verifyAccessToken } = await import("./jwt-B3zjddCa.js").then((n) => n.c);
 			const payload = verifyAccessToken(authHeader.substring(7));
-			if (payload) ops.afterLogout(payload.userId).catch((err) => {
+			if (payload) ops.afterLogout(payload.uid).catch((err) => {
 				logger.error("[AuthHooks] afterLogout error", { error: err instanceof Error ? err.message : err });
 			});
 		}
@@ -10019,7 +10019,7 @@ function mountSessionRoutes(opts) {
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
 		const currentRefreshToken = c.req.header("x-refresh-token");
 		const currentTokenHash = currentRefreshToken ? hashRefreshToken(currentRefreshToken) : null;
-		const mappedSessions = (await authRepo.listRefreshTokensForUser(userCtx.userId)).map((s) => ({
+		const mappedSessions = (await authRepo.listRefreshTokensForUser(userCtx.uid)).map((s) => ({
 			id: s.id,
 			userAgent: s.userAgent,
 			ipAddress: s.ipAddress,
@@ -10035,7 +10035,7 @@ function mountSessionRoutes(opts) {
 	router.delete("/sessions", requireAuth, async (c) => {
 		const userCtx = c.get("user");
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
-		await authRepo.deleteAllRefreshTokensForUser(userCtx.userId);
+		await authRepo.deleteAllRefreshTokensForUser(userCtx.uid);
 		return c.json({
 			success: true,
 			message: "All sessions revoked successfully"
@@ -10050,7 +10050,7 @@ function mountSessionRoutes(opts) {
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
 		const id = c.req.param("id");
 		if (!id) throw ApiError.badRequest("Session ID is required", "INVALID_INPUT");
-		await authRepo.deleteRefreshTokenById(id, userCtx.userId);
+		await authRepo.deleteRefreshTokenById(id, userCtx.uid);
 		return c.json({
 			success: true,
 			message: "Session revoked successfully"
@@ -10063,7 +10063,7 @@ function mountSessionRoutes(opts) {
 	router.get("/me", requireAuth, async (c) => {
 		const userCtx = c.get("user");
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
-		const result = await authRepo.getUserWithRoles(userCtx.userId);
+		const result = await authRepo.getUserWithRoles(userCtx.uid);
 		if (!result) throw ApiError.notFound("User not found");
 		return c.json({ user: {
 			uid: result.user.id,
@@ -10103,11 +10103,11 @@ function mountSessionRoutes(opts) {
 		const userCtx = c.get("user");
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
 		const { displayName, photoURL } = parseBody(updateProfileSchema, await c.req.json());
-		if (!await authRepo.updateUser(userCtx.userId, {
+		if (!await authRepo.updateUser(userCtx.uid, {
 			displayName: displayName !== void 0 ? displayName : void 0,
 			photoUrl: photoURL !== void 0 ? photoURL : void 0
 		})) throw ApiError.notFound("User not found");
-		const result = await authRepo.getUserWithRoles(userCtx.userId);
+		const result = await authRepo.getUserWithRoles(userCtx.uid);
 		if (!result) throw ApiError.notFound("User not found");
 		return c.json({ user: {
 			uid: result.user.id,
@@ -10169,7 +10169,7 @@ function mountSessionRoutes(opts) {
 	router.post("/anonymous/link", requireAuth, async (c) => {
 		const userCtx = c.get("user");
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
-		const user = await authRepo.getUserById(userCtx.userId);
+		const user = await authRepo.getUserById(userCtx.uid);
 		if (!user?.isAnonymous) throw ApiError.badRequest("User is not anonymous", "NOT_ANONYMOUS");
 		const { email, password } = parseBody(linkSchema, await c.req.json());
 		const passwordValidation = ops.validatePasswordStrength(password);
@@ -10498,54 +10498,101 @@ function createAuthRoutes(config) {
 	/**
 	* Dynamically mount OAuth provider routes
 	*/
-	if (config.oauthProviders && config.oauthProviders.length > 0) for (const provider of config.oauthProviders) router.post(`/${provider.id}`, defaultAuthLimiter, async (c) => {
-		const payload = parseBody(provider.schema, await c.req.json());
-		let externalUser;
-		try {
-			externalUser = await provider.verify(payload);
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			throw ApiError.unauthorized(`${provider.id} login failed: ${msg}`, "OAUTH_ERROR");
-		}
-		if (!externalUser) throw ApiError.unauthorized(`Invalid ${provider.id} credentials`, "INVALID_TOKEN");
-		let user = await authRepo.getUserByIdentity(provider.id, externalUser.providerId);
-		if (!user) {
-			user = await authRepo.getUserByEmail(externalUser.email);
-			if (user) {
-				if (!externalUser.emailVerified) throw ApiError.forbidden("Cannot auto-link account: email not verified by the OAuth provider. Please log in with your password first and link the provider from your profile.", "EMAIL_NOT_VERIFIED");
-				await authRepo.linkUserIdentity(user.id, provider.id, externalUser.providerId, { email: externalUser.email });
-				await authRepo.updateUser(user.id, {
-					displayName: user.displayName || externalUser.displayName || void 0,
-					photoUrl: user.photoUrl || externalUser.photoUrl || void 0
-				});
-			} else {
-				user = await authRepo.createUser({
-					email: externalUser.email.toLowerCase(),
-					displayName: externalUser.displayName || void 0,
-					photoUrl: externalUser.photoUrl || void 0
-				});
-				await authRepo.linkUserIdentity(user.id, provider.id, externalUser.providerId, { email: externalUser.email });
-				if (ops.afterUserCreate) try {
-					await ops.afterUserCreate(user);
-				} catch (err) {
-					logger.error("[AuthHooks] afterUserCreate error", { error: err instanceof Error ? err.message : err });
+	if (config.oauthProviders && config.oauthProviders.length > 0) for (const provider of config.oauthProviders) {
+		router.post(`/${provider.id}`, defaultAuthLimiter, async (c) => {
+			const payload = parseBody(provider.schema, await c.req.json());
+			let externalUser;
+			try {
+				externalUser = await provider.verify(payload);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw ApiError.unauthorized(`${provider.id} login failed: ${msg}`, "OAUTH_ERROR");
+			}
+			if (!externalUser) throw ApiError.unauthorized(`Invalid ${provider.id} credentials`, "INVALID_TOKEN");
+			let user = await authRepo.getUserByIdentity(provider.id, externalUser.providerId);
+			if (!user) {
+				user = await authRepo.getUserByEmail(externalUser.email);
+				if (user) {
+					if (!externalUser.emailVerified) throw ApiError.forbidden(`An account with this email already exists with a different sign-in method. ${provider.id} has not verified this email address, so it cannot be linked automatically. Sign in with your existing method, then POST to /auth/link/${provider.id} to link ${provider.id} to your account.`, "EMAIL_NOT_VERIFIED");
+					await authRepo.linkUserIdentity(user.id, provider.id, externalUser.providerId, { email: externalUser.email });
+					await authRepo.updateUser(user.id, {
+						displayName: user.displayName || externalUser.displayName || void 0,
+						photoUrl: user.photoUrl || externalUser.photoUrl || void 0
+					});
+				} else {
+					user = await authRepo.createUser({
+						email: externalUser.email.toLowerCase(),
+						displayName: externalUser.displayName || void 0,
+						photoUrl: externalUser.photoUrl || void 0
+					});
+					await authRepo.linkUserIdentity(user.id, provider.id, externalUser.providerId, { email: externalUser.email });
+					if (ops.afterUserCreate) try {
+						await ops.afterUserCreate(user);
+					} catch (err) {
+						logger.error("[AuthHooks] afterUserCreate error", { error: err instanceof Error ? err.message : err });
+					}
+					const allUsers = await authRepo.listUsers();
+					if (allUsers.length === 1 && allUsers[0].id === user.id) await authRepo.setUserRoles(user.id, ["admin"]);
+					else if (config.defaultRole) await authRepo.assignDefaultRole(user.id, config.defaultRole);
+					sendWelcomeEmail({
+						email: user.email,
+						displayName: user.displayName
+					});
 				}
-				const allUsers = await authRepo.listUsers();
-				if (allUsers.length === 1 && allUsers[0].id === user.id) await authRepo.setUserRoles(user.id, ["admin"]);
-				else if (config.defaultRole) await authRepo.assignDefaultRole(user.id, config.defaultRole);
-				sendWelcomeEmail({
-					email: user.email,
-					displayName: user.displayName
-				});
+			} else await authRepo.updateUser(user.id, {
+				displayName: externalUser.displayName || user.displayName || void 0,
+				photoUrl: externalUser.photoUrl || user.photoUrl || void 0
+			});
+			const { roleIds, accessToken, refreshToken } = await createSessionAndTokens(user.id, c.req.header("user-agent") || "unknown", c.req.header("x-forwarded-for") || "unknown");
+			const finalResponse = redactRefreshToken(await applyTransformHook(buildAuthResponse(user, roleIds, accessToken, refreshToken, provider.id), "oauth", c.req.raw, user.id), c, refreshToken, config.cookieAuth);
+			return c.json(finalResponse);
+		});
+		/**
+		* POST /auth/link/:provider
+		* Attach an OAuth identity to the *already authenticated* account.
+		*
+		* This is the escape hatch from the `EMAIL_NOT_VERIFIED` rejection
+		* on the sign-in route above, and the way to attach a provider
+		* whose email differs from the account's.
+		*
+		* Note the deliberate asymmetry with sign-in: linking here does
+		* NOT require the provider to have verified the email, and does
+		* not require the emails to match at all. On the sign-in route the
+		* provider's email is the *only* evidence tying the incoming
+		* identity to an existing account, so an unverified address would
+		* let an attacker claim someone else's account. Here the caller
+		* has already proven ownership by holding a valid session, and the
+		* OAuth credential proves control of the provider identity — the
+		* email plays no part in the decision, so its verification status
+		* is irrelevant.
+		*/
+		router.post(`/link/${provider.id}`, defaultAuthLimiter, requireAuth, async (c) => {
+			const userCtx = c.get("user");
+			if (!userCtx) throw ApiError.unauthorized("Not authenticated");
+			const payload = parseBody(provider.schema, await c.req.json());
+			let externalUser;
+			try {
+				externalUser = await provider.verify(payload);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw ApiError.unauthorized(`${provider.id} link failed: ${msg}`, "OAUTH_ERROR");
 			}
-		} else await authRepo.updateUser(user.id, {
-			displayName: externalUser.displayName || user.displayName || void 0,
-			photoUrl: externalUser.photoUrl || user.photoUrl || void 0
+			if (!externalUser) throw ApiError.unauthorized(`Invalid ${provider.id} credentials`, "INVALID_TOKEN");
+			const identityOwner = await authRepo.getUserByIdentity(provider.id, externalUser.providerId);
+			if (identityOwner && identityOwner.id !== userCtx.uid) throw ApiError.conflict(`That ${provider.id} account is already linked to a different user.`, "IDENTITY_ALREADY_LINKED");
+			if (identityOwner) return c.json({
+				success: true,
+				provider: provider.id,
+				alreadyLinked: true
+			});
+			await authRepo.linkUserIdentity(userCtx.uid, provider.id, externalUser.providerId, { email: externalUser.email });
+			return c.json({
+				success: true,
+				provider: provider.id,
+				alreadyLinked: false
+			});
 		});
-		const { roleIds, accessToken, refreshToken } = await createSessionAndTokens(user.id, c.req.header("user-agent") || "unknown", c.req.header("x-forwarded-for") || "unknown");
-		const finalResponse = redactRefreshToken(await applyTransformHook(buildAuthResponse(user, roleIds, accessToken, refreshToken, provider.id), "oauth", c.req.raw, user.id), c, refreshToken, config.cookieAuth);
-		return c.json(finalResponse);
-	});
+	}
 	/**
 	* POST /auth/forgot-password
 	* Request password reset email
@@ -10616,7 +10663,7 @@ function createAuthRoutes(config) {
 		const userCtx = c.get("user");
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
 		const { oldPassword, newPassword } = parseBody(changePasswordSchema, await c.req.json());
-		const user = await authRepo.getUserById(userCtx.userId);
+		const user = await authRepo.getUserById(userCtx.uid);
 		if (!user || !user.passwordHash) throw ApiError.badRequest("Cannot change password for this account", "INVALID_ACCOUNT");
 		if (!await ops.verifyPassword(oldPassword, user.passwordHash)) throw ApiError.unauthorized("Current password is incorrect", "INVALID_CREDENTIALS");
 		const passwordValidation = ops.validatePasswordStrength(newPassword);
@@ -10637,7 +10684,7 @@ function createAuthRoutes(config) {
 		const userCtx = c.get("user");
 		if (!userCtx) throw ApiError.unauthorized("Not authenticated");
 		if (!isEmailConfigured()) throw ApiError.serviceUnavailable("Email service not configured. Email verification is not available.", "EMAIL_NOT_CONFIGURED");
-		const user = await authRepo.getUserById(userCtx.userId);
+		const user = await authRepo.getUserById(userCtx.uid);
 		if (!user) throw ApiError.notFound("User not found");
 		if (user.emailVerified) throw ApiError.badRequest("Email is already verified", "ALREADY_VERIFIED");
 		const token = generateSecureToken();
@@ -10683,7 +10730,7 @@ function createAuthRoutes(config) {
 	* Refresh access token using refresh token
 	*/
 	router.post("/refresh", async (c) => {
-		const refreshToken = readRefreshToken(c, parseBody(refreshSchema, await c.req.json()), config.cookieAuth);
+		const refreshToken = readRefreshToken(c, parseBody(refreshSchema, await c.req.json().catch(() => ({}))), config.cookieAuth);
 		if (!refreshToken) throw ApiError.badRequest("Refresh token is required", "INVALID_INPUT");
 		const tokenHash = hashRefreshToken(refreshToken);
 		const storedToken = await authRepo.findRefreshTokenByHash(tokenHash);
@@ -11066,8 +11113,7 @@ function createAdminUsersRoute(config) {
 	});
 	router.delete("/users/:userId", requireAdmin, async (c) => {
 		const userId = c.req.param("userId");
-		const authUser = c.get("user");
-		if ((authUser?.uid || authUser?.userId) === userId) throw ApiError.badRequest("Cannot delete your own account", "SELF_DELETE");
+		if (c.get("user")?.uid === userId) throw ApiError.badRequest("Cannot delete your own account", "SELF_DELETE");
 		if (!await authRepo.getUserById(userId)) throw ApiError.notFound("User not found");
 		if ((await authRepo.getUserRoleIds(userId)).includes("admin")) {
 			if ((await authRepo.listUsersPaginated({
@@ -11110,16 +11156,16 @@ function createBuiltinAuthAdapter(config) {
 			if (!payload) return null;
 			let roles = payload.roles || [];
 			try {
-				roles = await authRepository.getUserRoleIds(payload.userId);
+				roles = await authRepository.getUserRoleIds(payload.uid);
 			} catch (err) {
 				logger.warn("Role lookup from repository failed, using token roles as fallback", {
-					userId: payload.userId,
+					uid: payload.uid,
 					error: err
 				});
 			}
 			const isAdmin = roles.some((r) => r === "admin" || r === "schema-admin");
 			return {
-				uid: payload.userId,
+				uid: payload.uid,
 				email: payload.email ?? "",
 				displayName: payload.displayName ?? null,
 				roles,
@@ -11139,16 +11185,16 @@ function createBuiltinAuthAdapter(config) {
 			if (!payload) return null;
 			let roles = payload.roles || [];
 			try {
-				roles = await authRepository.getUserRoleIds(payload.userId);
+				roles = await authRepository.getUserRoleIds(payload.uid);
 			} catch (err) {
 				logger.warn("Role lookup from repository failed, using token roles as fallback", {
-					userId: payload.userId,
+					uid: payload.uid,
 					error: err
 				});
 			}
 			const isAdmin = roles.some((r) => r === "admin" || r === "schema-admin");
 			return {
-				uid: payload.userId,
+				uid: payload.uid,
 				email: payload.email ?? "",
 				displayName: payload.displayName ?? null,
 				roles,
@@ -11416,8 +11462,8 @@ function requestLogger(options) {
 		const reqId = c.get("requestId");
 		if (reqId) data.requestId = reqId;
 		if (contentLength) data.contentLength = parseInt(contentLength, 10);
-		const userId = c.get("userId");
-		if (userId) data.userId = userId;
+		const uid = c.get("user")?.uid;
+		if (uid) data.uid = uid;
 		if (status >= 500) logger.error("request", data);
 		else if (status >= 400) logger.warn("request", data);
 		else logger.info("request", data);
@@ -11623,11 +11669,21 @@ var LocalStorageController = class {
 		}
 	}
 	/**
-	* Get the full filesystem path for a storage path.
-	* Includes a path traversal guard to prevent escaping the base directory.
+	* Get the full filesystem path for a storage path, with a traversal guard
+	* that keeps the result inside the bucket directory.
+	*
+	* Defaults the bucket the way `putObject` does.
+	*
+	* `putObject` has always written into `default` when given no bucket, while
+	* the read side resolved a bare key against the storage root — where
+	* nothing is. The two disagreed silently: `getObject` returned null (reads
+	* as "file missing"), `deleteObject` deleted nothing (404s are swallowed by
+	* design), and `listObjects` returned an empty page. So the obvious
+	* `putObject({ key })` → `getObject(key)` did not round-trip and nothing
+	* said why. One default, applied everywhere, removes the whole class.
 	*/
 	getFullPath(storagePath, bucket) {
-		const bucketPath = bucket ? path$1.join(this.basePath, bucket) : this.basePath;
+		const bucketPath = path$1.join(this.basePath, bucket ?? "default");
 		const resolved = path$1.resolve(path$1.join(bucketPath, storagePath));
 		if (!resolved.startsWith(bucketPath + path$1.sep) && resolved !== bucketPath) throw new Error("Path traversal detected: resolved storage path is outside the bucket directory.");
 		return resolved;
@@ -11788,8 +11844,10 @@ var LocalStorageController = class {
 			let count = 0;
 			const maxResults = options?.maxResults ?? 1e3;
 			const startIndex = options?.pageToken ? parseInt(options.pageToken, 10) : 0;
+			let scanned = startIndex;
 			for (let i = startIndex; i < entries.length && count < maxResults; i++) {
 				const entry = entries[i];
+				scanned = i + 1;
 				if (entry.name.endsWith(".metadata.json")) continue;
 				const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
 				const bucket = options?.bucket ?? "default";
@@ -11808,7 +11866,7 @@ var LocalStorageController = class {
 			return {
 				items,
 				prefixes,
-				nextPageToken: startIndex + count < entries.length ? String(startIndex + count) : void 0
+				nextPageToken: scanned < entries.length ? String(scanned) : void 0
 			};
 		} catch (error) {
 			const code = error?.code;
@@ -13759,12 +13817,14 @@ var UPLOAD_EXPIRY_MS = 1440 * 60 * 1e3;
 var TusHandler = class {
 	storageController;
 	storageRegistry;
+	authorizeUpload;
 	uploads = /* @__PURE__ */ new Map();
 	tusDir;
 	cleanupTimer;
-	constructor(storageBaseDir, storageController, storageRegistry) {
+	constructor(storageBaseDir, storageController, storageRegistry, authorizeUpload) {
 		this.storageController = storageController;
 		this.storageRegistry = storageRegistry;
+		this.authorizeUpload = authorizeUpload;
 		this.tusDir = join(storageBaseDir, ".tus-uploads");
 	}
 	/** Ensure the temp directory exists. */
@@ -13828,6 +13888,10 @@ var TusHandler = class {
 		if (Number.isNaN(uploadLength) || uploadLength <= 0) throw ApiError.badRequest("Invalid Upload-Length");
 		if (uploadLength > MAX_UPLOAD_SIZE) throw new ApiError(413, "PAYLOAD_TOO_LARGE", `Upload-Length exceeds maximum of ${MAX_UPLOAD_SIZE} bytes`);
 		const metadata = this.parseMetadata(c.req.header("Upload-Metadata") || "");
+		if (this.authorizeUpload) {
+			const key = metadata.key || metadata.filename || "";
+			await this.authorizeUpload(c, key, metadata.bucket || "default");
+		}
 		const id = randomUUID$1();
 		const filePath = join(this.tusDir, id);
 		await writeFile(filePath, Buffer.alloc(0));
@@ -14013,7 +14077,7 @@ function buildAdapterAuthMiddleware(adapter, requireAuth, publicRead) {
 				} }, 401);
 			}
 			if (authenticatedUser) c.set("user", {
-				userId: authenticatedUser.uid,
+				uid: authenticatedUser.uid,
 				email: authenticatedUser.email,
 				roles: authenticatedUser.roles
 			});
@@ -14035,7 +14099,34 @@ function buildAdapterAuthMiddleware(adapter, requireAuth, publicRead) {
 function createStorageRoutes(config) {
 	const router = new Hono();
 	router.onError(errorHandler);
-	const { controller, registry, sources: declaredSources, requireAuth: requireAuth$1 = true, publicRead = false, authAdapter } = config;
+	const { controller, registry, sources: declaredSources, requireAuth: requireAuth$1 = true, publicRead = false, authAdapter, authorize } = config;
+	/**
+	* Run the per-object authorization hook, if one is configured.
+	*
+	* Denials are 403 rather than 404: the route already established that the
+	* caller is authenticated, so hiding existence buys nothing, and a
+	* distinguishable status is what makes a misconfigured policy debuggable.
+	* A hook that throws denies too — an ownership lookup that fails must not
+	* fall open.
+	*/
+	const checkAuthorized = async (c, operation, key, bucket, storageId) => {
+		if (!authorize) return;
+		const user = c.get("user") ?? null;
+		if (user?.uid === "download-token" || user?.uid === "public") return;
+		let allowed;
+		try {
+			allowed = await authorize({
+				key,
+				bucket,
+				operation,
+				user,
+				storageId: storageId ?? void 0
+			});
+		} catch {
+			allowed = false;
+		}
+		if (!allowed) throw ApiError.forbidden("Not authorized for this object");
+	};
 	/**
 	* Resolve the storage controller for a request.
 	* Looks up by `storageId` in the registry, falls back to the single
@@ -14085,6 +14176,7 @@ function createStorageRoutes(config) {
 		const finalKey = sanitizeStorageKey(key || uploadedFile.name || "unnamed");
 		const metadata = {};
 		for (const [k, value] of Object.entries(body)) if (k.startsWith("metadata_")) metadata[k.replace("metadata_", "")] = value;
+		await checkAuthorized(c, "write", finalKey, bucket ?? "default", storageId);
 		const result = await resolveController(storageId).putObject({
 			file: uploadedFile,
 			key: finalKey,
@@ -14105,7 +14197,12 @@ function createStorageRoutes(config) {
 		const rawPath = extractWildcardPath(c);
 		if (!rawPath) throw ApiError.notFound("File not found");
 		const filePath = decodeURIComponent(rawPath);
-		const resolved = resolveController(c.req.query("storageId"));
+		const storageId = c.req.query("storageId");
+		const resolved = resolveController(storageId);
+		{
+			const { bucket, resolvedPath } = parseBucketAndPath(filePath);
+			await checkAuthorized(c, "read", resolvedPath, bucket, storageId);
+		}
 		const transformOpts = parseTransformOptions(c.req.query());
 		if (resolved.getType() === "local") {
 			const localController = resolved;
@@ -14168,8 +14265,10 @@ function createStorageRoutes(config) {
 			fileNotFound: true
 		}, 404);
 		const filePath = decodeURIComponent(rawPath);
-		const resolved = resolveController(c.req.query("storageId"));
+		const storageId = c.req.query("storageId");
+		const resolved = resolveController(storageId);
 		const { bucket, resolvedPath } = parseBucketAndPath(filePath);
+		await checkAuthorized(c, "read", resolvedPath, bucket, storageId);
 		const downloadConfig = await resolved.getSignedUrl(resolvedPath, bucket);
 		if (downloadConfig.fileNotFound) throw ApiError.notFound("File not found");
 		if (downloadConfig.metadata) {
@@ -14195,8 +14294,10 @@ function createStorageRoutes(config) {
 			message: "No file to delete"
 		});
 		const filePath = decodeURIComponent(rawPath);
-		const resolved = resolveController(c.req.query("storageId"));
+		const storageId = c.req.query("storageId");
+		const resolved = resolveController(storageId);
 		const { bucket, resolvedPath } = parseBucketAndPath(filePath);
+		await checkAuthorized(c, "delete", resolvedPath, bucket, storageId);
 		await resolved.deleteObject(resolvedPath, bucket);
 		return c.json({
 			success: true,
@@ -14211,7 +14312,9 @@ function createStorageRoutes(config) {
 		const bucket = c.req.query("bucket");
 		const maxResults = c.req.query("maxResults");
 		const pageToken = c.req.query("pageToken");
-		const resolved = resolveController(c.req.query("storageId"));
+		const storageId = c.req.query("storageId");
+		const resolved = resolveController(storageId);
+		await checkAuthorized(c, "list", storagePrefix, bucket ?? "default", storageId);
 		const result = await resolved.listObjects(storagePrefix, {
 			bucket: bucket ?? (resolved.getType() === "local" ? "default" : void 0),
 			maxResults: maxResults ? parseInt(maxResults, 10) : void 0,
@@ -14234,6 +14337,7 @@ function createStorageRoutes(config) {
 		const resolved = resolveController(storageId);
 		const { bucket, resolvedPath } = parseBucketAndPath(folderPath);
 		if (!resolvedPath || resolvedPath.trim() === "") throw ApiError.badRequest("Invalid folder path");
+		await checkAuthorized(c, "write", resolvedPath, bucket, storageId);
 		if (resolved.getType() === "local") {
 			const absolutePath = resolved.getAbsolutePath(resolvedPath, bucket);
 			fs$1.mkdirSync(absolutePath, { recursive: true });
@@ -14251,7 +14355,9 @@ function createStorageRoutes(config) {
 		}, 201);
 	});
 	const defaultCtrl = getDefaultController();
-	const tusHandler = new TusHandler(defaultCtrl.getType() === "local" ? defaultCtrl.getBasePath() : process.env.STORAGE_PATH || "./uploads", defaultCtrl, registry);
+	const tusHandler = new TusHandler(defaultCtrl.getType() === "local" ? defaultCtrl.getBasePath() : process.env.STORAGE_PATH || "./uploads", defaultCtrl, registry, authorize ? async (c, key, bucket) => {
+		await checkAuthorized(c, "write", sanitizeStorageKey(key), bucket, c.req.query("storageId"));
+	} : void 0);
 	tusHandler.startCleanup();
 	router.options("/tus", (_c) => tusHandler.options());
 	router.post("/tus", writeAuthMiddleware, async (c) => tusHandler.create(c));
@@ -14392,7 +14498,7 @@ async function initializeStorage(storageConfig, isProduction) {
 	const toController = async (entry, label) => {
 		if (typeof entry.putObject === "function") return entry;
 		const conf = entry;
-		if (isProduction && conf.type === "local") logger.warn(`Storage backend "${label}" uses local filesystem in production. Files will be lost on container restart. Configure S3-compatible storage or a custom StorageController.`);
+		if (isProduction && conf.type === "local" && !process.env.FORCE_LOCAL_STORAGE) throw new Error(`Storage backend "${label}" is set to "local" in production. Local storage is the container filesystem, so uploaded files are destroyed on the next restart or redeploy. Configure S3-compatible storage (STORAGE_TYPE=s3) or GCS (STORAGE_TYPE=gcs), or pass a custom StorageController. If this deployment really does have a durable volume mounted at the storage path, set FORCE_LOCAL_STORAGE=true to proceed.`);
 		return await createStorageController(conf);
 	};
 	if (typeof storageConfig === "object" && ("type" in storageConfig || typeof storageConfig.putObject === "function")) controllers[DEFAULT_STORAGE_ID] = await toController(storageConfig, DEFAULT_STORAGE_ID);
@@ -14649,6 +14755,28 @@ function buildQueryString(params) {
 	}
 	return parts.length > 0 ? "?" + parts.join("&") : "";
 }
+/**
+* The base every request and every caller-built URL resolves against.
+*
+* `baseUrl` is optional because the common production shape is a Rebase
+* backend serving its own SPA, where the API is simply the page's origin.
+* Leaving it unset is therefore the *correct* configuration there — and the
+* one that keeps working when a second hostname (a custom domain) points at
+* the same app.
+*
+* When unset in a browser this resolves to the page origin rather than "".
+* Requests behave identically either way, but the empty string is a trap for
+* anything that builds a URL from `client.baseUrl`: `new URL("" + path)`
+* throws, so apps "fixed" it by baking an absolute host into their bundle —
+* which is exactly what breaks the day a custom domain is added, and which no
+* amount of CORS configuration repairs, because a SameSite=Lax auth cookie is
+* not sent cross-site either.
+*/
+function resolveBaseUrl(configured) {
+	if (configured) return configured.replace(/\/$/, "");
+	if (typeof window !== "undefined" && window.location?.origin) return window.location.origin;
+	return "";
+}
 function createTransport(config) {
 	const fetchFn = config.fetch || globalThis.fetch;
 	const apiPath = config.apiPath || "/api";
@@ -14663,7 +14791,7 @@ function createTransport(config) {
 		};
 	}
 	async function request(path, init) {
-		const url = (config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "") + apiPath + path;
+		const url = resolveBaseUrl(config.baseUrl) + apiPath + path;
 		let activeToken = token;
 		if (tokenGetter) try {
 			const fetched = await tokenGetter();
@@ -14738,7 +14866,7 @@ function createTransport(config) {
 			onUnauthorizedHandler = handler;
 		},
 		get baseUrl() {
-			return config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "";
+			return resolveBaseUrl(config.baseUrl);
 		},
 		get apiPath() {
 			return apiPath;
@@ -15198,6 +15326,30 @@ function createAuth(transport, options) {
 			})
 		});
 	}
+	/**
+	* Link an OAuth provider to the **currently signed-in** account.
+	*
+	* Use this when `signIn*` failed with `EMAIL_NOT_VERIFIED` — an account
+	* with that email already exists under a different sign-in method — or to
+	* attach a provider whose email differs from the account's.
+	*
+	* The payload is the same one the provider's sign-in method takes, e.g.
+	* `linkProvider("google", { idToken })`.
+	*
+	* Unlike sign-in, this does not require the provider to have verified the
+	* email, and the emails need not match: the active session already proves
+	* account ownership.
+	*
+	* Throws `IDENTITY_ALREADY_LINKED` (409) if that provider identity is
+	* attached to a different user. Succeeds idempotently (`alreadyLinked:
+	* true`) if it is already attached to the current one.
+	*/
+	async function linkProvider(providerId, payload) {
+		return transport.request(authPath + "/link/" + providerId, {
+			method: "POST",
+			body: JSON.stringify(payload)
+		});
+	}
 	async function sendVerificationEmail() {
 		return transport.request(authPath + "/send-verification", { method: "POST" });
 	}
@@ -15319,6 +15471,7 @@ function createAuth(transport, options) {
 		resetPasswordForEmail,
 		resetPassword,
 		changePassword,
+		linkProvider,
 		sendVerificationEmail,
 		verifyEmail,
 		sendMagicLink,
@@ -15933,12 +16086,29 @@ var ClientStorageSourceRegistry = class ClientStorageSourceRegistry {
 function extractMessageError(message) {
 	const payload = message.payload;
 	const errPayload = payload?.error;
+	const errorMessage = typeof errPayload === "object" ? errPayload.message : payload?.message || (typeof errPayload === "string" ? errPayload : void 0) || message.error || "Unknown error";
+	const errorCode = typeof errPayload === "object" ? errPayload.code : payload?.code;
 	return {
-		errorMessage: typeof errPayload === "object" ? errPayload.message : payload?.message || (typeof errPayload === "string" ? errPayload : void 0) || message.error || "Unknown error",
-		errorCode: typeof errPayload === "object" ? errPayload.code : payload?.code
+		errorMessage: typeof errorMessage === "string" ? errorMessage : errorMessage == null ? "Unknown error" : JSON.stringify(errorMessage),
+		errorCode
 	};
 }
 /**
+* Broadcast and presence frames.
+*
+* Fire-and-forget (the server sends no response envelope), and exempt from the
+* client-side auth gate — a public channel is usable without an account.
+*/
+var CHANNEL_MESSAGE_TYPES = new Set([
+	"join_channel",
+	"leave_channel",
+	"broadcast",
+	"presence_track",
+	"presence_untrack",
+	"presence_state",
+	"channel_history"
+]);
+/**
 * Low-level realtime WebSocket client.
 *
 * @internal Not a stable app-facing API. `createRebaseClient()` constructs and
@@ -15953,6 +16123,36 @@ var RebaseWebSocketClient = class {
 	getAuthToken;
 	subscriptions = /* @__PURE__ */ new Map();
 	listeners = /* @__PURE__ */ new Map();
+	/** Channel-name → handlers, for broadcast and presence frames. */
+	channelHandlers = /* @__PURE__ */ new Map();
+	/** Set by `close()`. Blocks any later operation from silently redialling. */
+	closedByCaller = false;
+	/**
+	* Whether a socket exists at all (open or still opening).
+	*
+	* Lets callers distinguish "authenticate the live socket" from "there is
+	* nothing to authenticate yet", without that question forcing a dial.
+	*/
+	get hasSocket() {
+		return this.ws !== null;
+	}
+	/** So the "no WebSocket in this environment" warning is said once, not per call. */
+	warnedNoWebSocket = false;
+	/** Subscribe to broadcast/presence frames for one channel. */
+	onChannelMessage(channel, handler) {
+		if (!this.channelHandlers.has(channel)) this.channelHandlers.set(channel, /* @__PURE__ */ new Set());
+		this.channelHandlers.get(channel).add(handler);
+		return () => {
+			const handlers = this.channelHandlers.get(channel);
+			if (!handlers) return;
+			handlers.delete(handler);
+			if (handlers.size === 0) this.channelHandlers.delete(channel);
+		};
+	}
+	/** Notified after the socket comes back, so channels can re-join. */
+	onReconnect(handler) {
+		return this.on("reconnect", handler);
+	}
 	on(event, cb) {
 		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
 		this.listeners.get(event).add(cb);
@@ -15971,6 +16171,7 @@ var RebaseWebSocketClient = class {
 	isConnected = false;
 	messageQueue = [];
 	requestTimeoutMs = 3e4;
+	subscriptionTimeoutMs = 3e4;
 	reconnectTimeout = null;
 	isAuthenticated = false;
 	authPromise = null;
@@ -15982,8 +16183,25 @@ var RebaseWebSocketClient = class {
 		this.getAuthToken = config.getAuthToken;
 		this.onUnauthorized = config.onUnauthorized;
 		this.WebSocketConstructor = config.WebSocket || (typeof WebSocket !== "undefined" ? WebSocket : void 0);
-		if (!this.WebSocketConstructor) console.warn("WebSocket is not defined in this environment. Realtime subscriptions will not work unless you provide a WebSocket implementation in the config.");
-		else this.initWebSocket();
+	}
+	/**
+	* Open the socket if it is not open (or opening) already.
+	*
+	* Idempotent, synchronous, and safe to call on every operation that needs a
+	* live socket — `initWebSocket` already no-ops on an open socket and is
+	* re-entrant, since the reconnect path has always called it.
+	*/
+	ensureConnected() {
+		if (this.closedByCaller) return;
+		if (!this.WebSocketConstructor) {
+			if (!this.warnedNoWebSocket) {
+				this.warnedNoWebSocket = true;
+				console.warn("WebSocket is not defined in this environment. Realtime subscriptions will not work unless you provide a WebSocket implementation in the config.");
+			}
+			return;
+		}
+		if (this.ws || this.reconnectTimeout) return;
+		this.initWebSocket();
 	}
 	/**
 	* Authenticate the WebSocket connection
@@ -16033,7 +16251,16 @@ var RebaseWebSocketClient = class {
 			});
 		}
 	}
-	disconnect() {
+	/**
+	* Drop the socket.
+	*
+	* `permanent` distinguishes the two callers. Signing out drops the socket
+	* but the client stays usable — a later subscribe should reconnect
+	* anonymously. `client.close()` is the caller saying they are done, and
+	* must not be undone by a stray queued frame.
+	*/
+	disconnect(permanent = false) {
+		if (permanent) this.closedByCaller = true;
 		this.isAuthenticated = false;
 		this.authPromise = null;
 		if (this.reconnectTimeout) {
@@ -16076,6 +16303,7 @@ var RebaseWebSocketClient = class {
 				this.emit(wasReconnect ? "reconnect" : "connect");
 				this.processMessageQueue();
 				if (wasReconnect) this.resubscribeAll();
+				this.armPendingSubscribeWatchdogs();
 			};
 			this.ws.onmessage = (event) => {
 				try {
@@ -16090,6 +16318,7 @@ var RebaseWebSocketClient = class {
 				this.isConnected = false;
 				this.isAuthenticated = false;
 				this.authPromise = null;
+				this.suspendSubscribeWatchdogs();
 				this.emit("disconnect");
 				for (const [reqId, request] of this.pendingRequests.entries()) {
 					if (reqId.startsWith("auth_")) request.reject(/* @__PURE__ */ new Error("Connection closed during authentication"));
@@ -16121,6 +16350,7 @@ var RebaseWebSocketClient = class {
 	attemptReconnect() {
 		if (this.reconnectAttempts >= this.maxReconnectAttempts) {
 			console.error("Max reconnection attempts reached");
+			this.failAllPendingSubscriptions(new RebaseApiError("Connection lost", { code: "CONNECTION_LOST" }));
 			return;
 		}
 		this.reconnectAttempts++;
@@ -16175,29 +16405,18 @@ var RebaseWebSocketClient = class {
 				subscription.backendSubscriptionId = newBackendId;
 				backendKeyMap.delete(oldBackendId);
 				backendKeyMap.set(newBackendId, subscriptionKey);
-				this.sendMessage({
-					type: messageType,
-					payload: {
-						...subscription.props,
-						subscriptionId: newBackendId
-					}
-				}).catch((error) => {
-					console.error(`[WS] Failed to re-subscribe ${idPrefix} after auth refresh:`, subscriptionKey, error);
-					subscription.callbacks.forEach((callback) => {
-						if (callback.onError) callback.onError(error);
-					});
-				});
-			} else {
-				const { errorMessage, errorCode } = extractMessageError(message);
-				const error = new RebaseApiError(errorMessage, { code: errorCode });
-				subscription.callbacks.forEach((callback) => {
-					if (callback.onError) callback.onError(error);
-				});
+				if (messageType === "subscribe_collection") this.sendCollectionSubscribe(subscriptionKey);
+				else this.sendEntitySubscribe(subscriptionKey);
+				return;
 			}
+			const { errorMessage, errorCode } = extractMessageError(message);
+			const error = new RebaseApiError(errorMessage, { code: errorCode });
+			if (messageType === "subscribe_collection") this.failCollectionSubscription(subscriptionKey, error);
+			else this.failEntitySubscription(subscriptionKey, error);
 		}).catch((err) => {
-			subscription.callbacks.forEach((callback) => {
-				if (callback.onError) callback.onError(err);
-			});
+			const error = err instanceof Error ? err : new Error(String(err));
+			if (messageType === "subscribe_collection") this.failCollectionSubscription(subscriptionKey, error);
+			else this.failEntitySubscription(subscriptionKey, error);
 		});
 	}
 	handleWebSocketMessage(message) {
@@ -16226,6 +16445,15 @@ var RebaseWebSocketClient = class {
 			}
 			return;
 		}
+		if (typeof message.channel === "string" && (type === "broadcast" || type === "presence_state" || type === "presence_diff" || type === "channel_history")) {
+			const handlers = this.channelHandlers.get(message.channel);
+			if (handlers) for (const handler of [...handlers]) try {
+				handler(message);
+			} catch (error) {
+				console.error("Error in channel handler:", error);
+			}
+			return;
+		}
 		if (subscriptionId && type === "collection_update") {
 			const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
 			if (subscriptionKey) {
@@ -16238,6 +16466,9 @@ var RebaseWebSocketClient = class {
 					collectionSub.latestData = rows;
 					collectionSub.lastUpdated = Date.now();
 					collectionSub.isInitialDataReceived = true;
+					if (collectionSub.subscribeTimeout) clearTimeout(collectionSub.subscribeTimeout);
+					collectionSub.subscribeTimeout = void 0;
+					collectionSub.subscribeInFlight = false;
 					collectionSub.callbacks.forEach((callback) => {
 						try {
 							callback.onUpdate(rows);
@@ -16293,6 +16524,9 @@ var RebaseWebSocketClient = class {
 					entitySub.latestData = row;
 					entitySub.lastUpdated = Date.now();
 					entitySub.isInitialDataReceived = true;
+					if (entitySub.subscribeTimeout) clearTimeout(entitySub.subscribeTimeout);
+					entitySub.subscribeTimeout = void 0;
+					entitySub.subscribeInFlight = false;
 					entitySub.callbacks.forEach((callback) => {
 						try {
 							callback.onUpdate(row);
@@ -16314,6 +16548,9 @@ var RebaseWebSocketClient = class {
 						this.resubscribeAfterAuthRefresh(message, collectionSub, collectionKey, "collection", this.backendToCollectionKey, "subscribe_collection");
 						return;
 					}
+					if (collectionSub.subscribeTimeout) clearTimeout(collectionSub.subscribeTimeout);
+					collectionSub.subscribeTimeout = void 0;
+					collectionSub.subscribeInFlight = false;
 					const { errorMessage, errorCode } = extractMessageError(message);
 					const error = new RebaseApiError(errorMessage, { code: errorCode });
 					collectionSub.callbacks.forEach((callback) => {
@@ -16330,6 +16567,9 @@ var RebaseWebSocketClient = class {
 						this.resubscribeAfterAuthRefresh(message, entitySub, entityKey, "row", this.backendToEntityKey, "subscribe_one");
 						return;
 					}
+					if (entitySub.subscribeTimeout) clearTimeout(entitySub.subscribeTimeout);
+					entitySub.subscribeTimeout = void 0;
+					entitySub.subscribeInFlight = false;
 					const { errorMessage, errorCode } = extractMessageError(message);
 					const error = new RebaseApiError(errorMessage, { code: errorCode });
 					entitySub.callbacks.forEach((callback) => {
@@ -16402,21 +16642,28 @@ var RebaseWebSocketClient = class {
 			throw error;
 		}
 	}
+	/**
+	* Public because `RebaseRealtimeChannel` sends channel frames through it.
+	* Not part of the stable surface — prefer `client.realtime.channel(name)`.
+	*/
 	sendMessage(message) {
 		const queuedMsg = message;
 		if (queuedMsg._queuedResolve && queuedMsg._queuedReject) return this.doSendMessage(message, queuedMsg._queuedResolve, queuedMsg._queuedReject);
-		if (!this.isConnected || !this.ws) return new Promise((resolve, reject) => {
-			const queueable = message;
-			queueable._queuedResolve = resolve;
-			queueable._queuedReject = reject;
-			this.messageQueue.push(message);
-		});
+		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);
+			});
+		}
 		return new Promise((resolve, reject) => {
 			this.doSendMessage(message, resolve, reject);
 		});
 	}
 	async doSendMessage(message, resolve, reject) {
-		if (message.type !== "AUTHENTICATE" && this.getAuthToken && !this.isAuthenticated) try {
+		if (message.type !== "AUTHENTICATE" && !CHANNEL_MESSAGE_TYPES.has(message.type) && this.getAuthToken && !this.isAuthenticated) try {
 			await this.ensureAuthenticated();
 		} catch (error) {
 			reject(new RebaseApiError(error instanceof Error ? error.message : "Authentication required"));
@@ -16424,17 +16671,7 @@ var RebaseWebSocketClient = class {
 		}
 		const requestId = message.requestId || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 		message.requestId = requestId;
-		const expectsResponse = ![
-			"subscribe_collection",
-			"subscribe_one",
-			"unsubscribe",
-			"join_channel",
-			"leave_channel",
-			"broadcast",
-			"presence_track",
-			"presence_untrack",
-			"presence_state"
-		].includes(message.type);
+		const expectsResponse = !(message.type === "subscribe_collection" || message.type === "subscribe_one" || message.type === "unsubscribe" || CHANNEL_MESSAGE_TYPES.has(message.type));
 		if (expectsResponse && !this.pendingRequests.has(requestId)) {
 			const timeoutHandle = setTimeout(() => {
 				if (this.pendingRequests.has(requestId)) {
@@ -16504,6 +16741,9 @@ var RebaseWebSocketClient = class {
 	async fetchAvailableRoles() {
 		return (await this.sendMessage({ type: "FETCH_ROLES" })).roles || [];
 	}
+	async fetchApplicationRoles() {
+		return (await this.sendMessage({ type: "FETCH_APPLICATION_ROLES" })).roles || [];
+	}
 	async fetchCurrentDatabase() {
 		return (await this.sendMessage({ type: "FETCH_CURRENT_DATABASE" })).database;
 	}
@@ -16663,6 +16903,7 @@ var RebaseWebSocketClient = class {
 		});
 	}
 	listenCollection(props, onUpdate, onError) {
+		this.ensureConnected();
 		const subscriptionKey = this.createCollectionSubscriptionKey(props);
 		const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 		const existingSubscription = this.collectionSubscriptions.get(subscriptionKey);
@@ -16678,9 +16919,12 @@ var RebaseWebSocketClient = class {
 				console.error("Error in collection subscription callback:", error);
 				if (onError) onError(error instanceof Error ? error : new Error(String(error)));
 			}
+			else if (!existingSubscription.subscribeInFlight) this.sendCollectionSubscribe(subscriptionKey);
 			return () => {
 				callbackMap.delete(callbackId);
 				if (callbackMap.size === 0) {
+					if (this.collectionSubscriptions.get(subscriptionKey) !== existingSubscription) return;
+					if (existingSubscription.subscribeTimeout) clearTimeout(existingSubscription.subscribeTimeout);
 					this.collectionSubscriptions.delete(subscriptionKey);
 					this.backendToCollectionKey.delete(existingSubscription.backendSubscriptionId);
 					if (this.isConnected && this.ws) this.sendMessage({
@@ -16702,21 +16946,14 @@ var RebaseWebSocketClient = class {
 			props
 		});
 		this.backendToCollectionKey.set(backendSubscriptionId, subscriptionKey);
-		this.sendMessage({
-			type: "subscribe_collection",
-			payload: {
-				...props,
-				subscriptionId: backendSubscriptionId
-			}
-		}).catch((error) => {
-			if (onError) onError(error);
-		});
+		this.sendCollectionSubscribe(subscriptionKey);
 		return () => {
 			const subscription = this.collectionSubscriptions.get(subscriptionKey);
 			if (subscription) {
 				const callbacks = subscription.callbacks;
 				callbacks.delete(callbackId);
 				if (callbacks.size === 0) {
+					if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
 					this.collectionSubscriptions.delete(subscriptionKey);
 					this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
 					if (this.isConnected && this.ws) this.sendMessage({
@@ -16728,6 +16965,7 @@ var RebaseWebSocketClient = class {
 		};
 	}
 	listenOne(props, onUpdate, onError) {
+		this.ensureConnected();
 		const subscriptionKey = this.createSingleSubscriptionKey(props);
 		const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 		const existingSubscription = this.singleSubscriptions.get(subscriptionKey);
@@ -16743,9 +16981,12 @@ var RebaseWebSocketClient = class {
 				console.error("Error in row subscription callback:", error);
 				if (onError) onError(error instanceof Error ? error : new Error(String(error)));
 			}
+			else if (!existingSubscription.subscribeInFlight) this.sendEntitySubscribe(subscriptionKey);
 			return () => {
 				callbackMap.delete(callbackId);
 				if (callbackMap.size === 0) {
+					if (this.singleSubscriptions.get(subscriptionKey) !== existingSubscription) return;
+					if (existingSubscription.subscribeTimeout) clearTimeout(existingSubscription.subscribeTimeout);
 					this.singleSubscriptions.delete(subscriptionKey);
 					this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
 					if (this.isConnected && this.ws) this.sendMessage({
@@ -16767,15 +17008,7 @@ var RebaseWebSocketClient = class {
 			props
 		});
 		this.backendToEntityKey.set(backendSubscriptionId, subscriptionKey);
-		this.sendMessage({
-			type: "subscribe_one",
-			payload: {
-				...props,
-				subscriptionId: backendSubscriptionId
-			}
-		}).catch((error) => {
-			if (onError) onError(error);
-		});
+		this.sendEntitySubscribe(subscriptionKey);
 		return () => {
 			const subscription = this.singleSubscriptions.get(subscriptionKey);
 			if (subscription) {
@@ -16793,6 +17026,157 @@ var RebaseWebSocketClient = class {
 		};
 	}
 	/**
+	* Send a `subscribe_collection` for an already-registered subscription and
+	* arm its watchdog.
+	*
+	* Every path that registers a collection subscription goes through here, so
+	* that a subscribe which never lands — a rejected send, or a server that
+	* never answers — always ends up in `failCollectionSubscription` rather than
+	* leaving the entry parked with `isInitialDataReceived === false` forever.
+	*/
+	sendCollectionSubscribe(subscriptionKey) {
+		const subscription = this.collectionSubscriptions.get(subscriptionKey);
+		if (!subscription) return;
+		const backendSubscriptionId = subscription.backendSubscriptionId;
+		subscription.subscribeInFlight = true;
+		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
+		subscription.subscribeTimeout = void 0;
+		if (this.isConnected) this.sendCollectionSubscribeWatchdog(subscriptionKey);
+		this.sendMessage({
+			type: "subscribe_collection",
+			payload: {
+				...subscription.props,
+				subscriptionId: backendSubscriptionId
+			}
+		}).catch((error) => {
+			const current = this.collectionSubscriptions.get(subscriptionKey);
+			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
+			this.failCollectionSubscription(subscriptionKey, error instanceof Error ? error : new Error(String(error)));
+		});
+	}
+	/** The `listenOne` counterpart of {@link sendCollectionSubscribe}. */
+	sendEntitySubscribe(subscriptionKey) {
+		const subscription = this.singleSubscriptions.get(subscriptionKey);
+		if (!subscription) return;
+		const backendSubscriptionId = subscription.backendSubscriptionId;
+		subscription.subscribeInFlight = true;
+		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
+		subscription.subscribeTimeout = void 0;
+		if (this.isConnected) this.sendEntitySubscribeWatchdog(subscriptionKey);
+		this.sendMessage({
+			type: "subscribe_one",
+			payload: {
+				...subscription.props,
+				subscriptionId: backendSubscriptionId
+			}
+		}).catch((error) => {
+			const current = this.singleSubscriptions.get(subscriptionKey);
+			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
+			this.failEntitySubscription(subscriptionKey, error instanceof Error ? error : new Error(String(error)));
+		});
+	}
+	/**
+	* Report a subscribe failure to every listener and drop the registration.
+	*
+	* Dropping it is the point: the callbacks stay live (their components are
+	* still mounted and have been told), but the next `listenCollection` for
+	* these params finds no entry and issues a fresh subscribe instead of
+	* silently attaching to a dead one.
+	*/
+	failCollectionSubscription(subscriptionKey, error) {
+		const subscription = this.collectionSubscriptions.get(subscriptionKey);
+		if (!subscription) return;
+		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
+		subscription.subscribeInFlight = false;
+		this.collectionSubscriptions.delete(subscriptionKey);
+		this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
+		subscription.callbacks.forEach((callback) => {
+			if (callback.onError) try {
+				callback.onError(error);
+			} catch (callbackError) {
+				console.error("Error in collection subscription error callback:", callbackError);
+			}
+		});
+	}
+	/** The `listenOne` counterpart of {@link failCollectionSubscription}. */
+	failEntitySubscription(subscriptionKey, error) {
+		const subscription = this.singleSubscriptions.get(subscriptionKey);
+		if (!subscription) return;
+		if (subscription.subscribeTimeout) clearTimeout(subscription.subscribeTimeout);
+		subscription.subscribeInFlight = false;
+		this.singleSubscriptions.delete(subscriptionKey);
+		this.backendToEntityKey.delete(subscription.backendSubscriptionId);
+		subscription.callbacks.forEach((callback) => {
+			if (callback.onError) try {
+				callback.onError(error);
+			} catch (callbackError) {
+				console.error("Error in row subscription error callback:", callbackError);
+			}
+		});
+	}
+	/**
+	* Stop the watchdogs without failing anything — used when the socket drops,
+	* since the reconnect path re-subscribes everything anyway and a watchdog
+	* firing mid-reconnect would tear down healthy subscriptions.
+	*/
+	suspendSubscribeWatchdogs() {
+		for (const sub of this.collectionSubscriptions.values()) {
+			if (sub.subscribeTimeout) clearTimeout(sub.subscribeTimeout);
+			sub.subscribeTimeout = void 0;
+			sub.subscribeInFlight = false;
+		}
+		for (const sub of this.singleSubscriptions.values()) {
+			if (sub.subscribeTimeout) clearTimeout(sub.subscribeTimeout);
+			sub.subscribeTimeout = void 0;
+			sub.subscribeInFlight = false;
+		}
+	}
+	/**
+	* Arm watchdogs for subscribes that were requested while offline and have
+	* just been flushed to the socket. Their timers were deliberately not set at
+	* request time, so without this they would have no timeout at all.
+	*/
+	armPendingSubscribeWatchdogs() {
+		for (const [key, sub] of this.collectionSubscriptions.entries()) if (sub.subscribeInFlight && !sub.subscribeTimeout) this.sendCollectionSubscribeWatchdog(key);
+		for (const [key, sub] of this.singleSubscriptions.entries()) if (sub.subscribeInFlight && !sub.subscribeTimeout) this.sendEntitySubscribeWatchdog(key);
+	}
+	sendCollectionSubscribeWatchdog(subscriptionKey) {
+		const subscription = this.collectionSubscriptions.get(subscriptionKey);
+		if (!subscription) return;
+		const backendSubscriptionId = subscription.backendSubscriptionId;
+		subscription.subscribeTimeout = setTimeout(() => {
+			const current = this.collectionSubscriptions.get(subscriptionKey);
+			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
+			if (!current.subscribeInFlight) return;
+			this.failCollectionSubscription(subscriptionKey, new RebaseApiError("Subscription timed out", { code: "SUBSCRIPTION_TIMEOUT" }));
+		}, this.subscriptionTimeoutMs);
+	}
+	sendEntitySubscribeWatchdog(subscriptionKey) {
+		const subscription = this.singleSubscriptions.get(subscriptionKey);
+		if (!subscription) return;
+		const backendSubscriptionId = subscription.backendSubscriptionId;
+		subscription.subscribeTimeout = setTimeout(() => {
+			const current = this.singleSubscriptions.get(subscriptionKey);
+			if (!current || current.backendSubscriptionId !== backendSubscriptionId) return;
+			if (!current.subscribeInFlight) return;
+			this.failEntitySubscription(subscriptionKey, new RebaseApiError("Subscription timed out", { code: "SUBSCRIPTION_TIMEOUT" }));
+		}, this.subscriptionTimeoutMs);
+	}
+	/**
+	* Fail every subscription that never received data. Called when reconnection
+	* is given up on, so views surface an error instead of spinning forever.
+	*/
+	failAllPendingSubscriptions(error) {
+		for (const key of [...this.collectionSubscriptions.keys()]) {
+			const sub = this.collectionSubscriptions.get(key);
+			if (sub && !sub.isInitialDataReceived) this.failCollectionSubscription(key, error);
+		}
+		for (const key of [...this.singleSubscriptions.keys()]) {
+			const sub = this.singleSubscriptions.get(key);
+			if (sub && !sub.isInitialDataReceived) this.failEntitySubscription(key, error);
+		}
+	}
+	/**
 	* Re-send all active subscriptions to the backend after a reconnect.
 	* The server wipes subscription state when a client disconnects, so
 	* we need to re-register everything to resume receiving updates.
@@ -16805,15 +17189,7 @@ var RebaseWebSocketClient = class {
 			sub.backendSubscriptionId = newBackendId;
 			this.backendToCollectionKey.delete(oldBackendId);
 			this.backendToCollectionKey.set(newBackendId, key);
-			this.sendMessage({
-				type: "subscribe_collection",
-				payload: {
-					...sub.props,
-					subscriptionId: newBackendId
-				}
-			}).catch((error) => {
-				console.error("[WS] Failed to re-subscribe collection:", key, error);
-			});
+			this.sendCollectionSubscribe(key);
 		}
 		for (const [key, sub] of this.singleSubscriptions.entries()) {
 			const oldBackendId = sub.backendSubscriptionId;
@@ -16821,15 +17197,7 @@ var RebaseWebSocketClient = class {
 			sub.backendSubscriptionId = newBackendId;
 			this.backendToEntityKey.delete(oldBackendId);
 			this.backendToEntityKey.set(newBackendId, key);
-			this.sendMessage({
-				type: "subscribe_one",
-				payload: {
-					...sub.props,
-					subscriptionId: newBackendId
-				}
-			}).catch((error) => {
-				console.error("[WS] Failed to re-subscribe row:", key, error);
-			});
+			this.sendEntitySubscribe(key);
 		}
 	}
 	createCollectionSubscriptionKey(props) {
@@ -16856,6 +17224,377 @@ var RebaseWebSocketClient = class {
 	}
 };
 /**
+* Re-send presence comfortably inside the server's 30s expiry.
+*
+* Two-thirds of the window: one lost heartbeat still leaves time for the next
+* before the entry is reaped, so a single dropped frame is not a disappearance.
+*/
+var PRESENCE_HEARTBEAT_MS = 2e4;
+/**
+* How long live messages are held back waiting for a catch-up response.
+*
+* Short, because the cost of waiting is visible — on a collaborative document
+* this is a stall in everyone else's edits appearing. Long enough that a slow
+* replay of a busy channel is not abandoned needlessly.
+*/
+var CATCH_UP_TIMEOUT_MS = 1e4;
+var RebaseRealtimeChannel = class {
+	name;
+	transport;
+	presenceHandlers = /* @__PURE__ */ new Set();
+	broadcastHandlers = /* @__PURE__ */ new Set();
+	unsubscribers = [];
+	/** Last known roster, kept so handlers always get a full picture. */
+	presences = {};
+	/** What this client last tracked, replayed on reconnect and heartbeat. */
+	trackedState = null;
+	heartbeat = null;
+	joined = false;
+	/** Whether this handle asks the server to replay missed messages. */
+	wantsHistory;
+	/**
+	* Highest sequence number delivered to handlers so far.
+	*
+	* This is the resume point sent as `sinceSeq`, and the watermark that makes
+	* replay idempotent: catch-up ranges overlap with what arrived live, and
+	* anything at or below this has already been seen.
+	*/
+	lastSeq = 0;
+	/**
+	* Live messages that arrived while a catch-up was in flight.
+	*
+	* Without this they would be delivered ahead of the older messages being
+	* fetched, and — worse — would advance {@link lastSeq} past them, so the
+	* catch-up response would then be discarded as already-seen and those
+	* messages would be lost for good. Held here and flushed, in order, once
+	* the replay lands.
+	*/
+	pendingLive = [];
+	catchUpInFlight = false;
+	/**
+	* Deadline for a catch-up response.
+	*
+	* Buffering live messages is only safe because the wait is bounded. A
+	* catch-up frame that never arrives — a server that dropped it, a socket
+	* that died between request and reply — would otherwise leave the channel
+	* silently holding every subsequent edit forever, which is a worse failure
+	* than the one replay was added to fix.
+	*/
+	catchUpTimeout = null;
+	/**
+	* Callers of {@link history} awaiting the next `channel_history` frame.
+	*
+	* These frames are addressed by channel rather than by request id, so they
+	* are matched in arrival order. Requests on one channel are serialized by
+	* the socket, so FIFO is the right correlation here.
+	*/
+	historyWaiters = [];
+	constructor(name, transport, options = {}) {
+		this.name = name;
+		this.transport = transport;
+		this.wantsHistory = options.history ?? false;
+	}
+	/**
+	* Turn on catch-up for a handle that was created without it.
+	*
+	* The client hands back the same channel object for a given name, so a
+	* later `channel(name, { history: true })` has no new object to configure —
+	* it upgrades this one instead. Idempotent, and never downgrades: one
+	* caller asking for history must not be switched off by another that did
+	* not ask.
+	*/
+	enableHistory() {
+		if (this.wantsHistory) return;
+		this.wantsHistory = true;
+		if (this.joined) this.requestHistory();
+	}
+	/**
+	* Join the channel and ask for the current roster.
+	*
+	* Called automatically by `track`, `broadcast`, `onPresence` and
+	* `onBroadcast`; calling it directly is only needed to start receiving
+	* before there is anything to send.
+	*/
+	/**
+	* Send a channel message.
+	*
+	* Every channel message is read by the server out of a `payload` envelope
+	* (`payload?.channel`, `payload?.state`, `payload?.event`). Sending those
+	* fields flat does not error: `payload?.channel` simply reads as
+	* `undefined`, so the client is registered into channel `undefined` with
+	* empty state, and the echo comes back with no `channel` for
+	* `onChannelMessage` to match — presence and broadcast both go quiet with
+	* nothing logged. Funnelled through one place so a new message type cannot
+	* reintroduce that.
+	*/
+	send(type, fields = {}) {
+		return this.transport.sendMessage({
+			type,
+			payload: {
+				channel: this.name,
+				...fields
+			}
+		});
+	}
+	async join() {
+		if (this.joined) return;
+		this.joined = true;
+		this.unsubscribers.push(this.transport.onChannelMessage(this.name, (message) => this.handle(message)));
+		this.unsubscribers.push(this.transport.onReconnect(() => {
+			this.rejoin();
+		}));
+		await this.send("join_channel");
+		await this.send("presence_state");
+		if (this.wantsHistory) await this.requestHistory();
+	}
+	async rejoin() {
+		try {
+			await this.send("join_channel");
+			await this.send("presence_state");
+			if (this.trackedState) await this.send("presence_track", { state: this.trackedState });
+			if (this.wantsHistory) await this.requestHistory();
+		} catch {}
+	}
+	/**
+	* Ask the server for everything after {@link lastSeq}.
+	*
+	* Live messages are buffered from here until the answer arrives — see
+	* {@link pendingLive}.
+	*/
+	async requestHistory(limit) {
+		this.catchUpInFlight = true;
+		if (this.catchUpTimeout) clearTimeout(this.catchUpTimeout);
+		this.catchUpTimeout = setTimeout(() => this.abandonCatchUp(), CATCH_UP_TIMEOUT_MS);
+		this.catchUpTimeout.unref?.();
+		try {
+			await this.send("channel_history", {
+				sinceSeq: this.lastSeq,
+				...limit !== void 0 ? { limit } : {}
+			});
+		} catch {
+			this.abandonCatchUp();
+		}
+	}
+	/**
+	* Give up waiting for a catch-up and release what was held back.
+	*
+	* The buffered messages are still the freshest thing this client has, so
+	* they are delivered rather than dropped. Callers of {@link history} are
+	* answered with `retained: false` — accurate in the sense that matters:
+	* this client has no history to work from and has to resync.
+	*/
+	abandonCatchUp() {
+		if (this.catchUpTimeout) {
+			clearTimeout(this.catchUpTimeout);
+			this.catchUpTimeout = null;
+		}
+		if (!this.catchUpInFlight) return;
+		this.catchUpInFlight = false;
+		for (const resolve of this.historyWaiters.splice(0)) resolve({
+			messages: [],
+			retained: false
+		});
+		this.flushPendingLive();
+	}
+	/**
+	* Publish this client's presence state, and keep publishing it.
+	*
+	* Calling `track` again replaces the state (and restarts the heartbeat),
+	* which is how you update e.g. a cursor position.
+	*/
+	async track(state) {
+		await this.join();
+		this.trackedState = state;
+		await this.send("presence_track", { state });
+		if (!this.heartbeat) {
+			this.heartbeat = setInterval(() => {
+				if (!this.trackedState) return;
+				this.send("presence_track", { state: this.trackedState }).catch(() => {});
+			}, PRESENCE_HEARTBEAT_MS);
+			this.heartbeat.unref?.();
+		}
+	}
+	/** Stop publishing presence, without leaving the channel. */
+	async untrack() {
+		this.stopHeartbeat();
+		this.trackedState = null;
+		if (this.joined) await this.send("presence_untrack");
+	}
+	/**
+	* Observe the roster. The handler fires immediately with what is already
+	* known, then on every change.
+	*/
+	onPresence(handler) {
+		this.presenceHandlers.add(handler);
+		this.join();
+		if (Object.keys(this.presences).length > 0) handler({ ...this.presences });
+		return () => this.presenceHandlers.delete(handler);
+	}
+	/** Send a broadcast. The sender does not receive its own message. */
+	async broadcast(event, payload) {
+		await this.join();
+		await this.send("broadcast", {
+			event,
+			payload
+		});
+	}
+	onBroadcast(eventOrHandler, maybeHandler) {
+		const wrapped = typeof eventOrHandler === "string" ? (e) => {
+			if (e.event === eventOrHandler) maybeHandler(e.payload);
+		} : eventOrHandler;
+		this.broadcastHandlers.add(wrapped);
+		this.join();
+		return () => this.broadcastHandlers.delete(wrapped);
+	}
+	/**
+	* The last sequence number this channel has delivered.
+	*
+	* Zero on a channel that retains nothing. Persist it if you want catch-up
+	* to survive a page reload as well as a reconnect, and pass it back via
+	* {@link history}.
+	*/
+	get sequence() {
+		return this.lastSeq;
+	}
+	/**
+	* Fetch retained messages explicitly, instead of waiting for join or
+	* reconnect to do it.
+	*
+	* Defaults to resuming from {@link sequence}. Messages are delivered to
+	* `onBroadcast` handlers as usual — the returned value is for callers that
+	* want to inspect the batch, or to learn from `retained` that the channel
+	* keeps no history at all.
+	*/
+	async history(options = {}) {
+		await this.join();
+		if (options.sinceSeq !== void 0) this.lastSeq = options.sinceSeq;
+		const result = new Promise((resolve) => {
+			this.historyWaiters.push(resolve);
+		});
+		await this.requestHistory(options.limit);
+		return result;
+	}
+	/** Leave the channel and release every listener and timer. */
+	async leave() {
+		this.stopHeartbeat();
+		this.trackedState = null;
+		this.presences = {};
+		this.presenceHandlers.clear();
+		this.broadcastHandlers.clear();
+		this.lastSeq = 0;
+		this.pendingLive = [];
+		this.catchUpInFlight = false;
+		if (this.catchUpTimeout) {
+			clearTimeout(this.catchUpTimeout);
+			this.catchUpTimeout = null;
+		}
+		for (const resolve of this.historyWaiters.splice(0)) resolve({
+			messages: [],
+			retained: false
+		});
+		for (const off of this.unsubscribers) off();
+		this.unsubscribers = [];
+		if (this.joined) {
+			this.joined = false;
+			await this.send("leave_channel");
+		}
+	}
+	stopHeartbeat() {
+		if (this.heartbeat) {
+			clearInterval(this.heartbeat);
+			this.heartbeat = null;
+		}
+	}
+	/** Fold an incoming frame into the roster and fan it out. */
+	handle(message) {
+		switch (message.type) {
+			case "presence_state":
+				this.presences = message.presences ?? {};
+				this.emitPresence();
+				break;
+			case "presence_diff": {
+				const joins = message.joins ?? {};
+				const leaves = message.leaves ?? {};
+				for (const [id, state] of Object.entries(joins)) this.presences[id] = state;
+				for (const id of Object.keys(leaves)) delete this.presences[id];
+				this.emitPresence({
+					joins,
+					leaves
+				});
+				break;
+			}
+			case "broadcast": {
+				const seq = typeof message.seq === "number" ? message.seq : void 0;
+				const event = {
+					event: message.event,
+					payload: message.payload,
+					...seq !== void 0 ? { seq } : {}
+				};
+				if (seq === void 0) {
+					this.deliver(event);
+					break;
+				}
+				if (this.catchUpInFlight) {
+					this.pendingLive.push(event);
+					break;
+				}
+				if (seq <= this.lastSeq) break;
+				this.lastSeq = seq;
+				this.deliver(event);
+				break;
+			}
+			case "channel_history": {
+				this.catchUpInFlight = false;
+				if (this.catchUpTimeout) {
+					clearTimeout(this.catchUpTimeout);
+					this.catchUpTimeout = null;
+				}
+				const entries = message.messages ?? [];
+				const retained = message.retained === true;
+				const latestSeq = typeof message.latestSeq === "number" ? message.latestSeq : void 0;
+				for (const resolve of this.historyWaiters.splice(0)) resolve({
+					messages: entries,
+					retained,
+					latestSeq
+				});
+				for (const entry of entries) {
+					if (entry.seq <= this.lastSeq) continue;
+					this.lastSeq = entry.seq;
+					this.deliver({
+						event: entry.event,
+						payload: entry.payload,
+						seq: entry.seq,
+						replayed: true
+					});
+				}
+				this.flushPendingLive();
+				break;
+			}
+		}
+	}
+	/** Deliver everything held back during a catch-up, in sequence order. */
+	flushPendingLive() {
+		if (this.pendingLive.length === 0) return;
+		const buffered = this.pendingLive.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+		this.pendingLive = [];
+		for (const event of buffered) {
+			const seq = event.seq;
+			if (seq !== void 0) {
+				if (seq <= this.lastSeq) continue;
+				this.lastSeq = seq;
+			}
+			this.deliver(event);
+		}
+	}
+	deliver(event) {
+		for (const handler of [...this.broadcastHandlers]) handler(event);
+	}
+	emitPresence(diff) {
+		const snapshot = { ...this.presences };
+		for (const handler of this.presenceHandlers) handler(snapshot, diff);
+	}
+};
+/**
 * Derive a WebSocket URL from an HTTP base URL.
 * `http://` → `ws://`, `https://` → `wss://`.
 */
@@ -16904,6 +17643,8 @@ function createRebaseClient(options) {
 	};
 	const resolvedWsUrl = options.realtime !== false ? options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl) : void 0;
 	let ws;
+	/** One channel object per name — see `realtime.channel`. */
+	const realtimeChannels = /* @__PURE__ */ new Map();
 	if (resolvedWsUrl) {
 		ws = new RebaseWebSocketClient({
 			websocketUrl: resolvedWsUrl,
@@ -16927,7 +17668,7 @@ function createRebaseClient(options) {
 			if (!ws) return;
 			if (event === "SIGNED_OUT") ws.disconnect();
 			else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-				if (session?.accessToken) ws.authenticate(session.accessToken).catch(console.warn);
+				if (session?.accessToken && ws.hasSocket) ws.authenticate(session.accessToken).catch(console.warn);
 			}
 		});
 	}
@@ -17014,6 +17755,24 @@ function createRebaseClient(options) {
 		createStorageSource,
 		fetchStorageSources,
 		ws,
+		realtime: { 
+		/**
+		* Join a broadcast/presence channel.
+		*
+		* Repeated calls with the same name return the same channel, so
+		* separate components can attach handlers without each opening its
+		* own membership — and `leave()` from one would otherwise silently
+		* cut off the others.
+		*/
+channel: (name, options) => {
+			if (!ws) throw new RebaseClientError("Realtime is disabled on this client (realtime: false), so channels are unavailable.");
+			let existing = realtimeChannels.get(name);
+			if (!existing) {
+				existing = new RebaseRealtimeChannel(name, ws, options);
+				realtimeChannels.set(name, existing);
+			} else if (options?.history) existing.enableHistory();
+			return existing;
+		} },
 		/**
 		* Release the realtime socket and its reconnect timer.
 		*
@@ -17022,7 +17781,9 @@ function createRebaseClient(options) {
 		* was never started, and safe to call twice.
 		*/
 		close: () => {
-			ws?.disconnect();
+			for (const channel of realtimeChannels.values()) channel.leave();
+			realtimeChannels.clear();
+			ws?.disconnect(true);
 		},
 		setToken: transport.setToken,
 		setAuthTokenGetter: transport.setAuthTokenGetter,
@@ -17663,7 +18424,8 @@ async function _initializeRebaseBackend(config) {
 			registry: storageRegistry,
 			sources: config.storageSources,
 			requireAuth: resolveRequireAuth(config.auth),
-			authAdapter
+			authAdapter,
+			authorize: config.storageAuthorize
 		});
 		const storageRouter = new Hono();
 		if (apiKeyPreAuth) storageRouter.use("/*", apiKeyPreAuth, createStorageApiKeyGuard());
@@ -17932,7 +18694,7 @@ async function loadFunctionsFromDirectory(directory, importModule = nativeDynami
 	const problems = [];
 	if (!fs$2.existsSync(directory)) return functions;
 	const files = fs$2.readdirSync(directory);
-	for (const file of files) if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js") {
+	for (const file of files) if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.startsWith(".") && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js") {
 		const filePath = path$1.join(directory, file);
 		try {
 			const fileUrl = pathToFileURL(filePath).href;
@@ -18061,7 +18823,7 @@ async function loadCronJobsFromDirectory(directory, importModule = nativeDynamic
 	const jobs = [];
 	if (!fs$2.existsSync(directory)) return jobs;
 	const files = fs$2.readdirSync(directory);
-	for (const file of files) if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js") {
+	for (const file of files) if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.startsWith(".") && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js") {
 		const filePath = path$1.join(directory, file);
 		try {
 			const fileUrl = pathToFileURL(filePath).href;
@@ -18335,6 +19097,7 @@ var CronScheduler = class {
 			logger.warn("[cron] Failed to seed job stats from database", { error: err });
 		});
 		for (const [id, job] of this.jobs) if (job.enabled) this.scheduleNext(id);
+		if (!this.store) logger.warn("[cron] No cron store attached — runs are uncoordinated; with multiple app instances every instance will execute every job");
 		logger.info(`⏰ Cron scheduler started with ${this.jobs.size} job(s)`);
 	}
 	/**
@@ -18453,6 +19216,19 @@ var CronScheduler = class {
 					this.scheduleNext(id);
 					return;
 				}
+				if (this.store?.tryClaimRun) {
+					let claimed = true;
+					try {
+						claimed = await this.store.tryClaimRun(id, nextRun.toISOString());
+					} catch (err) {
+						logger.warn(`[cron] Claim check threw for "${id}" — running uncoordinated`, { error: err });
+					}
+					if (!claimed) {
+						logger.info(`[cron] Slot ${nextRun.toISOString()} for "${id}" claimed by another instance — skipping`);
+						if (this.started && job.enabled) this.scheduleNext(id);
+						return;
+					}
+				}
 				await this.executeJob(job, false);
 				if (this.started && job.enabled) this.scheduleNext(id);
 			}, Math.max(rawDelay, MIN_SCHEDULE_INTERVAL_MS));
@@ -18621,6 +19397,25 @@ function createCronRoutes(scheduler) {
 //#region src/cron/cron-store.ts
 var cron_store_exports = /* @__PURE__ */ __exportAll({ createCronStore: () => createCronStore });
 var TABLE = "rebase.cron_logs";
+var CLAIMS_TABLE = "rebase.cron_claims";
+/** Claims older than this are garbage-collected on startup. */
+var CLAIM_RETENTION_DAYS = 7;
+/**
+* Detect a unique-constraint violation anywhere in an error's cause chain.
+* Drizzle wraps the PG error — match the SQLSTATE code, never message text.
+* Also covers SQLite ("UNIQUE constraint failed") and MySQL (ER_DUP_ENTRY 1062)
+* for future SQL drivers.
+*/
+function isUniqueViolation(err) {
+	let current = err;
+	for (let depth = 0; depth < 10 && current; depth++) if (typeof current === "object") {
+		const e = current;
+		if (e.code === "23505" || e.errno === 1062) return true;
+		if (typeof e.message === "string" && e.message.includes("UNIQUE constraint failed")) return true;
+		current = e.cause;
+	} else break;
+	return false;
+}
 function createCronStore(driver) {
 	const admin = driver.admin;
 	if (!isSQLAdmin(admin)) {
@@ -18650,6 +19445,15 @@ function createCronStore(driver) {
                     CREATE INDEX IF NOT EXISTS idx_cron_logs_job
                     ON ${TABLE}(job_id, started_at DESC)
                 `);
+				await exec(`
+                    CREATE TABLE IF NOT EXISTS ${CLAIMS_TABLE} (
+                        job_id TEXT NOT NULL,
+                        slot TIMESTAMPTZ NOT NULL,
+                        claimed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+                        PRIMARY KEY (job_id, slot)
+                    )
+                `);
+				await exec(`DELETE FROM ${CLAIMS_TABLE} WHERE claimed_at < now() - make_interval(days => $1)`, { params: [CLAIM_RETENTION_DAYS] });
 				logger.info("✅ Cron logs table ready");
 			} catch (err) {
 				logger.error("❌ Failed to create cron logs table", { error: err });
@@ -18709,6 +19513,18 @@ function createCronStore(driver) {
 				logger.error("[cron-store] Failed to fetch job stats", { error: err });
 			}
 			return stats;
+		},
+		async tryClaimRun(jobId, slot) {
+			try {
+				return (await exec(`INSERT INTO ${CLAIMS_TABLE} (job_id, slot)
+                     VALUES ($1, $2)
+                     ON CONFLICT (job_id, slot) DO NOTHING
+                     RETURNING job_id`, { params: [jobId, slot] })).length > 0;
+			} catch (err) {
+				if (isUniqueViolation(err)) return false;
+				logger.warn(`[cron-store] Claim check failed for "${jobId}" — running uncoordinated`, { error: err });
+				return true;
+			}
 		}
 	};
 }
@@ -19008,7 +19824,10 @@ var rebaseEnvSchema = object({
 	S3_ACCESS_KEY_ID: string().optional(),
 	S3_SECRET_ACCESS_KEY: string().optional(),
 	S3_ENDPOINT: string().url().optional(),
-	S3_FORCE_PATH_STYLE: optionalBoolString
+	S3_FORCE_PATH_STYLE: optionalBoolString,
+	GCS_BUCKET: string().optional(),
+	GCS_PROJECT_ID: string().optional(),
+	GCS_KEY_FILENAME: string().optional()
 });
 function loadEnv(options) {
 	const isProduction = process.env.NODE_ENV === "production";