better-supabase 0.5.1 → 0.6.1

package/dist/stripe-D04h-QBT.d.ts

@@ -0,0 +1,136 @@
+//#region src/blocks/stripe.d.ts
+/**
+ * The part of the Stripe SDK (`stripe`, an optional peer) the billing and
+ * usage blocks call, typed structurally so the blocks never import it.
+ */
+interface StripeClient {
+  readonly customers: {
+    create(params: {
+      readonly email?: string;
+      readonly name?: string;
+      readonly metadata?: Readonly<Record<string, string>>;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.updateCustomer`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.taxIds`. */
+    listTaxIds?(id: string, params?: {
+      readonly limit?: number;
+    }): Promise<{
+      readonly data: readonly StripeTaxId[];
+    }>;
+    /** Used by `billing.addTaxId`. */
+    createTaxId?(id: string, params: {
+      readonly type: string;
+      readonly value: string;
+    }): Promise<StripeTaxId>;
+    /** Used by `billing.removeTaxId`. */
+    deleteTaxId?(id: string, taxId: string): Promise<{
+      readonly id: string;
+      readonly deleted?: boolean;
+    }>;
+  };
+  readonly checkout: {
+    readonly sessions: {
+      create(params: Readonly<Record<string, unknown>>, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string | null;
+      }>;
+    };
+  };
+  readonly billingPortal: {
+    readonly sessions: {
+      create(params: {
+        readonly customer: string;
+        readonly return_url?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string;
+      }>;
+    };
+  };
+  readonly subscriptionItems: {
+    update(id: string, params: {
+      readonly quantity: number;
+      readonly proration_behavior?: string;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+      readonly quantity?: number | null;
+    }>;
+  };
+  readonly subscriptions: {
+    cancel(id: string): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.changePlan` and `billing.cancelAtPeriodEnd`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+  };
+  /** Used by `billing.voidInvoice` and `billing.markInvoiceUncollectible`. */
+  readonly invoices?: {
+    voidInvoice(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+    markUncollectible(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+  };
+  readonly billing: {
+    readonly meterEvents: {
+      create(params: {
+        readonly event_name: string;
+        readonly payload: Readonly<Record<string, string>>;
+        readonly identifier?: string;
+        readonly timestamp?: number;
+      }, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<unknown>;
+    };
+  };
+  readonly webhooks: {
+    constructEventAsync(payload: string, header: string, secret: string): Promise<{
+      readonly id: string;
+      readonly type: string;
+      readonly data: {
+        readonly object: unknown;
+      };
+    }>;
+  };
+}
+/** A customer tax id as Stripe returns it (`eu_vat`, `DE123456789`). */
+interface StripeTaxId {
+  readonly id: string;
+  readonly type: string;
+  readonly value: string;
+  readonly country?: string | null;
+  readonly verification?: {
+    readonly status?: string | null;
+  } | null;
+  readonly created?: number | null;
+}
+/**
+ * A Stripe client, the secret key to create one from the `stripe` package,
+ * or a function that returns a client. The function runs on every Stripe
+ * call, so it can create the client lazily, pick a per-request or per-tenant
+ * client (Stripe Connect), or read a rotated key; cache inside it when needed.
+ */
+type StripeSource = StripeClient | {
+  readonly secretKey: string;
+  readonly apiVersion?: string;
+} | (() => StripeClient | Promise<StripeClient>);
+//#endregion
+export { StripeSource as n, StripeTaxId as r, StripeClient as t };

package/dist/{support-view-B8SlToQX.d.ts → support-view-33Oi07TT.d.ts}

@@ -1,4 +1,4 @@
-import { t as AuthSession } from "./view-CbgObAeb.js";
+import { t as AuthSession } from "./view-DbxLNu8L.js";
 //#region src/auth/support-view.d.ts
 /** A running support session as the target's view shows it, for a banner. */
 interface SupportView {

package/dist/{support-wHnK6zp-.js → support-zIa1URaN.js}

@@ -1,11 +1,11 @@
-import { c as mapDbError, n as dbError } from "./errors-DtwXa6b8.js";
-import { t as temporal } from "./temporal-required-CAt4Dc9Z.js";
-import { i as ok, n as err, o as toDbError, t as AsyncResult } from "./result-BKiliPY7.js";
-import { t as validate } from "./standard-D7r6dMUu.js";
-import { c as supportCookie, l as supportCookieValue, s as clearSupportCookie } from "./server-B1mZ7CgQ.js";
-import { r as sqlIdent } from "./template-TxrGI5jR.js";
-import { n as emitKitEvent } from "./kit-events-CTFDfSwb.js";
-import { t as fromPgError } from "./executor-XycESQPH.js";
+import { c as mapDbError, n as dbError } from "./errors-B11Duf73.js";
+import { t as temporal } from "./temporal-required-BVvW7SYJ.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { n as validate } from "./standard-BK0cqJ7y.js";
+import { t as fromPgError } from "./executor-De1Of3m3.js";
+import { d as clearSupportCookie, f as supportCookie, m as supportCookieValue } from "./adapter-CHnPkCPd.js";
+import { r as sqlIdent } from "./template--jDkl3UP.js";
+import { i as emitBlockEvent } from "./block-events-CrT8r7Fe.js";
 //#region src/auth/support.ts
 /** A session from the jsonb the `support-sessions` functions return. */
 function supportSessionFromRow(row) {
@@ -25,7 +25,7 @@ function supportSessionFromRow(row) {
 	};
 }
 /**
-* Support sessions in the `support-sessions` SQL kit module. `start` runs
+* 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.
 */
@@ -97,6 +97,9 @@ function supportClaims(session, target) {
 }
 //#endregion
 //#region src/server/support.ts
+/** 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) {
@@ -119,7 +122,7 @@ function createSupport(options, events, claimsSchema) {
 	const maxTtl = policy.maxTtl ?? 14400;
 	const cookieName = options.cookie?.name;
 	const emit = (type, data) => {
-		emitKitEvent(events, type, data, {
+		emitBlockEvent(events, type, data, {
 			actorId: data.adminId,
 			...data.sessionId ? { subject: `support_sessions/${data.sessionId}` } : {}
 		});
@@ -129,6 +132,24 @@ function createSupport(options, events, claimsSchema) {
 		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 = /* @__PURE__ */ new Map();
+	const cachedTargetClaims = async (session) => {
+		const now = Date.now();
+		const cached = claimsCache.get(session.id);
+		if (cached && cached.until > now) return cached.claims;
+		const claims = await targetClaims(options.store, session.targetUserId);
+		claimsCache.delete(session.id);
+		if (claimsCache.size >= CLAIMS_CACHE_SIZE) {
+			const oldest = claimsCache.keys().next();
+			if (!oldest.done) claimsCache.delete(oldest.value);
+		}
+		claimsCache.set(session.id, {
+			claims,
+			until: Math.min(session.expiresAt.epochMilliseconds, 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");
@@ -250,7 +271,7 @@ function createSupport(options, events, claimsSchema) {
 					...session,
 					readOnly: true
 				};
-				claims = supportClaims(session, await targetClaims(options.store, session.targetUserId));
+				claims = supportClaims(session, await cachedTargetClaims(session));
 			} catch (cause) {
 				events.logger.warn("Could not load the support session", { cause });
 				return;

package/dist/svelte/index.d.ts

@@ -0,0 +1,114 @@
+import { b as DbError } from "../result-D7y2fT87.js";
+import { it as QuerySpec } from "../define-CJJkkr1-.js";
+import { n as TemplateValues } from "../template-CwO38Do8.js";
+import { t as AuthSnapshot } from "../bind-Bu_ZNa3W.js";
+import { t as AuthSession } from "../view-DbxLNu8L.js";
+import { S as Topic, f as PresenceMember, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus } from "../index-DunNRdnT.js";
+import { a as BroadcastOptions, c as LiveCountSource, d as PresenceTopic, f as UseActionOptions, i as ActionState, l as LiveQueryHookOptions, n as ActionInputOf, o as ClientLike, r as ActionResultOf, s as LiveCountHookOptions, t as fieldErrorsOf, u as PresenceHookOptions } from "../field-errors-BFOa7WhB.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/svelte/index.d.ts
+/** A value read through `.current`, reactive in templates, `$derived` and `$effect`. */
+export interface Current<T> {
+  readonly current: T;
+}
+export interface LiveCount {
+  /** `undefined` until the first count arrives. */
+  readonly count: number | undefined;
+  readonly status: SubscriptionStatus;
+  /** The last failed refetch; the previous count stays. */
+  readonly error: DbError | undefined;
+}
+export interface Presence<I, O> {
+  /** Everyone on the topic, this client included, from the last sync. */
+  readonly members: readonly PresenceMember<O>[];
+  readonly status: SubscriptionStatus;
+  /** Shares a state now; the `state` option tracks one for you. */
+  readonly track: (state: I) => Promise<DbError | undefined>;
+  readonly untrack: () => Promise<DbError | undefined>;
+}
+export interface SveltePresenceOptions<I> extends Omit<PresenceHookOptions<I>, "state"> {
+  readonly state?: () => I | null | undefined;
+}
+export interface ActionHandle<I, T> extends ActionState<I, T> {
+  /** Runs the action; resolves with its result. */
+  readonly run: (input: I) => Promise<ActionResultOf<T>>;
+  readonly reset: () => void;
+}
+/** The claims type of a client's `betterSupabase.claims(schema)`, `unknown` without one. */
+export type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
+} ? C : unknown;
+/** The profile type of a client's `betterSupabase.userMetadata(schema)`, `unknown` without one. */
+export type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
+} ? P : unknown;
+/**
+ * The client bound to Svelte. Inputs are getters (`() => spec`), so the
+ * subscriptions follow `$state` and `$props`. A subscription starts when a
+ * template, `$derived` or `$effect` reads one of its fields and stops when
+ * nothing reads it any more.
+ */
+export interface BetterSvelte<B extends ClientLike = ClientLike> {
+  readonly client: B;
+  readonly queryClient: QueryClient | undefined;
+  /** Repositories bound to the current session. */
+  readonly db: B["db"];
+  /** TanStack Query option factories: `createQuery(() => bs.queries.customers.findMany())`. */
+  readonly queries: B["queries"];
+  readonly supabase: SupabaseClient;
+  /** The session state for UI: `loading`, `signed-out` or `signed-in`. */
+  readonly auth: Current<AuthSnapshot>;
+  broadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: () => TemplateValues<P> | null | undefined, handlers?: TopicHandlers<E>, options?: BroadcastOptions): Current<SubscriptionStatus>;
+  liveQuery(spec: () => QuerySpec | null | undefined, options?: LiveQueryHookOptions): Current<SubscriptionStatus>;
+  liveCount(source: () => LiveCountSource, options?: LiveCountHookOptions): LiveCount;
+  presence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: () => TemplateValues<P> | null | undefined, options?: SveltePresenceOptions<I>): Presence<I, O>;
+  action<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
+}
+export interface BetterSvelteOptions {
+  /** better-supabase queries are reset when the user signs out or changes. */
+  readonly queryClient?: QueryClient;
+}
+/** Binds a client to Svelte without a component context, e.g. in tests or a module. */
+export declare function createBetterSvelte<B extends ClientLike>(client: B, options?: BetterSvelteOptions): BetterSvelte<B>;
+/**
+ * Binds the client for the components below, in the root layout. With a
+ * `queryClient`, better-supabase queries are reset when the caller changes.
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   setBetterSupabase(bs, { queryClient });
+ * <\/script>
+ * ```
+ */
+export declare function setBetterSupabase<B extends ClientLike>(client: B, options?: BetterSvelteOptions): BetterSvelte<B>;
+/** The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof bs>()`. */
+export declare function getBetterSupabase<B extends ClientLike = ClientLike>(): BetterSvelte<B>;
+/** The session state for UI. Call during component setup. */
+export declare function useAuth(): Current<AuthSnapshot>;
+/** Subscribes to a topic while read. Call during component setup. */
+export declare function useBroadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: () => TemplateValues<P> | null | undefined, handlers?: TopicHandlers<E>, options?: BroadcastOptions): Current<SubscriptionStatus>;
+/**
+ * Keeps a query fresh while read. Call during component setup.
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   const live = useLiveQuery(() => betterSupabase.spec.customers.findMany());
+ * <\/script>
+ * <span data-status={live.current}></span>
+ * ```
+ */
+export declare function useLiveQuery(spec: () => QuerySpec | null | undefined, options?: LiveQueryHookOptions): Current<SubscriptionStatus>;
+/** A count that stays current while read. Call during component setup. */
+export declare function useLiveCount(source: () => LiveCountSource, options?: LiveCountHookOptions): LiveCount;
+/** Joins a presence topic while read. Call during component setup. */
+export declare function usePresence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: () => TemplateValues<P> | null | undefined, options?: SveltePresenceOptions<I>): Presence<I, O>;
+/** Tracks the runs of a server action or form action. */
+export declare function useAction<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
+/** Shares a server-verified session (from `+layout.ts` data) with the components below. */
+export declare function setSession(session: () => AuthSession): void;
+/** The session from the nearest `setSession()`, typed with `useSession<Claims, Profile>()`. */
+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 ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type UseActionOptions, fieldErrorsOf };

package/dist/svelte/index.js

@@ -0,0 +1,344 @@
+import { t as clearOnUserChange } from "../user-change-XzvgafU4.js";
+import { t as fieldErrorsOf } from "../field-errors-VF1yb8yI.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-CI0Z2zWX.js";
+import { getContext, onMount, setContext } from "svelte";
+import { createSubscriber } from "svelte/reactivity";
+//#region src/svelte/index.ts
+/** Reads a store reactively: the caller re-runs when the store changes. */
+function reactive(store) {
+	const subscribe = createSubscriber((update) => store.subscribe(update));
+	return { get current() {
+		subscribe();
+		return store.current();
+	} };
+}
+/**
+* A subscription keyed by `key()`. The returned function goes in each
+* getter: it registers the reader, then restarts the subscription when the
+* key (read in the reader's tracking context) changed. Notifications are
+* queued, since a getter may run inside `$derived`, where writes throw.
+*/
+function followed(key, start) {
+	const run = keyed();
+	let notify;
+	const queued = () => {
+		queueMicrotask(() => notify?.());
+	};
+	const update = () => {
+		const next = key();
+		run.update(next, () => next === null ? void 0 : start(next, queued));
+	};
+	const subscribe = createSubscriber((changed) => {
+		notify = changed;
+		update();
+		return () => {
+			notify = void 0;
+			run.stop();
+		};
+	});
+	return () => {
+		subscribe();
+		if (notify) update();
+	};
+}
+const NO_MEMBERS = [];
+/** Binds a client to Svelte without a component context, e.g. in tests or a module. */
+function createBetterSvelte(client, options = {}) {
+	const { queryClient } = options;
+	const auth = reactive(client.auth);
+	const plainCallers = /* @__PURE__ */ new WeakMap();
+	const callerFor = (supabase) => {
+		if (supabase === void 0) return { get current() {
+			return callerOf(auth.current);
+		} };
+		let caller = plainCallers.get(supabase);
+		if (!caller) {
+			caller = reactive(plainCaller(supabase));
+			plainCallers.set(supabase, caller);
+		}
+		return caller;
+	};
+	return {
+		client,
+		queryClient,
+		db: client.db,
+		queries: client.queries,
+		supabase: client.supabase,
+		auth,
+		broadcast(topic, values, handlers, options) {
+			const supabase = options?.client ?? client.supabase;
+			const forQuery = options?.queryClient ?? queryClient;
+			assertInvalidateClient("broadcast", options, forQuery);
+			const caller = callerFor(options?.client);
+			let status = "closed";
+			const name = () => {
+				const current = values();
+				return current ? topic.topic(current) : null;
+			};
+			const track = followed(() => {
+				const current = name();
+				const who = caller.current;
+				if (current === null || who.status === "loading") return null;
+				return JSON.stringify([current, who.userId]);
+			}, (_key, notify) => {
+				const current = name();
+				if (current === null) return;
+				return startBroadcast({
+					supabase,
+					topic,
+					name: current,
+					latest: () => ({
+						handlers,
+						options
+					}),
+					queryClient: forQuery,
+					onStatus: (next) => {
+						status = next;
+						notify();
+					}
+				});
+			});
+			return { get current() {
+				track();
+				return status;
+			} };
+		},
+		liveQuery(spec, options = {}) {
+			let status = "closed";
+			let joined = null;
+			const track = followed(() => {
+				const current = spec();
+				if (current && !queryClient) throw new Error("better-supabase: liveQuery needs setBetterSupabase(bs, { queryClient })");
+				return liveKey(client, current, auth.current, options);
+			}, (key, notify) => {
+				const current = spec();
+				if (!current || !queryClient) return;
+				const resumed = joined === key;
+				joined = key;
+				return startLiveQuery({
+					client,
+					queryClient,
+					spec: current,
+					auth: client.auth.current(),
+					options,
+					resumed,
+					onStatus: (next) => {
+						status = next;
+						notify();
+					}
+				});
+			});
+			return { get current() {
+				track();
+				return status;
+			} };
+		},
+		liveCount(source, options = {}) {
+			let status = "closed";
+			let state = NO_COUNT;
+			let joined = null;
+			const parsed = () => countSource(source(), options);
+			const key = () => liveKey(client, parsed().spec, auth.current, options);
+			const track = followed(key, (next, notify) => {
+				const { spec, initial, seedAt } = parsed();
+				if (!spec) return;
+				const previous = joined?.key === next ? joined : null;
+				joined = {
+					key: next,
+					at: previous?.at ?? seedAt ?? 0
+				};
+				return startLiveCount({
+					client,
+					spec,
+					key: next,
+					auth: client.auth.current(),
+					options,
+					immediate: initial === void 0 && !previous,
+					since: previous ? previous.at : seedAt,
+					onState: (update) => {
+						state = update(state);
+						if (joined?.key === next) joined = {
+							key: next,
+							at: state.at
+						};
+						notify();
+					},
+					onStatus: (value) => {
+						status = value;
+						notify();
+					}
+				});
+			});
+			const shown = () => {
+				track();
+				return shownCount(state, key(), parsed());
+			};
+			return {
+				get count() {
+					return shown().count;
+				},
+				get status() {
+					track();
+					return status;
+				},
+				get error() {
+					return shown().error;
+				}
+			};
+		},
+		presence(topic, values, options = {}) {
+			const supabase = options.client ?? client.supabase;
+			const caller = callerFor(options.client);
+			let members = NO_MEMBERS;
+			let status = "closed";
+			let join;
+			const name = () => {
+				const current = values();
+				return current ? topic.topic(current) : null;
+			};
+			const follow = followed(() => {
+				const current = name();
+				const who = caller.current;
+				if (current === null || who.status === "loading") return null;
+				return JSON.stringify([current, who.userId]);
+			}, (_key, notify) => {
+				const current = name();
+				if (current === null) return;
+				const joined = joinPresence(supabase, topic, current, {
+					onStatus: (next) => {
+						status = next;
+						notify();
+					},
+					onPresence: (next) => {
+						members = next;
+						notify();
+					}
+				});
+				if (!joined) return;
+				join = joined;
+				joined.sync(options.state?.());
+				return () => {
+					join = void 0;
+					members = NO_MEMBERS;
+					status = "closed";
+					joined.leave();
+					notify();
+				};
+			});
+			const track = () => {
+				follow();
+				join?.sync(options.state?.());
+			};
+			return {
+				get members() {
+					track();
+					return members;
+				},
+				get status() {
+					track();
+					return status;
+				},
+				track: (state) => join?.track(state) ?? notJoined(),
+				untrack: () => join?.untrack() ?? notJoined()
+			};
+		},
+		action(action, options = {}) {
+			const call = action;
+			const runner = createActionRunner(() => ({
+				action: call,
+				options
+			}));
+			const state = reactive(runner);
+			return {
+				run: runner.run,
+				reset: runner.reset,
+				get pending() {
+					return state.current.pending;
+				},
+				get pendingInputs() {
+					return state.current.pendingInputs;
+				},
+				get pendingInput() {
+					return state.current.pendingInput;
+				},
+				get data() {
+					return state.current.data;
+				},
+				get error() {
+					return state.current.error;
+				}
+			};
+		}
+	};
+}
+const CLIENT = Symbol("better-supabase");
+const SESSION = Symbol("better-supabase-session");
+/**
+* Binds the client for the components below, in the root layout. With a
+* `queryClient`, better-supabase queries are reset when the caller changes.
+*
+* ```svelte
+* <script lang="ts">
+*   setBetterSupabase(bs, { queryClient });
+* <\/script>
+* ```
+*/
+function setBetterSupabase(client, options = {}) {
+	const bound = createBetterSvelte(client, options);
+	const { queryClient } = options;
+	if (queryClient) onMount(() => clearOnUserChange(queryClient, client.auth));
+	return setContext(CLIENT, bound);
+}
+/** The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof bs>()`. */
+function getBetterSupabase() {
+	const bound = getContext(CLIENT);
+	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bs) in a parent component");
+	return bound;
+}
+/** The session state for UI. Call during component setup. */
+function useAuth() {
+	return getBetterSupabase().auth;
+}
+/** Subscribes to a topic while read. Call during component setup. */
+function useBroadcast(topic, values, handlers, options) {
+	return getBetterSupabase().broadcast(topic, values, handlers, options);
+}
+/**
+* Keeps a query fresh while read. Call during component setup.
+*
+* ```svelte
+* <script lang="ts">
+*   const live = useLiveQuery(() => betterSupabase.spec.customers.findMany());
+* <\/script>
+* <span data-status={live.current}></span>
+* ```
+*/
+function useLiveQuery(spec, options) {
+	return getBetterSupabase().liveQuery(spec, options);
+}
+/** A count that stays current while read. Call during component setup. */
+function useLiveCount(source, options) {
+	return getBetterSupabase().liveCount(source, options);
+}
+/** Joins a presence topic while read. Call during component setup. */
+function usePresence(topic, values, options) {
+	return getBetterSupabase().presence(topic, values, options);
+}
+/** Tracks the runs of a server action or form action. */
+function useAction(action, options) {
+	return getBetterSupabase().action(action, options);
+}
+/** Shares a server-verified session (from `+layout.ts` data) with the components below. */
+function setSession(session) {
+	setContext(SESSION, session);
+}
+/** The session from the nearest `setSession()`, typed with `useSession<Claims, Profile>()`. */
+function useSession() {
+	const session = getContext(SESSION);
+	if (!session) throw new Error("better-supabase: useSession() needs setSession(() => data.session) in a parent component");
+	return { get current() {
+		return session();
+	} };
+}
+//#endregion
+export { createBetterSvelte, fieldErrorsOf, getBetterSupabase, setBetterSupabase, setSession, useAction, useAuth, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession };