better-supabase 0.3.0 → 0.5.0

package/dist/{query-BdKLTPlj.js → query-CCbo44lG.js}

@@ -1,8 +1,8 @@
-import { t as DbException } from "./errors-Bl3rkOzo.js";
-import { t as invalidationTargets } from "./tables-Dhha3BXM.js";
-import { t as invalidateTables } from "./invalidate-DbxuL2jL.js";
+import { t as DbException } from "./errors-DtwXa6b8.js";
+import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
+import { n as invalidateTables } from "./user-change-CHFEUro1.js";
 //#region src/query/queries.ts
-/** Query errors stay `DbException`s, even for an `sb` with `mapError()`. */
+/** Query errors stay `DbException`s, even for an `betterSupabase` with `mapError()`. */
 const asException = (error) => new DbException(error);
 function isSkip(value) {
 	return typeof value === "symbol";
@@ -28,13 +28,13 @@ function specQuery(runtime, spec, key) {
 			...spec.args
 		],
 		queryFn: ({ signal }) => runtime.db().$run(spec, { signal }).orThrow(asException),
-		meta: { bsTables: runtime.sb.tablesOf(spec) },
+		meta: { bsTables: runtime.betterSupabase.tablesOf(spec) },
 		...stale
 	};
 }
 function tableQueries(runtime, table) {
 	const key = ["bs", table];
-	const specs = runtime.sb.spec[table];
+	const specs = runtime.betterSupabase.spec[table];
 	const stale = runtime.staleTime === void 0 ? {} : { staleTime: runtime.staleTime };
 	const read = (method) => (args) => isSkip(args) ? specQuery(runtime, args, [
 		...key,
@@ -84,7 +84,7 @@ function tableQueries(runtime, table) {
 				}), { signal }).orThrow(asException),
 				initialPageParam: null,
 				getNextPageParam: (last) => last.nextCursor ?? void 0,
-				meta: { bsTables: runtime.sb.tablesOf(specs["paginate"]({
+				meta: { bsTables: runtime.betterSupabase.tablesOf(specs["paginate"]({
 					...base,
 					after: null
 				})) },
@@ -105,14 +105,14 @@ function tableQueries(runtime, table) {
 				}), { signal }).orThrow(asException),
 				initialPageParam: base.page ?? 1,
 				getNextPageParam: (last) => last.page.hasMore ? last.page.number + 1 : void 0,
-				meta: { bsTables: runtime.sb.tablesOf(specs["paginate"](base)) },
+				meta: { bsTables: runtime.betterSupabase.tablesOf(specs["paginate"](base)) },
 				...stale
 			};
 		},
 		create: (args) => mutation("create", (data) => call("create", data, args), [table]),
 		update: (args) => mutation("update", (variables) => call("update", variables.id, variables.patch, args), [table]),
 		upsert: (args) => mutation("upsert", (data) => call("upsert", data, args), [table]),
-		delete: (args) => mutation("delete", (id) => call("delete", id, args), invalidationTargets(runtime.sb.meta, table))
+		delete: (args) => mutation("delete", (id) => call("delete", id, args), invalidationTargets(runtime.betterSupabase.meta, table))
 	};
 }
 /**
@@ -123,19 +123,19 @@ function tableQueries(runtime, table) {
 * changed table.
 *
 * ```ts
-* const q = createQueries(sb, () => browser.db);
+* const q = createQueries(betterSupabase, () => bs.db);
 * const { data } = useQuery(q.customers.findMany({ select: ['id', 'name'] }));
 * ```
 */
