better-supabase 0.8.0 → 0.9.0

package/dist/support-BsKkvA92.js

@@ -0,0 +1,522 @@
+import { c as mapDbError, n as dbError } from "./errors-8i6tSICm.js";
+import { t as temporal } from "./temporal-required-DqRzr7i0.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-BlgnMB0H.js";
+import { n as validate } from "./standard-B5fe2gnW.js";
+import { o as problemResponse } from "./problem-pIiL3WbE.js";
+import { t as fromPgError } from "./pg-error-BV_X8Isq.js";
+import { d as clearSupportCookie, f as supportCookie, m as supportCookieValue } from "./adapter-CEjmtazZ.js";
+import { i as sqlIdent } from "./template-DdgYjIZ5.js";
+import { a as emitBlockEvent } from "./block-events-DD9Q_NUz.js";
+import { t as cronRoute } from "./cron-route-CoL-By8Z.js";
+import { t as boundedTtlCache } from "./ttl-cache-XzZ-Q2eX.js";
+//#region src/auth/support.ts
+/** A request from the jsonb the `support-sessions` request functions return. */
+function supportRequestFromRow(row, namespace) {
+	const Instant = (namespace ?? temporal()).Instant;
+	return {
+		id: row.id,
+		adminId: row.admin_id,
+		targetUserId: row.target_user_id,
+		reason: row.reason,
+		readOnly: row.read_only,
+		...row.tenant === null ? {} : { tenant: String(row.tenant) },
+		metadata: row.metadata ?? {},
+		requestedAt: Instant.from(row.requested_at),
+		expiresAt: Instant.from(row.expires_at),
+		...row.approved_by === null ? {} : { approvedBy: row.approved_by },
+		...row.approved_at === null ? {} : { approvedAt: Instant.from(row.approved_at) },
+		...row.session_id === null ? {} : { sessionId: row.session_id }
+	};
+}
+/**
+* A session from the jsonb the `support-sessions` functions return, with
+* `namespace` (else the provided or global Temporal) for its time values.
+*/
+function supportSessionFromRow(row, namespace) {
+	const Instant = (namespace ?? temporal()).Instant;
+	const instant = (value) => Instant.from(value);
+	return {
+		id: row.id,
+		adminId: row.admin_id,
+		targetUserId: row.target_user_id,
+		reason: row.reason,
+		readOnly: row.read_only ?? true,
+		...row.tenant === null ? {} : { tenant: String(row.tenant) },
+		startedAt: instant(row.started_at),
+		expiresAt: instant(row.expires_at),
+		...row.ended_at === null ? {} : { endedAt: instant(row.ended_at) },
+		...row.ended_by === null ? {} : { endedBy: row.ended_by },
+		metadata: row.metadata ?? {}
+	};
+}
+/**
+* Support sessions in the `support-sessions` SQL module. `start` runs
+* as the admin, so the module's `is_platform()` gate applies; the reads run
+* on the admin connection.
+*/
+function sqlSupportStore(postgres, options = {}) {
+	const fn = (name) => `${sqlIdent(options.schema ?? "better_supabase")}.${sqlIdent(name)}`;
+	const as = (claims) => claims ? postgres.asUser(claims) : postgres.admin;
+	const one = async (client, text, params) => {
+		const [row] = await client.queryRaw(text, params);
+		return row?.session ?? null;
+	};
+	return {
+		apiVersion: 1,
+		name: "sql",
+		async start(input) {
+			const row = await one(postgres.asUser(input.adminClaims), `select ${fn("start_support_session")}($1, $2, $3::interval, $4, $5, $6, $7) as session`, [
+				input.targetUserId,
+				input.reason,
+				`${String(input.ttlSeconds)} seconds`,
+				input.readOnly,
+				JSON.stringify(input.metadata),
+				input.tenant ?? null,
+				input.adminId
+			]);
+			if (!row) throw new Error("start_support_session returned no session");
+			return supportSessionFromRow(row, options.temporal);
+		},
+		async get(sessionId, adminId, claims) {
+			const row = await one(as(claims), `select ${fn("active_support_session")}($1, $2) as session`, [sessionId, adminId]);
+			return row ? supportSessionFromRow(row, options.temporal) : void 0;
+		},
+		async end(sessionId, endedBy, claims) {
+			const [row] = await as(claims).queryRaw(`select ${fn("end_support_session")}($1, $2) as ended`, [sessionId, endedBy]);
+			return row?.ended === true;
+		},
+		async list(filter = {}, claims) {
+			return (await as(claims).queryRaw(`select session from ${fn("list_support_sessions")}($1, $2, $3, $4) as session`, [
+				filter.adminId ?? null,
+				filter.targetUserId ?? null,
+				filter.active ?? null,
+				filter.limit ?? 50
+			])).map((row) => supportSessionFromRow(row.session, options.temporal));
+		},
+		async expire() {
+			return (await postgres.admin.queryRaw(`select session from ${fn("expire_support_sessions")}() as session`)).map((row) => supportSessionFromRow(row.session, options.temporal));
+		},
+		withTemporal: (namespace) => options.temporal === void 0 ? sqlSupportStore(postgres, {
+			...options,
+			temporal: namespace
+		}) : sqlSupportStore(postgres, options),
+		async claims(targetUserId) {
+			const [row] = await postgres.admin.queryRaw(`select ${fn("support_target_claims")}($1) as claims`, [targetUserId]);
+			return row?.claims ?? {};
+		},
+		async request(input) {
+			const row = await oneRequest(input.approvedBy !== void 0 ? postgres.admin : postgres.asUser(input.adminClaims), `select ${fn("request_support_session")}($1, $2, $3, $4, $5, $6, $7) as request`, [
+				input.targetUserId,
+				input.reason,
+				input.readOnly,
+				JSON.stringify(input.metadata),
+				input.tenant ?? null,
+				input.adminId,
+				input.approvedBy ?? null
+			]);
+			if (!row) throw new Error("request_support_session returned no request");
+			return supportRequestFromRow(row, options.temporal);
+		},
+		async getRequest(requestId) {
+			const row = await oneRequest(postgres.admin, `select ${fn("support_request")}($1) as request`, [requestId]);
+			return row ? supportRequestFromRow(row, options.temporal) : void 0;
+		},
+		async approve(requestId, approver) {
+			const row = await oneRequest(as(approver.claims), `select ${fn("approve_support_request")}($1, $2) as request`, [requestId, approver.id]);
+			if (!row) throw new Error("approve_support_request returned no request");
+			return supportRequestFromRow(row, options.temporal);
+		},
+		async approvedRequest(query) {
+			const row = await oneRequest(postgres.admin, `select ${fn("approved_support_request")}($1, $2, $3, $4) as request`, [
+				query.targetUserId,
+				query.tenant ?? null,
+				query.readOnly,
+				query.adminId
+			]);
+			return row ? supportRequestFromRow(row, options.temporal) : void 0;
+		}
+	};
+}
+async function oneRequest(client, text, params) {
+	const [row] = await client.queryRaw(text, params);
+	return row?.request ?? null;
+}
+/**
+* The claims a support session runs with: the target's, plus `act` naming
+* the admin, the reason and the session (the audit module records all three),
+* marked `kind: "support"` so `actorOf` never reads it as an OAuth client.
+* `role` falls back to `authenticated`; the admin's claims never leak in.
+*/
+function supportClaims(session, target) {
+	const role = target["role"];
+	return {
+		...target,
+		sub: session.targetUserId,
+		role: typeof role === "string" && role !== "" ? role : "authenticated",
+		act: {
+			kind: "support",
+			sub: session.adminId,
+			reason: session.reason,
+			session_id: session.id,
+			read_only: session.readOnly
+		}
+	};
+}
+//#endregion
+//#region src/server/support.ts
+/** The `kind` an `approverOf` hook sees for a support request; the SQL `isApprover` sees the same. */
+const SUPPORT_SESSION_APPROVAL = "support-session";
+/** How long a support target's claims are reused; a role change applies within it. */
+const CLAIMS_TTL_MS = 6e4;
+const CLAIMS_CACHE_SIZE = 1e3;
+const denied = (message, code) => dbError("forbidden", message, { code });
+const invalid = (message, code) => dbError("invalid_request", message, { code });
+function storeError(cause) {
+	const raw = fromPgError(cause);
+	return raw ? mapDbError(raw) : toDbError(cause);
+}
+/**
+* Support sessions for `createServer(betterSupabase, { support })`. Apps that
+* never import it don't bundle the support code.
+*/
+function supportSessions(options) {
+	return {
+		options,
+		create: (events, claimsSchema, temporal, authorization) => createSupport(options, events, claimsSchema, temporal, authorization)
+	};
+}
+const forbidden = () => denied("Not allowed to start a support session", "SUPPORT_FORBIDDEN");
+const selfApproval = () => denied("An admin cannot approve their own support session", "SUPPORT_SELF_APPROVAL");
+function createSupport(options, events, claimsSchema, temporal, authorization) {
+	const store = temporal !== void 0 && options.store.withTemporal ? options.store.withTemporal(temporal) : options.store;
+	const policy = options.policy ?? {};
+	const ttl = policy.ttl ?? 1800;
+	const maxTtl = policy.maxTtl ?? 14400;
+	const cookieName = options.cookie?.name;
+	const emit = (type, data) => {
+		emitBlockEvent(events, type, data, {
+			actorId: data.adminId,
+			...data.sessionId ? { subject: `support_sessions/${data.sessionId}` } : {}
+		});
+	};
+	const targetClaims = async (store, targetUserId) => {
+		if (options.claims) return options.claims(targetUserId);
+		if (store.claims) return store.claims(targetUserId);
+		return { role: "authenticated" };
+	};
+	/** Target claims per support session; the session itself is loaded every time, so revoking stays immediate. */
+	const claimsCache = boundedTtlCache({ max: CLAIMS_CACHE_SIZE });
+	const cachedTargetClaims = async (session) => {
+		const cached = claimsCache.get(session.id);
+		if (cached) return cached;
+		const claims = await targetClaims(store, session.targetUserId);
+		claimsCache.set(session.id, claims, Math.min(session.expiresAt.epochMilliseconds, Date.now() + CLAIMS_TTL_MS));
+		return claims;
+	};
+	const checkPolicy = (admin, request, reason, seconds) => {
+		if (admin.claims["act"] !== void 0) return denied("An impersonated session cannot start a support session", "SUPPORT_NESTED");
+		if (request.targetUserId === admin.user.id) return invalid("An admin cannot start a support session as themselves", "SUPPORT_SELF");
+		if ((policy.requireReason ?? true) && reason === "") return invalid("A reason is required", "SUPPORT_REASON_REQUIRED");
+		if (!Number.isFinite(seconds) || seconds <= 0 || seconds > maxTtl) return invalid(`ttl must be between 1 and ${String(maxTtl)} seconds`, "SUPPORT_TTL");
+	};
+	const approval = policy.approval ?? "distinct";
+	const authorize = options.authorize ?? authorization?.support?.authorize;
+	/** The decision for a start; a missing hook and a throw refuse it. */
+	const decide = async (input) => {
+		if (authorize === void 0) return false;
+		if (authorize === "store") return true;
+		try {
+			return await authorize(input);
+		} catch {
+			return false;
+		}
+	};
+	const mayApprove = async (approver, request) => {
+		const approverOf = authorization?.approverOf;
+		if (approverOf === void 0) return true;
+		try {
+			return await approverOf({
+				userId: approver.user.id,
+				claims: approver.claims
+			}, {
+				kind: SUPPORT_SESSION_APPROVAL,
+				subject: request.id,
+				requester: request.adminId,
+				...request.tenant === void 0 ? {} : { tenant: request.tenant }
+			});
+		} catch {
+			return false;
+		}
+	};
+	/** The approved request a start uses: recorded now for an `{ approvedBy }` decision, else looked up. */
+	const approvedRequest = async (admin, request, reason, readOnly, approvedBy) => {
+		const tenant = request.tenant === void 0 ? {} : { tenant: request.tenant };
+		if (approvedBy !== void 0) return store.request?.({
+			adminId: admin.user.id,
+			adminClaims: admin.claims,
+			targetUserId: request.targetUserId,
+			reason,
+			readOnly,
+			...tenant,
+			metadata: request.metadata ?? {},
+			approvedBy
+		});
+		return store.approvedRequest?.({
+			adminId: admin.user.id,
+			targetUserId: request.targetUserId,
+			readOnly,
+			...tenant
+		});
+	};
+	const noApprovals = () => dbError("unsupported", `The "${store.name}" support session store does not record approvals; set policy.approval to "none" or use a store that does`, { code: "SUPPORT_APPROVAL_UNSUPPORTED" });
+	const expire = () => AsyncResult.from(async () => {
+		if (!store.expire) return err(dbError("unsupported", `The "${store.name}" support session store has no expire()`, { code: "SUPPORT_EXPIRE_UNSUPPORTED" }));
+		let expired;
+		try {
+			expired = await store.expire();
+		} catch (cause) {
+			return err(storeError(cause));
+		}
+		for (const session of expired) emit("support.ended", {
+			sessionId: session.id,
+			adminId: session.adminId,
+			targetUserId: session.targetUserId,
+			reason: session.reason,
+			endedBy: "expired",
+			...session.tenant === void 0 ? {} : { organizationId: session.tenant }
+		});
+		return ok(expired);
+	});
+	const sessionIdOf = (request) => {
+		if (options.sessionId) try {
+			const id = options.sessionId(request);
+			return id === "" ? void 0 : id;
+		} catch (cause) {
+			events.logger.warn("support.sessionId threw", { cause });
+			return;
+		}
+		return supportCookieValue(request.headers.get("cookie"), cookieName);
+	};
+	const resolve = async (id, auth) => {
+		if (auth.kind !== "user") return;
+		if (auth.claims["act"] !== void 0) return;
+		if (!id) return;
+		let session;
+		let claims;
+		try {
+			session = await store.get(id, auth.user.id, auth.claims);
+			if (!session || session.expiresAt.epochMilliseconds <= Date.now()) return;
+			if (policy.readOnly !== "default" && !session.readOnly) session = {
+				...session,
+				readOnly: true
+			};
+			claims = supportClaims(session, await cachedTargetClaims(session));
+		} catch (cause) {
+			events.logger.warn("Could not load the support session", { cause });
+			return;
+		}
+		if (claimsSchema) {
+			const checked = await validate(claimsSchema, claims, "claims");
+			if (!checked.ok) {
+				events.logger.warn("The support target's claims fail the claims schema", { sessionId: session.id });
+				return;
+			}
+			if (typeof checked.data === "object" && checked.data !== null) claims = {
+				...claims,
+				...checked.data
+			};
+		}
+		return {
+			session,
+			admin: {
+				id: auth.user.id,
+				...auth.user.email ? { email: auth.user.email } : {}
+			},
+			claims
+		};
+	};
+	return {
+		expire,
+		expireRoute: (routeOptions) => cronRoute({
+			name: "expire",
+			secret: routeOptions.secret,
+			problem: routeOptions.problem
+		}, async (_request, instance) => {
+			const result = await expire();
+			return result.ok ? Response.json({ expired: result.data.length }) : problemResponse(result.error, {
+				instance,
+				format: routeOptions.problem
+			});
+		}),
+		start(admin, request) {
+			return AsyncResult.from(async () => {
+				if (admin.kind !== "user") return err(dbError("unauthorized", "Sign in to start a support session"));
+				const reason = request.reason?.trim() ?? "";
+				const seconds = request.ttl ?? ttl;
+				const readOnly = policy.readOnly === "default" ? request.readOnly ?? true : true;
+				const deny = (error, denial) => {
+					emit("support.denied", {
+						adminId: admin.user.id,
+						targetUserId: request.targetUserId,
+						...reason ? { reason } : {},
+						denial
+					});
+					return err(error);
+				};
+				const violation = checkPolicy(admin, request, reason, seconds);
+				if (violation) return deny(violation, "policy");
+				const tenant = request.tenant === void 0 ? {} : { tenant: request.tenant };
+				const input = {
+					admin,
+					targetUserId: request.targetUserId,
+					reason,
+					readOnly,
+					...tenant,
+					metadata: request.metadata ?? {}
+				};
+				const decision = await decide(input);
+				if (decision === false) return deny(forbidden(), "authorize");
+				const approvedBy = typeof decision === "object" ? decision.approvedBy : void 0;
+				if (approvedBy === admin.user.id) return deny(selfApproval(), "authorize");
+				let requestId;
+				if (approval === "distinct") {
+					let approved;
+					try {
+						approved = await approvedRequest(admin, request, reason, readOnly, approvedBy);
+					} catch (cause) {
+						const error = storeError(cause);
+						return deny(error, error.code === "42501" ? "permission" : "store");
+					}
+					if (approved === void 0 || approved.approvedBy === admin.user.id) return deny(denied("A second admin must approve this support session", "SUPPORT_APPROVAL_REQUIRED"), "policy");
+					requestId = approved.id;
+				}
+				let session;
+				try {
+					session = await store.start({
+						adminId: admin.user.id,
+						adminClaims: admin.claims,
+						targetUserId: request.targetUserId,
+						reason,
+						ttlSeconds: seconds,
+						readOnly,
+						...tenant,
+						metadata: request.metadata ?? {},
+						...requestId === void 0 ? {} : { requestId }
+					});
+				} catch (cause) {
+					const error = storeError(cause);
+					return deny(error, error.code === "42501" ? "permission" : "store");
+				}
+				emit("support.started", {
+					sessionId: session.id,
+					adminId: session.adminId,
+					targetUserId: session.targetUserId,
+					reason: session.reason,
+					readOnly: session.readOnly,
+					expiresAt: session.expiresAt
+				});
+				return ok({
+					session,
+					cookie: supportCookie(session, options.cookie)
+				});
+			});
+		},
+		request(admin, request) {
+			return AsyncResult.from(async () => {
+				if (admin.kind !== "user") return err(dbError("unauthorized", "Sign in to ask for a support session"));
+				const reason = request.reason?.trim() ?? "";
+				const violation = checkPolicy(admin, request, reason, request.ttl ?? ttl);
+				if (violation) return err(violation);
+				if (!store.request) return err(noApprovals());
+				try {
+					return ok(await store.request({
+						adminId: admin.user.id,
+						adminClaims: admin.claims,
+						targetUserId: request.targetUserId,
+						reason,
+						readOnly: policy.readOnly === "default" ? request.readOnly ?? true : true,
+						...request.tenant === void 0 ? {} : { tenant: request.tenant },
+						metadata: request.metadata ?? {}
+					}));
+				} catch (cause) {
+					return err(storeError(cause));
+				}
+			});
+		},
+		approve(approver, requestId) {
+			return AsyncResult.from(async () => {
+				if (approver.kind !== "user") return err(dbError("unauthorized", "Sign in to approve a support session"));
+				if (approver.claims["act"] !== void 0) return err(denied("An impersonated session cannot approve a support session", "SUPPORT_NESTED"));
+				if (!store.approve || !store.getRequest) return err(noApprovals());
+				try {
+					const found = await store.getRequest(requestId);
+					if (!found) return err(dbError("not_found", "No such support request", { code: "SUPPORT_REQUEST_MISSING" }));
+					if (found.adminId === approver.user.id) return err(selfApproval());
+					if (authorization?.approverOf === void 0) return ok(await store.approve(requestId, {
+						id: approver.user.id,
+						claims: approver.claims
+					}));
+					if (!await mayApprove(approver, found)) return err(denied("Not allowed to approve this support session", "SUPPORT_FORBIDDEN"));
+					return ok(await store.approve(requestId, { id: approver.user.id }));
+				} catch (cause) {
+					return err(storeError(cause));
+				}
+			});
+		},
+		stop(admin, sessionId) {
+			return AsyncResult.from(async () => {
+				const cookie = clearSupportCookie(options.cookie);
+				if (admin.kind !== "user") return err(dbError("unauthorized", "Sign in to stop a support session"));
+				try {
+					const session = await store.get(sessionId, admin.user.id, admin.claims);
+					if (!session) return ok({
+						ended: false,
+						cookie
+					});
+					const ended = await store.end(sessionId, "admin", admin.claims);
+					if (ended) emit("support.ended", {
+						sessionId,
+						adminId: session.adminId,
+						targetUserId: session.targetUserId,
+						endedBy: "admin"
+					});
+					return ok({
+						ended,
+						cookie
+					});
+				} catch (cause) {
+					return err(storeError(cause));
+				}
+			});
+		},
+		revoke(caller, sessionId) {
+			return AsyncResult.from(async () => {
+				if (caller.kind !== "user") return err(dbError("unauthorized", "Sign in to revoke a support session"));
+				try {
+					return ok(await store.end(sessionId, "revoked", caller.claims));
+				} catch (cause) {
+					return err(storeError(cause));
+				}
+			});
+		},
+		async current(request, auth) {
+			const id = sessionIdOf(request);
+			return id ? resolve(id, auth) : void 0;
+		},
+		resolve,
+		list(caller, filter) {
+			return AsyncResult.from(async () => {
+				if (caller.kind !== "user") return err(dbError("unauthorized", "Sign in to list support sessions"));
+				try {
+					return ok(await store.list(filter, caller.claims));
+				} catch (cause) {
+					return err(storeError(cause));
+				}
+			});
+		},
+		sessionIdOf,
+		clearCookie: () => clearSupportCookie(options.cookie)
+	};
+}
+//#endregion
+export { sqlSupportStore as n, supportClaims as r, supportSessions as t };

package/dist/support-view-BbcZR7Io.d.ts

@@ -0,0 +1,17 @@
+import { t as AuthSession } from "./view-Dv0A949a.js";
+//#region src/auth/support-view.d.ts
+/** A running support session as the target's view shows it, for a banner. */
+interface SupportView {
+  readonly sessionId: string;
+  /** The admin viewing the app. */
+  readonly adminId: string;
+  readonly targetUserId: string;
+  readonly reason?: string;
+  readonly readOnly: boolean;
+  /** Seconds since epoch. */
+  readonly expiresAt: number | null;
+}
+/** The support session behind `session`, or `undefined` outside one. */
+declare function supportOf(session: AuthSession): SupportView | undefined;
+//#endregion
+export { supportOf as n, SupportView as t };

package/dist/svelte/index.d.ts

@@ -1,10 +1,10 @@
-import { b as DbError } from "../result-BchM1XZn.js";
-import { J as TemplateValues } from "../storage-api-CB7Zl1Ci.js";
-import { at as QuerySpec } from "../define-DmcfoNXB.js";
-import { t as AuthSnapshot } from "../bind-CQ5mPyX1.js";
-import { t as AuthSession } from "../view-TpXEUcVN.js";
-import { S as Topic, f as PresenceMember, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus } from "../index-BCHR4Ucl.js";
-import { a as BroadcastOptions, c as LiveCountHookOptions, d as PresenceHookOptions, f as PresenceTopic, i as ActionState, l as LiveCountSource, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, t as fieldErrorsOf, u as LiveQueryHookOptions } from "../field-errors-DIe9XYWL.js";
+import { b as DbError } from "../result-Cj3yWhjH.js";
+import { J as TemplateValues } from "../storage-api-Cx-1iWBd.js";
+import { at as QuerySpec } from "../define-DxHHbNEb.js";
+import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-cMS7UtM1.js";
+import { t as AuthSnapshot } from "../bind-a7sUgvf4.js";
+import { t as AuthSession } from "../view-Dv0A949a.js";
+import { a as BroadcastOptions, c as LiveCountHookOptions, d as PresenceHookOptions, f as PresenceTopic, i as ActionState, l as LiveCountSource, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, t as fieldErrorsOf, u as LiveQueryHookOptions } from "../field-errors-CWXN_h_E.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { QueryClient } from "@tanstack/query-core";
 //#region src/svelte/index.d.ts

