better-supabase 0.13.0 → 0.14.0

package/dist/support-Ds1-UCN4.js

@@ -0,0 +1,534 @@
+import { c as mapDbError, n as dbError } from "./errors-03ysrOt4.js";
+import { t as temporal } from "./temporal-required-B8qQHYbI.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-B3m7xtRY.js";
+import { n as validate } from "./standard-DtkpFGkS.js";
+import { o as problemResponse } from "./problem-BWElIgIb.js";
+import { i as sqlIdent } from "./template-BWP7IXZg.js";
+import { t as fromPgError } from "./pg-error-B5QLDcbG.js";
+import { d as clearSupportCookie, f as supportCookie, m as supportCookieValue } from "./adapter-BCFAg58A.js";
+import { a as emitBlockEvent } from "./block-events-pBXPzwnW.js";
+import { t as cronRoute } from "./cron-route-Y0eJ-FNi.js";
+import { t as boundedTtlCache } from "./ttl-cache-Bhr9swjT.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-vwJbRMpV.d.ts

@@ -0,0 +1,17 @@
+import { t as AuthSession } from "./view-2_I-2ukO.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,12 +1,30 @@
-import { b as DbError } from "../result-mijqfoJN.js";
-import { J as QuerySpec } from "../define-D0LSXmUP.js";
-import { $ as TemplateValues } from "../bucket-DBay-ICp.js";
-import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-CZvLXFND.js";
-import { t as AuthSnapshot } from "../bind-DcXLU1ul.js";
-import { t as AuthSession } from "../view-CKzCp8FW.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-CKEqR38q.js";
+import { b as DbError } from "../result-C6jDfedy.js";
+import { Ct as Events, D as BlockEventPattern, T as BlockEvent, bt as EventMap, k as BlockEventsMatching } from "../events-DbLjvxDX.js";
+import { J as QuerySpec } from "../define-Dw7pRO4h.js";
+import { $ as TemplateValues } from "../bucket-TkB7_xv8.js";
+import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-D9j8G2dw.js";
+import { t as AuthSnapshot } from "../bind-Dz8y3T5T.js";
+import { t as AuthSession } from "../view-2_I-2ukO.js";
+import { _ as LiveQueryHookOptions, a as BlockQueryActions, b as ProfileOf, c as BlockRefetchOn, d as ActionState, f as BroadcastOptions, g as LiveCountSource, h as LiveCountHookOptions, i as BlockMutationState, l as ActionInputOf, m as ClientLike, n as BlockEventSource, o as BlockQueryOptions, p as ClaimsOf, r as BlockMutationActions, s as BlockQueryState, t as fieldErrorsOf, u as ActionResultOf, v as PresenceHookOptions, x as UseActionOptions, y as PresenceTopic } from "../field-errors-vshYTVKr.js";
+import { t as SvelteController } from "../svelte-bind-Ja6CtQGp.js";
+import { i as BlockMethodName, n as BlockDataOf, t as BlockArgsOf } from "../block-method-hsPAGFi5.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { QueryClient } from "@tanstack/query-core";
+//#region src/svelte/block-hooks.d.ts
+/**
+ * Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
+ * from mount. `refetchOn` calls it again on block events.
+ */
+export declare function useBlockQuery<C extends object, const K extends BlockMethodName<C>>(client: C, method: K, args: BlockArgsOf<C, K>, options?: BlockQueryOptions): SvelteController<BlockQueryState<BlockDataOf<C, K>>, BlockQueryActions>;
+/** Calls a write method of any block client and tracks its state. */
+export declare function useBlockMutation<C extends object, const K extends BlockMethodName<C>>(client: C, method: K): SvelteController<BlockMutationState<BlockDataOf<C, K>>, BlockMutationActions<BlockArgsOf<C, K>, BlockDataOf<C, K>>>;
+/**
+ * Calls `handler` for each block event matching `pattern` (`"task.*"`), typed
+ * by `events` (`blockEvents` from `blocks.generated.ts`), from mount until the
+ * component goes away. `source` is the client's `betterSupabase`.
+ */
+export declare function useBlockEvent<M extends EventMap, const P extends BlockEventPattern<M>>(source: BlockEventSource, events: Events<M>, pattern: P, handler: (event: BlockEvent<M, BlockEventsMatching<M, P>>) => void): void;
+//#endregion
 //#region src/svelte/index.d.ts
 /**
  * A value read through `.current`, reactive in templates, `$derived` and
@@ -120,4 +138,4 @@ export declare function setSession(session: () => AuthSession): void;
  */
 export declare function useSession<C = unknown, P = unknown>(): Current<AuthSession<C, P>>;
 //#endregion
-export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type UseActionOptions, fieldErrorsOf };
+export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BlockEventSource, type BlockMutationActions, type BlockMutationState, type BlockQueryActions, type BlockQueryOptions, type BlockQueryState, type BlockRefetchOn, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type UseActionOptions, fieldErrorsOf };

package/dist/svelte/index.js

@@ -1,9 +1,30 @@
 import { t as clearOnUserChange } from "../user-change-CSR_prhd.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-YASsOslj.js";
-import { t as fieldErrorsOf } from "../field-errors-DZVRWRkf.js";
-import { t as CLIENT } from "../context-C-bHOtoD.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-C_0XZieg.js";
+import { a as fieldErrorsOf, i as listenToBlockEvents, n as createBlockMutation, r as createBlockQuery } from "../block-controller-DTGuBemi.js";
+import { n as CLIENT, t as bindSvelteController } from "../svelte-bind-BHN5a8VV.js";
 import { getContext, onMount, setContext } from "svelte";
 import { createSubscriber } from "svelte/reactivity";
+//#region src/svelte/block-hooks.ts
+/**
+* Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
+* from mount. `refetchOn` calls it again on block events.
+*/
+function useBlockQuery(client, method, args, options = {}) {
+	return bindSvelteController(createBlockQuery(client, method, args, options));
+}
+/** Calls a write method of any block client and tracks its state. */
+function useBlockMutation(client, method) {
+	return bindSvelteController(createBlockMutation(client, method));
+}
+/**
+* Calls `handler` for each block event matching `pattern` (`"task.*"`), typed
+* by `events` (`blockEvents` from `blocks.generated.ts`), from mount until the
+* component goes away. `source` is the client's `betterSupabase`.
+*/
+function useBlockEvent(source, events, pattern, handler) {
+	onMount(() => listenToBlockEvents(source, events, pattern, () => handler));
+}
+//#endregion
 //#region src/svelte/index.ts
 /** Reads a store reactively: the caller re-runs when the store changes. */
 function reactive(store) {
@@ -353,4 +374,4 @@ function useSession() {
 	} };
 }
 //#endregion
-export { createBetterSvelte, fieldErrorsOf, getBetterSupabase, setBetterSupabase, setSession, useAction, useAuth, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession };
+export { createBetterSvelte, fieldErrorsOf, getBetterSupabase, setBetterSupabase, setSession, useAction, useAuth, useBlockEvent, useBlockMutation, useBlockQuery, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession };

package/dist/svelte-bind-BHN5a8VV.js

@@ -0,0 +1,46 @@
+import { onDestroy, onMount } from "svelte";
+import { readable } from "svelte/store";
+//#region src/svelte/context.ts
+/** The context key `setBetterSupabase` binds the client under. */
+const CLIENT = Symbol("better-supabase");
+//#endregion
+//#region src/blocks/svelte-bind.ts
+/**
+* Wraps a controller made 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 bindSvelteController(controller) {
+	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 { CLIENT as n, bindSvelteController as t };