-function createQueries(sb, db, options = {}) {
+function createQueries(betterSupabase, db, options = {}) {
 	const runtime = {
-		sb,
+		betterSupabase,
 		db: typeof db === "function" ? db : () => db,
 		staleTime: options.staleTime
 	};
 	const stale = options.staleTime === void 0 ? {} : { staleTime: options.staleTime };
 	const queries = {
-		key: ["bs"],
+		$key: ["bs"],
 		$spec: (spec) => specQuery(runtime, spec),
 		$prefetch: (client, spec) => client.prefetchQuery(specQuery(runtime, spec)),
 		$rpc: (name, args, rpcOptions = {}) => ({
@@ -156,10 +156,10 @@ function createQueries(sb, db, options = {}) {
 				name
 			],
 			mutationFn: (args) => runtime.db().$rpc(name, args ?? {}).orThrow(asException),
-			onSuccess: (_data, _variables, _result, context) => invalidateTables(context.client, (sb.options.rpc?.[name]?.invalidates ?? []).flatMap((table) => invalidationTargets(sb.meta, table)))
+			onSuccess: (_data, _variables, _result, context) => invalidateTables(context.client, (betterSupabase.options.rpc?.[name]?.invalidates ?? []).flatMap((table) => invalidationTargets(betterSupabase.meta, table)))
 		})
 	};
-	for (const table of Object.keys(sb.meta.tables)) {
+	for (const table of Object.keys(betterSupabase.meta.tables)) {
 		let built;
 		Object.defineProperty(queries, table, {
 			enumerable: true,
@@ -178,9 +178,9 @@ function queryCache(client) {
 		invalidate: (target) => invalidateTables(client, target.tables)
 	};
 }
-/** Invalidates affected queries for every mutation and declared RPC `sb` performs in this runtime. */
-function invalidateOnMutation(sb, client) {
-	return sb.cache(queryCache(client));
+/** Invalidates affected queries for every mutation and declared RPC `betterSupabase` performs in this runtime. */
+function invalidateOnMutation(betterSupabase, client) {
+	return betterSupabase.cache(queryCache(client));
 }
 //#endregion
 export { invalidateOnMutation as n, queryCache as r, createQueries as t };

package/dist/queue-BYUCjr59.d.ts

@@ -0,0 +1,252 @@
+/// <reference lib="esnext.temporal" />
+import { _ as DbError, a as AsyncResult } from "./executor-BunPOO-k.js";
+import { g as RequestContext, t as Actor } from "./plugin-o144f322.js";
+import { t as SqlClient } from "./executor-Cghdstwu.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/jobs/queue.d.ts
+type QueueSchemas = Readonly<Record<string, StandardSchemaV1>>;
+type PayloadIn<Q extends QueueSchemas, N extends keyof Q> = StandardSchemaV1.InferInput<Q[N]>;
+type PayloadOut<Q extends QueueSchemas, N extends keyof Q> = StandardSchemaV1.InferOutput<Q[N]>;
+/** The actor and tenant of the request that enqueued a job. */
+interface JobContext {
+  readonly actor?: Actor;
+  readonly tenant?: string;
+}
+interface Job<P = unknown> {
+  /** The pgmq message id. */
+  readonly id: number;
+  readonly queue: string;
+  readonly payload: P;
+  /** 1 on the first run (pgmq's `read_ct`). */
+  readonly attempts: number;
+  readonly maxAttempts: number;
+  readonly enqueuedAt: Temporal.Instant;
+  /** End of the lease: the job becomes claimable again after this. */
+  readonly visibleUntil: Temporal.Instant;
+  readonly lastError: string | null;
+  /**
+   * The actor and tenant recorded at enqueue, ready for `db.$with(job.context)`.
+   * Without a recorded tenant, `tenant()` applies its `onMissing` unless the
+   * worker runs with `allTenants: true`.
+   */
+  readonly context: RequestContext;
+}
+interface EnqueueOptions {
+  /** Run no earlier than this. */
+  readonly runAt?: Temporal.Instant;
+  /** Seconds to wait before running. */
+  readonly delay?: number;
+  /** Defaults to 5. After this many failed attempts the job is archived as dead. */
+  readonly maxAttempts?: number;
+  /**
+   * While a job with this key is waiting or running, enqueueing again returns
+   * its id. SQL connections only.
+   */
+  readonly dedupeKey?: string;
+  /**
+   * The request context whose actor and tenant the job records, next to the
+   * payload. The tenant is `context.tenant`, the one `tenant()` resolved, or
+   * the `tenant_id` claim (then `app_metadata.tenant_id`).
+   */
+  readonly context?: RequestContext;
+}
+interface ScheduleOptions {
+  /** The actor and tenant every scheduled run records, as in `enqueue`. */
+  readonly context?: RequestContext;
+  /**
+   * The IANA time zone the cron fields are read in. Defaults to `UTC`.
+   * Other zones need `kits.jobs.options.scheduler: "drain"`.
+   */
+  readonly timeZone?: string;
+}
+interface RunSchedulesOptions {
+  /** Seconds a claimed schedule stays leased. Defaults to 60. */
+  readonly lease?: number;
+  /** Defaults to 100. */
+  readonly batch?: number;
+}
+interface DrainOptions extends Omit<WorkOptions, "pollInterval" | "maxPollInterval" | "signal"> {
+  /** Stop claiming after this many ms; claimed jobs still finish. */
+  readonly budgetMs?: number;
+}
+interface DrainRouteOptions<Q extends QueueSchemas> extends Omit<DrainOptions, "onError"> {
+  /**
+   * The bearer token callers send (`Authorization: Bearer <secret>`), such
+   * as Vercel's `CRON_SECRET`. Required.
+   */
+  readonly secret: string | undefined;
+  /** The queues to drain, in order, with their handlers. */
+  readonly handlers: { readonly [N in Extract<keyof Q, string>]?: JobHandler<PayloadOut<Q, N>>; };
+  /** Total time in ms for schedules and queues. Defaults to 50000. */
+  readonly budgetMs?: number;
+  /** Enqueue due schedules first (the drain scheduler). Defaults to true. */
+  readonly schedules?: boolean;
+  readonly onError?: (error: DbError, job?: Job) => void;
+}
+interface DrainRouteResult {
+  /** Schedules whose run was enqueued. */
+  readonly schedules: number;
+  readonly queues: Readonly<Record<string, DrainResult>>;
+  /** True when the budget ran out before every queue was empty. */
+  readonly budgetExhausted: boolean;
+}
+interface ClaimOptions {
+  /** Defaults to 1. */
+  readonly batch?: number;
+  /** Seconds a claimed job stays invisible to other workers. Defaults to 300. */
+  readonly lease?: number;
+}
+interface FailOptions {
+  /** Retry after this many seconds instead of the exponential backoff. SQL connections only. */
+  readonly retryIn?: number;
+}
+type JobHandler<P> = (payload: P, job: Job<P>, signal: AbortSignal) => unknown;
+interface WorkOptions extends ClaimOptions {
+  /** Jobs handled at once. Defaults to 1. */
+  readonly concurrency?: number;
+  /**
+   * First wait between polls when the queue is empty, in ms. Defaults to
+   * 1000. Each empty poll doubles the wait up to `maxPollInterval`; a claimed
+   * job resets it.
+   */
+  readonly pollInterval?: number;
+  /** Longest wait between empty polls, in ms. Defaults to 30000. */
+  readonly maxPollInterval?: number;
+  /** Stops the loop; running jobs finish first. */
+  readonly signal?: AbortSignal;
+  readonly onError?: (error: DbError, job: Job) => void;
+  /**
+   * Run jobs that recorded no tenant with a context that `tenant()` and
+   * tenant buckets don't scope. Off by default, so such jobs get the
+   * `onMissing` of `tenant()`.
+   */
+  readonly allTenants?: boolean;
+}
+interface DrainResult {
+  readonly succeeded: number;
+  readonly failed: number;
+}
+interface Jobs<Q extends QueueSchemas> {
+  /** Validates the payload with the queue's schema, then enqueues it. Returns the job id. */
+  enqueue<N extends Extract<keyof Q, string>>(queue: N, payload: PayloadIn<Q, N>, options?: EnqueueOptions): AsyncResult<number>;
+  claim<N extends Extract<keyof Q, string>>(queue: N, options?: ClaimOptions): AsyncResult<Job<PayloadOut<Q, N>>[]>;
+  /** Archives the job. `false` when the lease was lost (another worker claimed it since). */
+  complete(job: Job): AsyncResult<boolean>;
+  /** Returns the new state: `queued` (will retry), `dead` (archived), or `null` when the lease was lost. */
+  fail(job: Job, error: unknown, options?: FailOptions): AsyncResult<"queued" | "dead" | null>;
+  /** Pushes the lease out by `lease` seconds. `false` when it was lost or the transport can't. */
+  extend(job: Job, lease: number): AsyncResult<boolean>;
+  /**
+   * Enqueues a dead letter again with its payload and attempts, and removes
+   * it from the archive. Returns the new id, or `null` when `id` is not a
+   * dead letter of `queue`. SQL connections only.
+   */
+  replay(queue: Extract<keyof Q, string>, id: number): AsyncResult<number | null>;
+  /**
+   * Enqueues `payload` on a cron schedule (`'0 3 * * *'`, `'@daily'`,
+   * `'30 seconds'`), with pg_cron or the drain scheduler
+   * (`kits.jobs.options.scheduler`). Re-scheduling a name replaces it. SQL
+   * connections only.
+   */
+  schedule<N extends Extract<keyof Q, string>>(name: string, cron: string, queue: N, payload: PayloadIn<Q, N>, options?: ScheduleOptions): AsyncResult<void>;
+  unschedule(name: string): AsyncResult<boolean>;
+  /**
+   * Enqueues one run of every due schedule (the drain scheduler) and moves
+   * it to its next time. Returns how many ran. Missed runs collapse into one.
+   */
+  runSchedules(options?: RunSchedulesOptions): AsyncResult<number>;
+  /** Processes ready jobs until the queue is empty or the budget is spent. For cron and edge invocations. */
+  drain<N extends Extract<keyof Q, string>>(queue: N, handler: JobHandler<PayloadOut<Q, N>>, options?: DrainOptions): Promise<DrainResult>;
+  /**
+   * A route handler for a cron caller such as Vercel Cron: checks the bearer
+   * secret, runs due schedules, then drains each queue in `handlers` within
+   * the budget, and answers with a `DrainRouteResult`.
+   */
+  drainRoute(options: DrainRouteOptions<Q>): (request: Request) => Promise<Response>;
+  /** Polls and processes jobs until `signal` aborts. */
+  work<N extends Extract<keyof Q, string>>(queue: N, handler: JobHandler<PayloadOut<Q, N>>, options?: WorkOptions): Promise<DrainResult>;
+}
+/** The body of a queued message, on pgmq and the table backend alike. */
+interface QueueMessageBody {
+  readonly payload?: unknown;
+  readonly max_attempts?: number;
+  readonly last_error?: string;
+}
+/** A claimed message, as `better_supabase.claim_jobs` returns it. */
+interface QueueMessageRow {
+  readonly id: string | number;
+  /** 1 on the first claim; a lease token for complete, fail and extend. */
+  readonly attempts: number;
+  readonly enqueued_at: Date | string;
+  readonly visible_until: Date | string;
+  readonly message: QueueMessageBody | null;
+}
+/** A schedule whose run is due, claimed by `runSchedules`. */
+interface DueSchedule {
+  readonly name: string;
+  readonly cron: string;
+  readonly timeZone: string;
+  readonly queue: string;
+  /** The payload as stored, with its recorded context. */
+  readonly payload: unknown;
+  readonly nextRun: Temporal.Instant;
+}
+/** A Supabase client, or anything with `.schema(name).rpc(fn, args)`. */
+interface QueueRpcClient {
+  schema(name: string): {
+    rpc(fn: string, args: Readonly<Record<string, unknown>>): PromiseLike<{
+      data: unknown;
+      error: unknown;
+    }>;
+  };
+}
+/**
+ * Where `createJobs` stores jobs. `sqlQueueBackend` (the `jobs` SQL kit
+ * module, on pgmq or its table backend) and `pgmqPublicBackend` ship with
+ * the package; `testQueueBackend` from `better-supabase/testing` checks
+ * another one.
+ */
+interface QueueBackend {
+  readonly apiVersion: 1;
+  readonly name: string;
+  /** Whether `extend` works, so long-running batches keep their lease. */
+  readonly leases: boolean;
+  send(queue: string, payload: unknown, delay: number, maxAttempts: number, dedupeKey: string | undefined): Promise<number>;
+  read(queue: string, lease: number, batch: number): Promise<readonly QueueMessageRow[]>;
+  /** `false` when the lease was lost. */
+  complete(job: Job): Promise<boolean>;
+  fail(job: Job, error: string, retryIn: number | undefined): Promise<"queued" | "dead" | null>;
+  extend(job: Job, lease: number): Promise<boolean>;
+  /** Re-enqueues a dead letter; `null` when it isn't one. Absent when the backend can't. */
+  replay?(queue: string, id: number): Promise<number | null>;
+  schedule(name: string, cron: string, queue: string, payload: unknown, timeZone: string, nextRun: Temporal.Instant): Promise<void>;
+  unschedule(name: string): Promise<boolean>;
+  /** Leases due schedules (the drain scheduler); absent or empty with pg_cron. */
+  dueSchedules?(lease: number, batch: number): Promise<readonly DueSchedule[]>;
+  /** Moves a schedule from `ran` to `next`; `false` when it changed since the claim. */
+  advanceSchedule?(name: string, ran: Temporal.Instant, next: Temporal.Instant): Promise<boolean>;
+}
+/**
+ * The `jobs` SQL kit module over a service SQL connection. The same
+ * functions back both `kits.jobs.options.backend` values (pgmq and table)
+ * and both schedulers.
+ */
+declare function sqlQueueBackend(sql: SqlClient): QueueBackend;
+/**
+ * Supabase's `pgmq_public` RPCs (Integrations, Queues, "Expose Queues via
+ * PostgREST"). No lease check on complete, no retry delay, no deduplication
+ * and no schedules: a failed job reappears when its lease ends.
+ */
+declare function pgmqPublicBackend(client: QueueRpcClient): QueueBackend;
+/**
+ * Typed jobs on Supabase Queues (pgmq), over the `jobs` SQL kit module.
+ *
+ * Pass a service SQL connection (`postgres.admin`, `ctx.sql`) for the full
+ * feature set, a service-role Supabase client to go through the
+ * `pgmq_public` RPCs where no direct connection exists (edge functions), or
+ * any `QueueBackend`. Queue names are lowercase letters, digits and
+ * underscores.
+ */
+declare function createJobs<const Q extends QueueSchemas>(source: SqlClient | QueueRpcClient | QueueBackend, queues: Q): Jobs<Q>;
+//#endregion
+export { sqlQueueBackend as C, pgmqPublicBackend as S, QueueSchemas as _, DrainRouteResult as a, WorkOptions as b, FailOptions as c, JobHandler as d, Jobs as f, QueueRpcClient as g, QueueMessageRow as h, DrainRouteOptions as i, Job as l, QueueMessageBody as m, DrainOptions as n, DueSchedule as o, QueueBackend as p, DrainResult as r, EnqueueOptions as s, ClaimOptions as t, JobContext as u, RunSchedulesOptions as v, createJobs as x, ScheduleOptions as y };

package/dist/react/index.d.ts

@@ -1,7 +1,8 @@
-import { s as Impersonator } from "../mfa-x3V3vGh-.js";
-import { t as AuthSession } from "../view-3Po_PVlr.js";
-import { r as LiveCountSeed } from "../live-QE3UPbGm.js";
-import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-DvJXoI02.js";
-import { a as BrowserLike, c as LiveCountHookOptions, d as createHooks, f as useAuth, g as useSupabase, h as useLiveQuery, i as BroadcastOptions, l as LiveQueryHookOptions, m as useLiveCount, n as BetterSupabaseProvider, o as ClaimsOf, p as useBroadcast, r as BetterSupabaseProviderProps, s as LiveCount, t as BetterHooks, u as ProfileOf } from "../index-BNsABq7P.js";
-import { SessionProvider, SessionProviderProps, useSession } from "./session.js";
-export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type BrowserLike, type ClaimsOf, type EntitlementKey, type Impersonator, type LiveCount, type LiveCountHookOptions, type LiveCountSeed, type LiveQueryHookOptions, type MembershipClaim, type ProfileOf, SessionProvider, type SessionProviderProps, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };
+import { s as Impersonator } from "../mfa-CusDgPaD.js";
+import { t as AuthSession } from "../view-BEf0diC5.js";
+import { r as LiveCountSeed } from "../live-D9W2M5aO.js";
+import { n as supportOf, t as SupportView } from "../support-view-Da5peKFg.js";
+import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-DUxU4oHe.js";
+import { _ as useBroadcast, a as BetterHooks, b as useSupabase, c as BroadcastOptions, d as LiveCount, f as LiveCountHookOptions, g as useAuth, h as createHooks, i as useNotifications, l as ClaimsOf, m as ProfileOf, n as NotificationsState, o as BetterSupabaseProvider, p as LiveQueryHookOptions, r as UseNotificationsOptions, s as BetterSupabaseProviderProps, t as NotificationSource, u as ClientLike, v as useLiveCount, y as useLiveQuery } from "../index-BGdgBPdf.js";
+import { SessionProvider, SessionProviderProps, useSession, useSupportSession } from "./session.js";
+export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type ClaimsOf, type ClientLike, type EntitlementKey, type Impersonator, type LiveCount, type LiveCountHookOptions, type LiveCountSeed, type LiveQueryHookOptions, type MembershipClaim, type NotificationSource, type NotificationsState, type ProfileOf, SessionProvider, type SessionProviderProps, type SupportView, type UseNotificationsOptions, createHooks, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveCount, useLiveQuery, useNotifications, useSession, useSupabase, useSupportSession };

package/dist/react/index.js

@@ -1,5 +1,6 @@
 "use client";
-import { SessionProvider, useSession } from "./session.js";
-import { a as useLiveCount, i as useBroadcast, n as createHooks, o as useLiveQuery, r as useAuth, s as useSupabase, t as BetterSupabaseProvider } from "../react-DNBYNazu.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
+import { SessionProvider, useSession, useSupportSession } from "./session.js";
+import { a as useBroadcast, c as useSupabase, i as useAuth, n as BetterSupabaseProvider, o as useLiveCount, r as createHooks, s as useLiveQuery, t as useNotifications } from "../react-C_s7kiNz.js";
 import { t as hasEntitlement } from "../entitlements-CTEBm7IB.js";
-export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, useAuth, useBroadcast, useLiveCount, useLiveQuery, useSession, useSupabase };
+export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveCount, useLiveQuery, useNotifications, useSession, useSupabase, useSupportSession };

package/dist/react/server.d.ts

@@ -1,13 +1,24 @@
-import { t as AuthSession } from "../view-3Po_PVlr.js";
-import { a as BrowserLike, f as useAuth, g as useSupabase, h as useLiveQuery, i as BroadcastOptions, l as LiveQueryHookOptions, n as BetterSupabaseProvider, o as ClaimsOf, p as useBroadcast, r as BetterSupabaseProviderProps, t as BetterHooks, u as ProfileOf } from "../index-BNsABq7P.js";
+import { Z as QuerySpec } from "../define-Bp_BZa5h.js";
+import { s as Impersonator } from "../mfa-CusDgPaD.js";
+import { t as AuthSession } from "../view-BEf0diC5.js";
+import { r as LiveCountSeed } from "../live-D9W2M5aO.js";
+import { n as supportOf, t as SupportView } from "../support-view-Da5peKFg.js";
+import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-DUxU4oHe.js";
+import { _ as useBroadcast, a as BetterHooks, b as useSupabase, c as BroadcastOptions, d as LiveCount, f as LiveCountHookOptions, g as useAuth, l as ClaimsOf, m as ProfileOf, n as NotificationsState, o as BetterSupabaseProvider, p as LiveQueryHookOptions, r as UseNotificationsOptions, s as BetterSupabaseProviderProps, t as NotificationSource, u as ClientLike, y as useLiveQuery } from "../index-BGdgBPdf.js";
 import { SessionProvider, SessionProviderProps } from "./session.js";
 //#region src/react/server.d.ts
-/** The `react-server` build of `useSession`: await `next.session()` instead. */
+/** The `react-server` build of `useSession`: await `bs.session()` instead. */
 export declare const useSession: <C = unknown, P = unknown>() => AuthSession<C, P>;
+/** The `react-server` build of `useSupportSession`: use `supportOf(await bs.session())` instead. */
+export declare const useSupportSession: () => SupportView | undefined;
+/** The `react-server` build of `useLiveCount`: render the `bs.liveCount()` seed instead. */
+export declare const useLiveCount: (source: QuerySpec<string, "count", number> | LiveCountSeed | null | undefined, options?: LiveCountHookOptions) => LiveCount;
+/** The `react-server` build of `useNotifications`: call `notifications.list()` instead. */
+export declare const useNotifications: <T>(options: UseNotificationsOptions<T>) => NotificationsState<T>;
 /**
  * The `react-server` build of `createHooks`: importing a module that creates
  * hooks is safe on the server, calling a hook there throws.
  */
-export declare function createHooks<B extends BrowserLike>(): BetterHooks<B>;
+export declare function createHooks<B extends ClientLike>(): BetterHooks<B>;
 //#endregion
-export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type BrowserLike, type ClaimsOf, type LiveQueryHookOptions, type ProfileOf, SessionProvider, type SessionProviderProps, useAuth, useBroadcast, useLiveQuery, useSupabase };
+export { type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type ClaimsOf, type ClientLike, type EntitlementKey, type Impersonator, type LiveCount, type LiveCountHookOptions, type LiveCountSeed, type LiveQueryHookOptions, type MembershipClaim, type NotificationSource, type NotificationsState, type ProfileOf, SessionProvider, type SessionProviderProps, type SupportView, type UseNotificationsOptions, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveQuery, useSupabase };

package/dist/react/server.js

@@ -1,13 +1,21 @@
-import { i as useBroadcast, o as useLiveQuery, r as useAuth, s as useSupabase, t as BetterSupabaseProvider } from "../react-DNBYNazu.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
+import { a as useBroadcast, c as useSupabase, i as useAuth, n as BetterSupabaseProvider, s as useLiveQuery } from "../react-C_s7kiNz.js";
+import { t as hasEntitlement } from "../entitlements-CTEBm7IB.js";
 import { SessionProvider } from "./session.js";
 //#region src/react/server.ts
 function clientOnly(name) {
 	return () => {
-		throw new Error(`better-supabase: ${name}() runs in Client Components only. In Server Components use \`next.server()\` or \`db.$run(spec)\`.`);
+		throw new Error(`better-supabase: ${name}() runs in Client Components only. In Server Components use \`bs.context()\` or \`db.$run(spec)\`.`);
 	};
 }
-/** The `react-server` build of `useSession`: await `next.session()` instead. */
+/** The `react-server` build of `useSession`: await `bs.session()` instead. */
 const useSession = clientOnly("useSession");
+/** The `react-server` build of `useSupportSession`: use `supportOf(await bs.session())` instead. */
+const useSupportSession = clientOnly("useSupportSession");
+/** The `react-server` build of `useLiveCount`: render the `bs.liveCount()` seed instead. */
+const useLiveCount = clientOnly("useLiveCount");
+/** The `react-server` build of `useNotifications`: call `notifications.list()` instead. */
+const useNotifications = clientOnly("useNotifications");
 /**
 * The `react-server` build of `createHooks`: importing a module that creates
 * hooks is safe on the server, calling a hook there throws.
@@ -22,4 +30,4 @@ function createHooks() {
 	};
 }
 //#endregion
-export { BetterSupabaseProvider, SessionProvider, createHooks, useAuth, useBroadcast, useLiveQuery, useSession, useSupabase };
+export { BetterSupabaseProvider, SessionProvider, createHooks, hasEntitlement, supportOf, useAuth, useBroadcast, useLiveCount, useLiveQuery, useNotifications, useSession, useSupabase, useSupportSession };

package/dist/react/session.d.ts

@@ -1,9 +1,10 @@
-import { t as AuthSession } from "../view-3Po_PVlr.js";
+import { t as AuthSession } from "../view-BEf0diC5.js";
+import { t as SupportView } from "../support-view-Da5peKFg.js";
 import { ReactNode } from "react";
 //#region src/react/session.d.ts
 export interface SessionProviderProps {
   /**
-   * An unresolved `next.session()` promise, created inside a `<Suspense>`
+   * An unresolved `bs.session()` promise, created inside a `<Suspense>`
    * boundary so the layout itself never waits for auth.
    */
   readonly sessionPromise: Promise<AuthSession>;
@@ -14,8 +15,13 @@ export declare function SessionProvider(props: SessionProviderProps): ReactNode;
 /**
  * The session from the nearest `<SessionProvider>`. Suspends until the
  * promise resolves, so render it inside `<Suspense>`. `C` types the claims
- * (the output of `sb.claims(schema)`) and `P` the profile (the output of
- * `sb.userMetadata(schema)`); `createHooks().useSession` infers both.
+ * (the output of `betterSupabase.claims(schema)`) and `P` the profile (the output of
+ * `betterSupabase.userMetadata(schema)`); `createHooks().useSession` infers both.
  */
 export declare function useSession<C = unknown, P = unknown>(): AuthSession<C, P>;
+/**
+ * The support session the page renders in, for a "Viewing as" banner, or
+ * `undefined` for a normal session. Needs `<SessionProvider>` like `useSession`.
+ */
+export declare function useSupportSession(): SupportView | undefined;
 //#endregion

package/dist/react/session.js

@@ -1,4 +1,5 @@
 "use client";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
 import { createContext, createElement, use, useContext } from "react";
 //#region src/react/session.ts
 const SessionContext = createContext(null);
@@ -9,13 +10,20 @@ function SessionProvider(props) {
 /**
 * The session from the nearest `<SessionProvider>`. Suspends until the
 * promise resolves, so render it inside `<Suspense>`. `C` types the claims
-* (the output of `sb.claims(schema)`) and `P` the profile (the output of
-* `sb.userMetadata(schema)`); `createHooks().useSession` infers both.
+* (the output of `betterSupabase.claims(schema)`) and `P` the profile (the output of
+* `betterSupabase.userMetadata(schema)`); `createHooks().useSession` infers both.
 */
 function useSession() {
 	const promise = useContext(SessionContext);
 	if (!promise) throw new Error("better-supabase: useSession() needs <SessionProvider sessionPromise={...}>");
 	return use(promise);
 }
+/**
+* The support session the page renders in, for a "Viewing as" banner, or
+* `undefined` for a normal session. Needs `<SessionProvider>` like `useSession`.
+*/
+function useSupportSession() {
+	return supportOf(useSession());
+}
 //#endregion
-export { SessionProvider, useSession };
+export { SessionProvider, useSession, useSupportSession };