package/dist/svelte/index.js

@@ -1,6 +1,7 @@
 import { t as clearOnUserChange } from "../user-change-XzvgafU4.js";
-import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-wxeTQFtB.js";
+import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-CvITjt-9.js";
 import { t as fieldErrorsOf } from "../field-errors-DZVRWRkf.js";
+import { t as CLIENT } from "../context-C-bHOtoD.js";
 import { getContext, onMount, setContext } from "svelte";
 import { createSubscriber } from "svelte/reactivity";
 //#region src/svelte/index.ts
@@ -271,7 +272,6 @@ function createBetterSvelte(client, options = {}) {
 		}
 	};
 }
-const CLIENT = Symbol("better-supabase");
 const SESSION = Symbol("better-supabase-session");
 /**
 * Binds the client for the components below, in the root layout. With a

package/dist/svelte-controller-CDAujo-_.js

@@ -0,0 +1,50 @@
+import { t as CLIENT } from "./context-C-bHOtoD.js";
+import { n as withEnv, t as blockEnv } from "./block-env-CBd_SoL5.js";
+import { getContext, onDestroy, onMount } from "svelte";
+import { readable } from "svelte/store";
+//#region src/blocks/svelte-controller.ts
+function contextClient() {
+	const bound = getContext(CLIENT);
+	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bs) in a parent component");
+	return bound.client;
+}
+/**
+* Makes a controller once, during component setup. The store follows it
+* from mount (never during server rendering) while it has subscribers, and
+* the controller is disposed with the component.
+*/
+function useBlockController(create, options, usesEnv = true) {
+	const controller = create(withEnv(options, usesEnv ? () => blockEnv(contextClient()) : void 0));
+	let mounted = false;
+	let pending;
+	const store = readable(controller.getSnapshot(), (set) => {
+		let stop;
+		const start = () => {
+			stop = controller.subscribe(() => {
+				set(controller.getSnapshot());
+			});
+			set(controller.getSnapshot());
+		};
+		if (mounted) start();
+		else pending = start;
+		return () => {
+			pending = void 0;
+			stop?.();
+		};
+	});
+	onMount(() => {
+		mounted = true;
+		pending?.();
+		pending = void 0;
+	});
+	onDestroy(() => {
+		controller.dispose();
+	});
+	return {
+		subscribe: store.subscribe,
+		actions: controller.actions,
+		controller
+	};
+}
+//#endregion
+export { useBlockController as t };

