better-supabase 0.5.0 → 0.6.0

package/dist/{queue-BYUCjr59.d.ts → queue-CLJurhdy.d.ts}

@@ -1,9 +1,120 @@
 /// <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 { b as DbError, t as AsyncResult } from "./result-D7y2fT87.js";
+import { t as SqlClient } from "./executor-DbvExCFC.js";
+import { m as RequestContext, t as Actor } from "./plugin-FGY8UhYm.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-CKtbFcRv.js";
+import { t as BlockProblemOptions } from "./problem-DD8LZFjc.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/jobs/queue.d.ts
+//#region src/blocks/jobs/backends.d.ts
+/** 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 queue's counts, as `jobs.stats` returns them. */
+interface QueueStats {
+  /** Visible now: the next claim takes them. */
+  readonly ready: number;
+  /** Claimed by a worker, or waiting out the backoff before a retry. */
+  readonly inFlight: number;
+  /** Enqueued with a delay and not claimed yet. */
+  readonly delayed: number;
+  /** Dead letters kept in the archive. */
+  readonly dead: number;
+  /** Seconds since the oldest message that isn't done was enqueued; null when none is waiting. */
+  readonly oldestAgeSeconds: number | null;
+}
+/** A dead letter, as `better_supabase.list_dead_jobs` returns it. */
+interface DeadJobRow {
+  readonly id: string | number;
+  readonly attempts: number;
+  readonly enqueued_at: Date | string;
+  readonly died_at: Date | string | null;
+  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 {
+  /**
+   * `never` parameters, so a typed `SupabaseClient<Database>` whose types
+   * leave out `pgmq_public` fits too.
+   */
+  schema(name: never): {
+    rpc(fn: never, args: never): PromiseLike<{
+      data: unknown;
+      error: unknown;
+    }>;
+  };
+}
+/**
+ * Where `createJobs` stores jobs. `sqlQueueBackend` (the `jobs` SQL module
+ * 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, dedupe?: "always" | "waiting"): 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>;
+  /** Counts for one queue. Absent when the backend can't. */
+  stats?(queue: string): Promise<QueueStats>;
+  /** Dead letters, newest first, before `before` when given. Absent when the backend can't. */
+  listDead?(queue: string, limit: number, before: number | undefined): Promise<readonly DeadJobRow[]>;
+  /** Re-enqueues the dead letters `ids`, or the newest `limit`; returns how many. */
+  retryDead?(queue: string, ids: readonly number[] | undefined, limit: number): Promise<number>;
+  schedule(name: string, cron: string, queue: string, payload: unknown, timeZone: string, nextRun: Temporal.Instant, tenant?: string): Promise<void>;
+  unschedule(name: string): Promise<boolean>;
+  /** Schedules by name prefix and tenant. Absent when the backend can't list them. */
+  listSchedules?(filter: ScheduleFilter): Promise<readonly ScheduleInfo[]>;
+  /** Removes a tenant's schedules and returns how many. Absent when the backend can't. */
+  unscheduleTenant?(tenant: string): Promise<number>;
+  /** 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 module over a service SQL connection. The same
+ * functions back both `sql.modules.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;
+//#endregion
+//#region src/blocks/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]>;
@@ -11,6 +122,11 @@ type PayloadOut<Q extends QueueSchemas, N extends keyof Q> = StandardSchemaV1.In
 interface JobContext {
   readonly actor?: Actor;
   readonly tenant?: string;
+  /**
+   * The `act` claim of a support or impersonated session, so the job runs
+   * under the same terms (a read-only support session stays read-only).
+   */
+  readonly act?: Readonly<Record<string, unknown>>;
 }
 interface Job<P = unknown> {
   /** The pgmq message id. */
@@ -25,7 +141,8 @@ interface Job<P = unknown> {
   readonly visibleUntil: Temporal.Instant;
   readonly lastError: string | null;
   /**
-   * The actor and tenant recorded at enqueue, ready for `db.$with(job.context)`.
+   * The actor and tenant recorded at enqueue, ready for `bs.forContext(job.context)`,
+   * which runs as that user with RLS.
    * Without a recorded tenant, `tenant()` applies its `onMissing` unless the
    * worker runs with `allTenants: true`.
    */
@@ -43,6 +160,13 @@ interface EnqueueOptions {
    * its id. SQL connections only.
    */
   readonly dedupeKey?: string;
+  /**
+   * Which jobs with the same `dedupeKey` take the enqueue: `"always"` (the
+   * default) a waiting or running one, `"waiting"` only one no worker has
+   * claimed yet, so a change made during a run queues one follow-up (a
+   * debounce).
+   */
+  readonly dedupe?: "always" | "waiting";
   /**
    * The request context whose actor and tenant the job records, next to the
    * payload. The tenant is `context.tenant`, the one `tenant()` resolved, or
@@ -53,12 +177,72 @@ interface EnqueueOptions {
 interface ScheduleOptions {
   /** The actor and tenant every scheduled run records, as in `enqueue`. */
   readonly context?: RequestContext;
+  /**
+   * The tenant the schedule belongs to, for `listSchedules({ tenant })` and
+   * `unscheduleAll({ tenant })`. Defaults to the tenant of `context`. Needs
+   * `sql.modules.jobs.options.scheduler: "drain"`.
+   */
+  readonly tenant?: string;
   /**
    * The IANA time zone the cron fields are read in. Defaults to `UTC`.
-   * Other zones need `kits.jobs.options.scheduler: "drain"`.
+   * Other zones need `sql.modules.jobs.options.scheduler: "drain"`.
    */
   readonly timeZone?: string;
 }
+/** One schedule of the set `ensureSchedules` keeps. */
+interface ScheduleDefinition<Q extends QueueSchemas, N extends Extract<keyof Q, string> = Extract<keyof Q, string>> extends ScheduleOptions {
+  readonly name: string;
+  readonly cron: string;
+  readonly queue: N;
+  readonly payload: PayloadIn<Q, N>;
+}
+/** Each queue's `ScheduleDefinition`, so `payload` follows `queue`. */
+type ScheduleDefinitions<Q extends QueueSchemas> = { readonly [N in Extract<keyof Q, string>]: ScheduleDefinition<Q, N>; }[Extract<keyof Q, string>];
+interface EnsureSchedulesOptions {
+  /**
+   * The set's name prefix, such as `workflow:`. Every definition's name
+   * starts with it, and existing schedules under it that the set doesn't
+   * name are removed.
+   */
+  readonly prefix: string;
+  /**
+   * Only this tenant's schedules under the prefix are compared and removed,
+   * and definitions without their own tenant get it.
+   */
+  readonly tenant?: string;
+}
+interface EnsureSchedulesResult {
+  /** The names written, in the order given. */
+  readonly scheduled: readonly string[];
+  /** Schedules under the prefix that the set no longer names. */
+  readonly removed: readonly string[];
+}
+interface ListDeadOptions extends CursorPageOptions<number> {
+  /** Defaults to 100, at most 1000. */
+  readonly limit?: number;
+  /** Only dead letters with a lower id, for the next page. */
+  readonly cursor?: number;
+}
+interface RetryDeadOptions {
+  /** The dead letters to retry. Defaults to the newest `limit`. */
+  readonly ids?: readonly number[];
+  /** Defaults to 1000. */
+  readonly limit?: number;
+}
+/** A dead letter as `listDead` returns it. */
+interface DeadJob<P = unknown> {
+  readonly id: number;
+  readonly queue: string;
+  /** The stored payload, unvalidated: its schema may have changed since. */
+  readonly payload: P;
+  readonly context: RequestContext;
+  readonly attempts: number;
+  readonly maxAttempts: number;
+  readonly lastError: string | null;
+  readonly enqueuedAt: Temporal.Instant;
+  /** When it was archived as dead. */
+  readonly diedAt: Temporal.Instant | null;
+}
 interface RunSchedulesOptions {
   /** Seconds a claimed schedule stays leased. Defaults to 60. */
   readonly lease?: number;
@@ -69,7 +253,7 @@ interface DrainOptions extends Omit<WorkOptions, "pollInterval" | "maxPollInterv
   /** Stop claiming after this many ms; claimed jobs still finish. */
   readonly budgetMs?: number;
 }
-interface DrainRouteOptions<Q extends QueueSchemas> extends Omit<DrainOptions, "onError"> {
+interface DrainRouteOptions<Q extends QueueSchemas> extends Omit<DrainOptions, "onError">, BlockProblemOptions {
   /**
    * The bearer token callers send (`Authorization: Bearer <secret>`), such
    * as Vercel's `CRON_SECRET`. Required.
@@ -82,6 +266,8 @@ interface DrainRouteOptions<Q extends QueueSchemas> extends Omit<DrainOptions, "
   /** Enqueue due schedules first (the drain scheduler). Defaults to true. */
   readonly schedules?: boolean;
   readonly onError?: (error: DbError, job?: Job) => void;
+  /** Hooks around each authorized drain, such as cron monitor check-ins. */
+  readonly monitor?: DrainMonitor;
 }
 interface DrainRouteResult {
   /** Schedules whose run was enqueued. */
@@ -89,6 +275,39 @@ interface DrainRouteResult {
   readonly queues: Readonly<Record<string, DrainResult>>;
   /** True when the budget ran out before every queue was empty. */
   readonly budgetExhausted: boolean;
+  /** Schedule or queue runs that failed as a whole (individual job failures are in `queues`). */
+  readonly errors: number;
+}
+/**
+ * Hooks around one authorized drain, for cron monitoring such as Sentry
+ * check-ins. A hook that throws is reported to `onError` and never fails
+ * the drain.
+ */
+interface DrainMonitor {
+  /** Before schedules run. Its return value (a check-in id) is passed to `onFinish`. */
+  onStart?(request: Request): unknown;
+  /** After the queues ran, with the result the route answers with. */
+  onFinish?(result: DrainRouteResult, started: unknown): unknown;
+}
+/** A schedule as `listSchedules` returns it. */
+interface ScheduleInfo {
+  readonly name: string;
+  readonly cron: string;
+  readonly timeZone: string;
+  /** Null under pg_cron, which keeps only the command. */
+  readonly queue: string | null;
+  readonly tenant: string | null;
+  /** The next run; null under pg_cron. */
+  readonly nextRun: Temporal.Instant | null;
+  readonly lastRun: Temporal.Instant | null;
+  /** Set while a drain holds the schedule. */
+  readonly leasedUntil: Temporal.Instant | null;
+  readonly createdAt: Temporal.Instant | null;
+}
+interface ScheduleFilter {
+  /** Schedules whose name starts with this, e.g. `workflow:`. */
+  readonly prefix?: string;
+  readonly tenant?: string;
 }
 interface ClaimOptions {
   /** Defaults to 1. */
@@ -142,14 +361,42 @@ interface Jobs<Q extends QueueSchemas> {
    * dead letter of `queue`. SQL connections only.
    */
   replay(queue: Extract<keyof Q, string>, id: number): AsyncResult<number | null>;
+  /**
+   * Counts per queue (ready, in flight, delayed, dead and the oldest
+   * waiting message's age), for an admin page. Defaults to every queue
+   * `createJobs` declared. SQL connections only.
+   */
+  stats<N extends Extract<keyof Q, string>>(queues?: readonly N[]): AsyncResult<Record<N, QueueStats>>;
+  /** A queue's dead letters, newest first, for an admin page. SQL connections only. */
+  listDead<N extends Extract<keyof Q, string>>(queue: N, options?: ListDeadOptions): AsyncResult<DeadJob<PayloadOut<Q, N>>[]>;
+  /**
+   * Enqueues dead letters again, the `ids` given or the newest `limit`
+   * (1000), each with its payload, attempts and dedupe key. Returns how many
+   * went back on the queue. SQL connections only.
+   */
+  retryDead(queue: Extract<keyof Q, string>, options?: RetryDeadOptions): AsyncResult<number>;
   /**
    * 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
+   * (`sql.modules.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>;
+  /**
+   * Makes the schedules under `prefix` (and `tenant`) exactly `definitions`:
+   * writes each one, keeping the next run of a schedule whose cron and time
+   * zone didn't change, and removes the rest. Every payload and cron is
+   * checked before anything is written. Run it on deploy or after a
+   * settings change; running it twice changes nothing. SQL connections only.
+   */
+  ensureSchedules(definitions: readonly ScheduleDefinitions<Q>[], options: EnsureSchedulesOptions): AsyncResult<EnsureSchedulesResult>;
+  /** Schedules by name prefix or tenant, with their next and last run. SQL connections only. */
+  listSchedules(filter?: ScheduleFilter): AsyncResult<ScheduleInfo[]>;
+  /** Removes every schedule of a tenant, for tenant deletion; returns how many. SQL connections only. */
+  unscheduleAll(filter: {
+    readonly tenant: string;
+  }): AsyncResult<number>;
   /**
    * 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.
@@ -166,80 +413,8 @@ interface Jobs<Q extends QueueSchemas> {
   /** 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.
+ * Typed jobs on Supabase Queues (pgmq), over the `jobs` SQL module.
  *
  * Pass a service SQL connection (`postgres.admin`, `ctx.sql`) for the full
  * feature set, a service-role Supabase client to go through the
@@ -247,6 +422,6 @@ declare function pgmqPublicBackend(client: QueueRpcClient): QueueBackend;
  * 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>;
+declare function createJobs<const Q extends QueueSchemas>(source: SqlClient | QueueRpcClient | QueueBackend, queues: Q, options?: BlockTemporalOptions): 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 };
+export { QueueMessageBody as A, ScheduleInfo as C, DeadJobRow as D, createJobs as E, sqlQueueBackend as F, QueueRpcClient as M, QueueStats as N, DueSchedule as O, pgmqPublicBackend as P, ScheduleFilter as S, WorkOptions as T, QueueSchemas as _, DrainResult as a, ScheduleDefinition as b, EnqueueOptions as c, FailOptions as d, Job as f, ListDeadOptions as g, Jobs as h, DrainOptions as i, QueueMessageRow as j, QueueBackend as k, EnsureSchedulesOptions as l, JobHandler as m, DeadJob as n, DrainRouteOptions as o, JobContext as p, DrainMonitor as r, DrainRouteResult as s, ClaimOptions as t, EnsureSchedulesResult as u, RetryDeadOptions as v, ScheduleOptions as w, ScheduleDefinitions as x, RunSchedulesOptions as y };

package/dist/react/index.d.ts

@@ -1,8 +1,12 @@
-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 { t as escapeLike } from "../escape-like-ImTK0ps_.js";
+import { s as Impersonator } from "../mfa-Daak8ukG.js";
+import { t as tenantOf } from "../tenant-icPeuUBN.js";
+import { t as AuthSession } from "../view-DbxLNu8L.js";
+import { r as LiveCountSeed } from "../index-DunNRdnT.js";
+import { r as MembershipClaim } from "../entitlements-DHrY2UDZ.js";
+import { n as supportOf, t as SupportView } from "../support-view-33Oi07TT.js";
+import { a as BroadcastOptions, f as UseActionOptions, l as LiveQueryHookOptions, n as ActionInputOf, o as ClientLike, r as ActionResultOf, s as LiveCountHookOptions, t as fieldErrorsOf } from "../field-errors-BFOa7WhB.js";
+import { A as useLiveCount, C as BetterSupabaseProviderProps, D as createHooks, E as ProfileOf, M as useSupabase, O as useAuth, S as BetterSupabaseProvider, T as LiveCount, _ as ActionHandle, a as UploadTarget, b as useActionForm, c as useUpload, d as useDebouncedSearch, f as Presence, g as ActionForm, h as usePresence, i as UploadStatus, j as useLiveQuery, k as useBroadcast, l as DebouncedSearch, m as PresenceTopic, n as SignedUrlSource, o as UseUploadOptions, p as PresenceHookOptions, r as Upload, s as useSignedUrl, t as SignedUrl, u as DebouncedSearchOptions, v as UseActionFormOptions, w as ClaimsOf, x as BetterHooks, y as useAction } from "../index-CtuakVRc.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 };
+import { a as useSignIn, i as SignOut, n as PendingState, o as useSignOut, r as SignIn, t as AuthHookOptions } from "../sign-in-BCV5S2WZ.js";
+export { type ActionForm, type ActionHandle, type ActionInputOf, type ActionResultOf, type AuthHookOptions, type AuthSession, type BetterHooks, BetterSupabaseProvider, type BetterSupabaseProviderProps, type BroadcastOptions, type ClaimsOf, type ClientLike, type DebouncedSearch, type DebouncedSearchOptions, type Impersonator, type LiveCount, type LiveCountHookOptions, type LiveCountSeed, type LiveQueryHookOptions, type MembershipClaim, type PendingState, type Presence, type PresenceHookOptions, type PresenceTopic, type ProfileOf, SessionProvider, type SessionProviderProps, type SignIn, type SignOut, type SignedUrl, type SignedUrlSource, type SupportView, type Upload, type UploadStatus, type UploadTarget, type UseActionFormOptions, type UseActionOptions, type UseUploadOptions, createHooks, escapeLike, fieldErrorsOf, supportOf, tenantOf, useAction, useActionForm, useAuth, useBroadcast, useDebouncedSearch, useLiveCount, useLiveQuery, usePresence, useSession, useSignIn, useSignOut, useSignedUrl, useSupabase, useSupportSession, useUpload };

package/dist/react/index.js

@@ -1,6 +1,10 @@
 "use client";
+import { t as escapeLike } from "../escape-like-DHfx6jRr.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, supportOf, useAuth, useBroadcast, useLiveCount, useLiveQuery, useNotifications, useSession, useSupabase, useSupportSession };
+import { a as useBroadcast, c as useLiveQuery, i as useAuth, l as useSupabase, r as createHooks, s as useLiveCount, t as BetterSupabaseProvider } from "../hooks-1BTCJsiw.js";
+import { t as fieldErrorsOf } from "../field-errors-VF1yb8yI.js";
+import { a as useAction, i as usePresence, n as useUpload, o as useActionForm, r as useDebouncedSearch, t as useSignedUrl } from "../react-F80mF4-t.js";
+import { t as tenantOf } from "../tenant-I1TEZ_BX.js";
+import { n as useSignIn, r as useSignOut } from "../sign-in-Cb1mwv6X.js";
+export { BetterSupabaseProvider, SessionProvider, createHooks, escapeLike, fieldErrorsOf, supportOf, tenantOf, useAction, useActionForm, useAuth, useBroadcast, useDebouncedSearch, useLiveCount, useLiveQuery, usePresence, useSession, useSignIn, useSignOut, useSignedUrl, useSupabase, useSupportSession, useUpload };

package/dist/react/native/index.d.ts

@@ -0,0 +1,116 @@
+import { t as AuthSnapshot } from "../../bind-Bu_ZNa3W.js";
+import { a as OAuthSignInOptions, i as OAuthClient, n as AuthLinkClient, o as WebBrowserLike, r as AuthLinkResult, t as AuthFailure } from "../../auth-link-BjFPqwLz.js";
+import { n as PendingState } from "../../sign-in-BCV5S2WZ.js";
+import { Provider } from "@supabase/supabase-js";
+import { ReactNode } from "react";
+//#region src/react/native/index.d.ts
+interface IdTokenClient {
+  readonly auth: {
+    signInWithIdToken(credentials: {
+      provider: string;
+      token: string;
+      nonce?: string;
+      access_token?: string;
+    }): Promise<{
+      readonly error: AuthFailure | null;
+    }>;
+  };
+}
+export interface UseOAuthOptions extends OAuthSignInOptions {
+  /** `expo-web-browser`. */
+  readonly browser: WebBrowserLike;
+  /** A supabase-js client for apps without `<BetterSupabaseProvider>`. */
+  readonly client?: OAuthClient & IdTokenClient;
+  readonly onSuccess?: () => void;
+}
+export interface OAuth extends PendingState {
+  /** Opens the provider in an auth session and finishes the sign-in. A cancelled browser is no error. */
+  readonly signIn: (provider: Provider) => Promise<AuthFailure | undefined>;
+  /**
+   * Native sign-in with an ID token from `expo-apple-authentication` or
+   * `@react-native-google-signin/google-signin`.
+   */
+  readonly idToken: (credentials: {
+    readonly provider: "apple" | "google" | (string & {});
+    readonly token: string;
+    readonly nonce?: string;
+    readonly accessToken?: string;
+  }) => Promise<AuthFailure | undefined>;
+}
+/**
+ * OAuth and native ID-token sign-in on a device, with `pending` and
+ * `error` state.
+ *
+ * ```tsx
+ * import * as WebBrowser from 'expo-web-browser';
+ * const oauth = useOAuth({ browser: WebBrowser, redirectTo: Linking.createURL('auth/callback') });
+ * <Button title="GitHub" disabled={oauth.pending} onPress={() => oauth.signIn('github')} />
+ * ```
+ */
+export declare function useOAuth(options: UseOAuthOptions): OAuth;
+/** The part of React Native's `Linking` that `useAuthDeepLinks` uses. */
+export interface LinkingLike {
+  getInitialURL(): Promise<string | null>;
+  addEventListener(type: "url", listener: (event: {
+    readonly url: string;
+  }) => void): {
+    remove(): void;
+  };
+}
+export interface AuthDeepLinksOptions {
+  readonly client?: AuthLinkClient;
+  /** Called with each auth link's outcome, e.g. to navigate after a magic link. */
+  readonly onResult?: (result: Exclude<AuthLinkResult, {
+    type: "none";
+  }>) => void;
+}
+/**
+ * Finishes sign-ins from deep links while mounted: the URL that opened the
+ * app and every link after it (magic links, email confirmations, OAuth
+ * redirects outside an auth session). Returns the last auth link's outcome.
+ *
+ * ```tsx
+ * import * as Linking from 'expo-linking';
+ * useAuthDeepLinks(Linking, { onResult: (r) => r.type === 'signed-in' && router.replace('/') });
+ * ```
+ */
+export declare function useAuthDeepLinks(linking: LinkingLike, options?: AuthDeepLinksOptions): AuthLinkResult;
+export interface ProtectedRouteOptions {
+  /** `useSegments()` from expo-router. */
+  readonly segments: readonly string[];
+  /** `useRouter()` from expo-router. */
+  readonly router: {
+    replace(href: string): void;
+  };
+  /** The route group signed-out users may see. Defaults to `(auth)`. */
+  readonly publicGroup?: string;
+  /** Defaults to `/sign-in`. */
+  readonly signInHref?: string;
+  /** Where a signed-in user on a public screen goes. Defaults to `/`. */
+  readonly homeHref?: string;
+}
+/**
+ * Redirects with expo-router: signed-out users outside the public group go
+ * to `signInHref`, signed-in users inside it go to `homeHref`. Returns the
+ * auth state; render a splash screen while it is `loading`.
+ *
+ * ```tsx
+ * const status = useProtectedRoute({ segments: useSegments(), router: useRouter() });
+ * ```
+ */
+export declare function useProtectedRoute(options: ProtectedRouteOptions): AuthSnapshot["status"];
+export interface AuthGateProps {
+  /** Shown while the session loads. Defaults to nothing. */
+  readonly fallback?: ReactNode;
+  /** Shown to signed-out users, e.g. the sign-in screen. */
+  readonly signedOut?: ReactNode;
+  readonly children?: ReactNode;
+}
+/**
+ * Renders `children` for signed-in users, `signedOut` otherwise, and
+ * `fallback` while the session loads. With expo-router, `Stack.Protected`
+ * takes `useAuth().status === 'signed-in'` as its `guard` instead.
+ */
+export declare function AuthGate(props: AuthGateProps): ReactNode;
+//#endregion
+export type { AuthFailure, AuthLinkResult, OAuthSignInOptions, WebBrowserLike };