package/dist/svelte-controller-DxxHEHxD.d.ts

@@ -0,0 +1,10 @@
+import { n as Controller } from "./controller-D845qKh2.js";
+import { Readable } from "svelte/store";
+//#region src/blocks/svelte-controller.d.ts
+/** A block controller in a Svelte component: a readable store of its state, with its actions. */
+interface SvelteController<S, A> extends Readable<S> {
+  readonly actions: A;
+  readonly controller: Controller<S, A>;
+}
+//#endregion
+export { SvelteController as t };

package/dist/sveltekit/index.d.ts

@@ -1,11 +1,11 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-CoE5Zwy4.js";
-import { t as BetterSupabase } from "../define-DmcfoNXB.js";
-import { t as BetterServer } from "../server-types-CrAmZ8jv.js";
-import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-W99LCPBS.js";
-import { t as RefusalRedirects } from "../refusal-CFI8-5nf.js";
-import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-148t1m3C.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-YfwpIE-d.js";
+import { t as BetterSupabase } from "../define-DxHHbNEb.js";
+import { t as BetterServer } from "../server-types-OohhIQb2.js";
+import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-D5S7KNFe.js";
+import { t as RefusalRedirects } from "../refusal-oD3ISM9h.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-DG5Bv39u.js";
 import { t as Validated } from "../shared-DDSjEGDR.js";
-import { i as tagFor } from "../tags-BO9LjtWG.js";
+import { i as tagFor } from "../tags-Dw8vKkcI.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/bridges/sveltekit.d.ts
@@ -18,9 +18,9 @@ interface SvelteKitEvent<Locals extends object> {
   } | undefined;
 }
 /** SvelteKit's `Handle`, typed structurally so the package does not import `@sveltejs/kit`. */
-type SvelteKitHandle<Locals extends object> = (input: {
-  readonly event: SvelteKitEvent<Locals>;
-  readonly resolve: (event: SvelteKitEvent<Locals>) => Response | Promise<Response>;
+type SvelteKitHandle<Locals extends object> = <Event extends SvelteKitEvent<Locals>>(input: {
+  readonly event: Event;
+  readonly resolve: (event: Event) => Response | Promise<Response>;
 }) => Promise<Response>;
 /**
  * Runs an entry array as a SvelteKit `handle` hook. Every contributed key
@@ -48,9 +48,7 @@ interface SvelteKitFailure<T> {
  * a `fail()` with the status.
  */
 interface SvelteKitHelpers {
-  error(status: number, body: {
-    readonly message: string;
-  }): never;
+  error(status: number, message: string): never;
   redirect(status: 303, location: string): never;
   fail(status: number, data: Record<string, unknown>): SvelteKitFailure<unknown>;
 }