better-supabase 0.14.0 → 0.15.0

package/dist/inbox-NDKwSk_H.d.ts

@@ -0,0 +1,321 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-CRpAHrp_.js";
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+import { p as MessageReaction } from "./messaging-C_Pr9tGx.js";
+import { S as StoredInboundEvent, a as ConversationEvent, b as PurgedContact, c as DeliveryStatus, d as InboxCounts, f as InboxFileSource, h as InboxUpload, i as Conversation, l as InboundResult, m as InboxRow, n as BotMode, o as ConversationPriority, p as InboxMessage, r as Contact, s as ConversationStatus, u as InboxChannel, v as MessageTemplate, x as ScheduledInboxMessage, y as PendingInboxFile } from "./types-Dp3UCr1e.js";
+//#region src/blocks/inbox/inbox.d.ts
+interface InboxOptions extends BlockTemporalOptions {
+  /**
+   * `sqlTransport(postgres.asUser(claims))` or `rpcTransport(supabase)` for a
+   * member or a contact; over the service role for webhooks and workers.
+   */
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around the methods (ADR 0015). */
+  readonly hooks?: InboxHooks;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+interface CreateInboxInput {
+  readonly tenant: string;
+  readonly name: string;
+  readonly channel?: InboxChannel;
+  /** The channel's address: a phone number, a Slack team id, an email. */
+  readonly address?: string;
+  readonly botMode?: BotMode;
+  /**
+   * `widget: true` lets signed-in visitors open conversations in an in-app
+   * inbox.
+   */
+  readonly settings?: Readonly<Record<string, unknown>>;
+}
+interface InboxPatch {
+  readonly name?: string;
+  readonly botMode?: BotMode;
+  readonly settings?: Readonly<Record<string, unknown>>;
+  readonly address?: string | null;
+  readonly installationId?: string | null;
+  readonly archived?: boolean;
+}
+interface ContactInput {
+  readonly id?: string;
+  readonly userId?: string;
+  readonly name?: string;
+  readonly email?: string;
+  readonly phone?: string;
+  readonly avatarUrl?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /** The contact's id on a channel, such as a WhatsApp number. */
+  readonly identity?: {
+    readonly channel: string;
+    readonly externalId: string;
+  };
+}
+interface MessageInput {
+  readonly body: string;
+  /** `note` is an internal note only staff see. */
+  readonly kind?: "message" | "note";
+  readonly format?: "text" | "markdown";
+  /** Ids from `messages.createUpload`, uploaded by the caller. */
+  readonly attachments?: readonly string[];
+  /**
+   * For the service: files that arrived on a channel. Each becomes a pending
+   * attachment for `files.pending()`.
+   */
+  readonly files?: readonly InboxFileSource[];
+  /** User ids; those who cannot read the inbox are dropped. */
+  readonly mentions?: readonly string[];
+  readonly replyTo?: string;
+  readonly externalId?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /** For the service: who writes. Defaults to `bot`. */
+  readonly authorType?: "contact" | "bot" | "system";
+  /**
+   * For the service: the caller posts to the channel itself, so no outbound job
+   * is queued.
+   */
+  readonly deliveredByCaller?: boolean;
+}
+/** What a scheduled reply carries: a message without the service's fields. */
+type ScheduledMessageInput = Pick<MessageInput, "body" | "format" | "attachments" | "mentions" | "replyTo" | "metadata">;
+interface StartConversationInput {
+  /**
+   * A contact id or the fields to find or create one. Leave it out on a widget
+   * inbox to open the conversation as the signed-in visitor, staff included.
+   */
+  readonly contact?: string | ContactInput;
+  readonly subject?: string;
+  readonly priority?: ConversationPriority;
+  readonly botMode?: BotMode;
+  /** The Chat SDK thread id. Defaults to `inbox:<conversation id>`. */
+  readonly threadId?: string;
+  readonly assigneeId?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  readonly message?: string | MessageInput;
+}
+interface InboundInput {
+  readonly inboxId: string;
+  readonly threadId: string;
+  readonly contact: ContactInput & {
+    /** Shorthand for `identity` on the inbox's channel. */
+    readonly externalId?: string;
+  };
+  readonly message: Omit<MessageInput, "kind" | "authorType" | "attachments">;
+  readonly subject?: string;
+  /** `outbound` records a message sent from the platform by someone else. */
+  readonly direction?: "inbound" | "outbound";
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface ConversationFilter extends CursorPageOptions<Pick<Conversation, "id" | "lastMessageAt">> {
+  readonly inboxId?: string;
+  /** Defaults to `open`. */
+  readonly status?: ConversationStatus | "all";
+  readonly assignee?: "me" | "unassigned" | (string & {});
+  readonly teamId?: string;
+  readonly contactId?: string;
+  readonly search?: string;
+  /** The last item of the previous page. */
+  readonly cursor?: Pick<Conversation, "id" | "lastMessageAt">;
+  /** Up to 200. Defaults to 50. */
+  readonly limit?: number;
+}
+interface TemplateInput {
+  readonly name: string;
+  readonly channel: string;
+  readonly body: string;
+  readonly language?: string;
+  readonly inboxId?: string;
+  readonly variables?: readonly string[];
+  readonly externalId?: string;
+}
+/** The `inbox` SQL module as typed calls. */
+/** Hooks for `Inbox`: the top-level methods, and each group's under its name. */
+type InboxHooks = BlockHooks<Inbox> & {
+  readonly inboxes?: BlockHooks<Inbox["inboxes"]>;
+  readonly contacts?: BlockHooks<Inbox["contacts"]>;
+  readonly conversations?: BlockHooks<Inbox["conversations"]>;
+  readonly messages?: BlockHooks<Inbox["messages"]>;
+  readonly files?: BlockHooks<Inbox["files"]>;
+  readonly deliveries?: BlockHooks<Inbox["deliveries"]>;
+  readonly templates?: BlockHooks<Inbox["templates"]>;
+  readonly inbound?: BlockHooks<Inbox["inbound"]>;
+};
+interface Inbox {
+  readonly inboxes: {
+    create(input: CreateInboxInput): AsyncResult<InboxRow>;
+    update(id: string, patch: InboxPatch): AsyncResult<InboxRow>;
+    /** `null` removes the member. */
+    setMember(inboxId: string, userId: string, role: "agent" | "lead" | null): AsyncResult<boolean>;
+    createTeam(tenant: string, name: string): AsyncResult<{
+      readonly id: string;
+      readonly name: string;
+    }>;
+    setTeamMember(teamId: string, userId: string, present?: boolean): AsyncResult<boolean>;
+  };
+  readonly contacts: {
+    /**
+     * Finds the contact by id, identity, user or email, filling in what is
+     * missing.
+     */
+    upsert(tenant: string, input: ContactInput): AsyncResult<Contact>;
+  };
+  readonly conversations: {
+    open(inboxId: string, input?: StartConversationInput): AsyncResult<Conversation>;
+    list(tenant: string | null, filter?: ConversationFilter): AsyncResult<readonly Conversation[]>;
+    get(conversationId: string): AsyncResult<Conversation | null>;
+    assign(conversationId: string, to: {
+      readonly assigneeId: string | null;
+      readonly teamId?: string | null;
+    }): AsyncResult<Conversation>;
+    setStatus(conversationId: string, status: ConversationStatus, options?: {
+      readonly snoozedUntil?: Temporal.Instant;
+    }): AsyncResult<Conversation>;
+    snooze(conversationId: string, until: Temporal.Instant): AsyncResult<Conversation>;
+    resolve(conversationId: string): AsyncResult<Conversation>;
+    reopen(conversationId: string): AsyncResult<Conversation>;
+    /** Hands a bot conversation to staff (`bot_mode = 'human'`) and tells them. */
+    handoff(conversationId: string, reason?: string): AsyncResult<Conversation>;
+    setBotMode(conversationId: string, mode: BotMode, reason?: string): AsyncResult<Conversation>;
+    markRead(conversationId: string): AsyncResult<Temporal.Instant>;
+    /**
+     * A typing ping on the conversation's messaging topic; the service names
+     * the bot in `actor`.
+     */
+    typing(conversationId: string, typing?: boolean, actor?: string): AsyncResult<boolean>;
+    events(conversationId: string): AsyncResult<readonly ConversationEvent[]>;
+    counts(tenant: string): AsyncResult<InboxCounts>;
+  };
+  readonly messages: {
+    send(conversationId: string, input: MessageInput): AsyncResult<InboxMessage>;
+    /** An internal note only staff see. */
+    note(conversationId: string, body: string, input?: Pick<MessageInput, "mentions" | "attachments" | "format">): AsyncResult<InboxMessage>;
+    list(conversationId: string, options?: CursorPageOptions<Temporal.Instant>): AsyncResult<readonly InboxMessage[]>;
+    get(messageId: string): AsyncResult<InboxMessage | null>;
+    edit(messageId: string, body: string): AsyncResult<InboxMessage>;
+    /** Leaves a tombstone with an empty body and deletes its attachments. */
+    remove(messageId: string): AsyncResult<InboxMessage>;
+    /** Needs the `reactions` module; returns the message's reactions. */
+    react(messageId: string, emoji: string, options?: {
+      readonly present?: boolean;
+      readonly actor?: string;
+    }): AsyncResult<readonly MessageReaction[]>;
+    /**
+     * A pending attachment on the conversation to upload a file to. Upload it
+     * to `bucket` at `path`, call `confirmUpload`, then pass its id in
+     * `attachments`.
+     */
+    createUpload(conversationId: string, file: {
+      readonly name: string;
+      readonly mimeType?: string;
+      readonly size?: number;
+    }): AsyncResult<InboxUpload>;
+    /** Marks the uploaded file as stored (the `attachments` module). */
+    confirmUpload(attachmentId: string): AsyncResult<void>;
+    /**
+     * Schedules a staff reply for `at` (in the future). It is sent as the
+     * caller when `publishDue` runs after that time; until then only the caller
+     * sees it.
+     */
+    schedule(conversationId: string, input: ScheduledMessageInput, at: Temporal.Instant): AsyncResult<ScheduledInboxMessage>;
+    /**
+     * The caller's scheduled replies, soonest first, on one conversation or
+     * all.
+     */
+    scheduled(conversationId?: string): AsyncResult<readonly ScheduledInboxMessage[]>;
+    /** Moves the caller's scheduled reply to another future time. */
+    reschedule(scheduledId: string, at: Temporal.Instant): AsyncResult<ScheduledInboxMessage>;
+    /** Deletes the caller's scheduled reply before it is sent. */
+    cancelScheduled(scheduledId: string): AsyncResult<void>;
+  };
+  /** Service only: the files that arrived on channels. */
+  readonly files: {
+    /** The channel files to fetch and upload, oldest first. */
+    pending(limit?: number): AsyncResult<readonly PendingInboxFile[]>;
+    /** Confirms a fetched and uploaded file. */
+    stored(attachmentId: string): AsyncResult<void>;
+    /** Gives up on a file the channel no longer serves. */
+    failed(attachmentId: string, detail?: string): AsyncResult<boolean>;
+  };
+  readonly deliveries: {
+    /** Service only: after posting a message on its channel. */
+    record(input: {
+      readonly messageId: string;
+      readonly channel: string;
+      readonly externalId?: string;
+      readonly status?: DeliveryStatus;
+      readonly error?: string;
+    }): AsyncResult<void>;
+    /** Service only: a status callback; returns how many deliveries moved. */
+    setStatus(input: {
+      readonly channel: string;
+      readonly externalId: string;
+      readonly status: DeliveryStatus;
+      readonly error?: string;
+    }): AsyncResult<number>;
+  };
+  readonly templates: {
+    upsert(tenant: string, input: TemplateInput): AsyncResult<MessageTemplate>;
+    delete(id: string): AsyncResult<boolean>;
+  };
+  /** Service only: channel messages, the webhook store and its sweeps. */
+  readonly inbound: {
+    /**
+     * A message that arrived on a channel: finds or opens the thread's
+     * conversation.
+     */
+    record(input: InboundInput): AsyncResult<InboundResult>;
+    store(input: {
+      readonly adapter: string;
+      readonly body: string;
+      readonly externalId?: string;
+      readonly headers?: Readonly<Record<string, string>>;
+      readonly inboxId?: string;
+      readonly tenant?: string;
+    }): AsyncResult<{
+      readonly id: string;
+      readonly duplicate: boolean;
+    }>;
+    setStatus(id: string, status: "processing" | "processed" | "ignored" | "failed", error?: string): AsyncResult<boolean>;
+    pending(options?: {
+      readonly limit?: number;
+      readonly maxAttempts?: number;
+    }): AsyncResult<readonly StoredInboundEvent[]>;
+    purge(options?: {
+      readonly olderThan?: number | string;
+      readonly batch?: number;
+    }): AsyncResult<number>;
+  };
+  /**
+   * Service only: reopens snoozed conversations whose time came, with the
+   * `inbox_conversation.unsnoozed` event and a notification. Returns the
+   * count.
+   */
+  wakeSnoozed(): AsyncResult<number>;
+  /**
+   * Service only: sends the scheduled replies whose time came, as their
+   * authors. Returns the number sent.
+   */
+  publishDue(maxRows?: number): AsyncResult<number>;
+  /**
+   * Erases a contact and its conversations for a data subject request
+   * (`inbox.manage` or the service). Remove the returned Storage objects
+   * afterwards.
+   */
+  purgeContact(contactId: string): AsyncResult<PurgedContact>;
+}
+/**
+ * The `inbox` SQL module as typed calls: inboxes, contacts, conversations,
+ * messages and notes, assignment, bot hand-off, read state, deliveries and the
+ * stored webhook events. The database checks every permission.
+ */
+declare function createInbox(options: InboxOptions): Inbox;
+//#endregion
+export { Inbox as a, InboxPatch as c, StartConversationInput as d, TemplateInput as f, InboundInput as i, MessageInput as l, ConversationFilter as n, InboxHooks as o, createInbox as p, CreateInboxInput as r, InboxOptions as s, ContactInput as t, ScheduledMessageInput as u };

package/dist/index-B938YqY-.d.ts

@@ -0,0 +1,188 @@
+import { b as DbError, f as Result } from "./result-DZeA5KS6.js";
+import { $ as RecordRef, ot as SchemaMeta } from "./types-DFdg_4yN.js";
+import { pt as QuerySpec } from "./define-DFBnQyYg.js";
+import { t as DataChanges } from "./data-engine-BWoz9lED.js";
+import { c as RealtimeClient, m as Topic, p as SubscriptionStatus } from "./topic-CJrQZQaa.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/realtime/subject-presence.d.ts
+/** The presence topic template; the subjects module's policies authorize it. */
+declare const SUBJECT_PRESENCE_TEMPLATE = "presence:{subjectType}:{subjectId}";
+type SubjectPresenceTopic<R extends boolean | StandardSchemaV1 = true> = Topic<typeof SUBJECT_PRESENCE_TEMPLATE, Record<never, never>, R>;
+/**
+ * The presence topic of a record, `presence:<type>:<id>`: who has it open.
+ * Anyone who can read the subject (`can_subject(type, id, 'read')`) joins it,
+ * so a channel uses its `conversation` subject, a comment thread its record and
+ * a document its own subject. Pass a schema to validate the tracked states.
+ *
+ * Presence states come from the clients, so show them as hints (a name, an
+ * avatar, a cursor) and never decide access on them.
+ */
+declare function subjectPresenceTopic<S extends StandardSchemaV1>(schema: S): SubjectPresenceTopic<S>;
+declare function subjectPresenceTopic(): SubjectPresenceTopic;
+/** `subjectPresenceTopic()` without a schema. */
+declare const subjectPresence: SubjectPresenceTopic;
+interface SubjectPresenceValues {
+  readonly subjectType: string;
+  readonly subjectId: string;
+}
+/**
+ * The topic values of a subject for `usePresence` and the bindings; `null` (no
+ * subject yet) pauses the join.
+ *
+ * ```tsx
+ * const { members } = usePresence(
+ *   subjectPresence,
+ *   subjectPresenceValues({ type: "conversation", id: conversationId }),
+ *   { state: { name, avatarUrl } },
+ * );
+ * ```
+ */
+declare function subjectPresenceValues(subject: RecordRef | null | undefined): SubjectPresenceValues | null;
+//#endregion
+//#region src/realtime/live.d.ts
+/**
+ * What `liveQuery` needs from `betterSupabase`: metadata and the tables a spec
+ * reads.
+ */
+interface LiveSource {
+  readonly meta: SchemaMeta;
+  tablesOf(spec: QuerySpec): string[];
+}
+interface LiveQueryOptions {
+  /**
+   * Called once per burst of changes, with the app keys of the tables that
+   * changed.
+   */
+  readonly onChange: (tables: readonly string[]) => void;
+  /**
+   * Tenant value for tables scoped by a tenant column (`realtime-tables`
+   * topics).
+   */
+  readonly tenant?: string;
+  /**
+   * The signed-in user's id, for tables that broadcast per user
+   * (`realtime.users`).
+   */
+  readonly user?: string;
+  /**
+   * Waits this long after the last change before calling `onChange`. Defaults
+   * to 100 ms.
+   */
+  readonly debounceMs?: number;
+  /**
+   * Also reports a channel that errors after it joined (`error`) and its rejoin
+   * (`subscribed`), not only the first join.
+   */
+  readonly onStatus?: (status: SubscriptionStatus, error?: Error) => void;
+  /**
+   * Retries a first join that failed, after 1 s and then twice as long each
+   * time, up to 30 s. Pass `false` to stay in `error`. Defaults to `true`.
+   */
+  readonly retry?: boolean;
+}
+interface LiveSubscription extends Disposable, AsyncDisposable {
+  /** App keys of the watched tables. */
+  readonly tables: readonly string[];
+  /**
+   * Tables the query reads that don't broadcast changes (not in
+   * `realtime.tables`).
+   */
+  readonly unwatched: readonly string[];
+  readonly ready: Promise<void>;
+  unsubscribe(): Promise<void>;
+}
+/**
+ * A count from the server plus the spec to keep it live on the client:
+ * `bsb.liveCount(spec)` makes one, `useLiveCount(seed)` reads it. `count` is
+ * `null` when the server read failed; the client then fetches it.
+ */
+interface LiveCountSeed<T extends string = string> {
+  readonly spec: QuerySpec<T, "count", number>;
+  readonly count: number | null;
+  /**
+   * When the count was taken (epoch ms). `useLiveCount` counts again after
+   * joining when it is older than a second.
+   */
+  readonly at?: number;
+}
+/**
+ * Topic a `realtime-tables` trigger broadcasts on:
+ * `bsb:t:<schema>.<table>[:<tenant>]`, or `bsb:t:<schema>.<table>:u:<user>` for
+ * a `realtime.users` table.
+ */
+declare function liveTopic(meta: SchemaMeta, table: string, tenant?: string, user?: string): string;
+/**
+ * Calls `onChange` when a table the spec reads changes, so you can refetch.
+ * Needs the `realtime-tables` SQL module and the tables in `realtime.tables`.
+ * Live queries on the same client share one channel per table, so any number of
+ * them can run at once.
+ *
+ * ```ts
+ * using live = liveQuery(betterSupabase, supabase, spec, {
+ *   onChange: () => refetch(),
+ * });
+ * ```
+ */
+declare function liveQuery(betterSupabase: LiveSource, client: RealtimeClient, spec: QuerySpec | readonly string[], options: LiveQueryOptions): LiveSubscription;
+/**
+ * What `liveCount` runs the spec with: a `db` from `betterSupabase.connect()`
+ * or `createClient()`.
+ */
+interface CountRunner {
+  $run(spec: QuerySpec): PromiseLike<Result<unknown>>;
+}
+interface LiveCountOptions extends Omit<LiveQueryOptions, "onChange"> {
+  readonly onCount: (count: number) => void;
+  /** A failed refetch; the previous count stays valid. */
+  readonly onError?: (error: DbError) => void;
+  /** Count right away. Defaults to `true`; pass `false` when you have a seed. */
+  readonly immediate?: boolean;
+  /**
+   * When the count you already have was taken (epoch ms). Counts again once the
+   * channel joins when that is more than a second ago, so a change made before
+   * the join is not lost.
+   */
+  readonly since?: number;
+}
+/**
+ * Keeps a count current: runs the `count` spec (a HEAD request) now, after each
+ * debounced change to a table it reads, and after the channel rejoins.
+ * Responses that arrive out of order are dropped.
+ *
+ * ```ts
+ * using live = liveCount(
+ *   betterSupabase,
+ *   supabase,
+ *   db,
+ *   betterSupabase.spec.notes.count(),
+ *   { onCount: (count) => render(count) },
+ * );
+ * ```
+ */
+declare function liveCount(betterSupabase: LiveSource, client: RealtimeClient, db: CountRunner, spec: QuerySpec<string, "count", number>, options: LiveCountOptions): LiveSubscription;
+interface RealtimeChangesOptions {
+  /** App keys of the tables to follow. Default every table in `realtime.tables`. */
+  readonly tables?: readonly string[];
+  /** Tenant value for tables scoped by a tenant column, read at each subscribe. */
+  readonly tenant?: string | (() => string | undefined);
+  /** The signed-in user's id for per-user tables, read at each subscribe. */
+  readonly user?: string | (() => string | undefined);
+  /** Waits this long after the last change. Defaults to 100 ms. */
+  readonly debounceMs?: number;
+}
+/**
+ * Supabase Realtime changes for an engine's `live` option: the data hooks read
+ * a source again when another client changes its table. It joins while a hook
+ * follows a read and leaves after the last one.
+ *
+ * ```ts
+ * export const bsb = createClient(betterSupabase, {
+ *   engine: memoryEngine({
+ *     live: realtimeChanges(betterSupabase, supabase),
+ *   }),
+ * });
+ * ```
+ */
+declare function realtimeChanges(betterSupabase: LiveSource, client: RealtimeClient, options?: RealtimeChangesOptions): DataChanges;
+//#endregion
+export { subjectPresenceValues as _, LiveSource as a, liveCount as c, realtimeChanges as d, SUBJECT_PRESENCE_TEMPLATE as f, subjectPresenceTopic as g, subjectPresence as h, LiveQueryOptions as i, liveQuery as l, SubjectPresenceValues as m, LiveCountOptions as n, LiveSubscription as o, SubjectPresenceTopic as p, LiveCountSeed as r, RealtimeChangesOptions as s, CountRunner as t, liveTopic as u };

package/dist/index-BUuVq1co.d.ts

@@ -0,0 +1,158 @@
+import { t as AsyncResult } from "./result-DZeA5KS6.js";
+import { O as AnyFunctions, k as AnyModels } from "./types-DFdg_4yN.js";
+import { l as PublicEnv } from "./index-NRMMhhEi.js";
+import { g as SessionEncoding } from "./resolve-CXX6DHv3.js";
+import { t as BetterSupabase } from "./define-DFBnQyYg.js";
+import { i as KeyboardPort, l as StoragePort, n as DeepLinkPort, r as FilePickerPort, s as PushTokenPort, t as ClientPorts } from "./ports-sx226JUL.js";
+import { i as BindClientOptions, r as BetterClient } from "./bind-CrMBwrPN.js";
+import { n as FunctionContract } from "./function-contract-DxFNOmsm.js";
+import { FunctionInvokeOptions, SupabaseClient, SupabaseClientOptions } from "@supabase/supabase-js";
+//#region src/client/functions.d.ts
+/**
+ * `supabase.functions.invoke` options, without the body: `invoke` sends the
+ * input.
+ */
+type InvokeOptions = Omit<FunctionInvokeOptions, "body">;
+/** Edge Function contracts by function name. */
+type FunctionContracts = Readonly<Record<string, FunctionContract>>;
+/** Anything with supabase-js's `functions` client, e.g. a `SupabaseClient`. */
+interface FunctionsHost {
+  readonly functions: {
+    invoke(name: string, options?: FunctionInvokeOptions): Promise<{
+      data: unknown;
+      error: unknown;
+      response?: Response;
+    }>;
+  };
+}
+interface TypedFunctions<Contracts extends FunctionContracts> {
+  /**
+   * Calls the function with `input` as the JSON body. Problem Details from the
+   * function come back as their `DbError`; a network or relay failure is a
+   * `network` error.
+   */
+  invoke<N extends keyof Contracts & string>(name: N, ...[input, options]: undefined extends Contracts[N]["input"] ? [input?: Contracts[N]["input"], options?: InvokeOptions] : [input: Contracts[N]["input"], options?: InvokeOptions]): AsyncResult<Contracts[N]["output"]>;
+}
+/**
+ * Typed Edge Function calls over supabase-js's `functions` client. The
+ * contracts come from the functions' own code, imported as types:
+ *
+ * ```ts
+ * import type { SendInvite } from "../supabase/functions/send-invite/index.ts";
+ *
+ * const fns = functions<{ "send-invite": SendInvite }>(supabase);
+ * const invite = await fns.invoke("send-invite", { email }).orThrow();
+ * ```
+ */
+declare function functions<Contracts extends FunctionContracts>(host: FunctionsHost): TypedFunctions<Contracts>;
+//#endregion
+//#region src/client/web-ports.d.ts
+/** The part of a `ServiceWorkerRegistration` the push token port uses. */
+interface PushRegistrationLike {
+  readonly pushManager: {
+    getSubscription(): Promise<unknown>;
+    subscribe(options: {
+      readonly userVisibleOnly: boolean;
+      readonly applicationServerKey: Uint8Array<ArrayBuffer>;
+    }): Promise<unknown>;
+  };
+}
+/**
+ * The storage port over `localStorage` (or `sessionStorage`). Reads resolve
+ * with `null` and writes do nothing where storage is missing or blocked.
+ */
+declare function webStorage(kind?: "local" | "session"): StoragePort;
+/** The keyboard port over `keydown` on `window`; `mod` matches Cmd and Ctrl. */
+declare function webKeyboard(): KeyboardPort;
+/** The file picker port over a hidden `<input type="file">`. */
+declare function webFilePicker(): FilePickerPort;
+/** The deep link port over `location`, `popstate` and `hashchange`. */
+declare function webDeepLinks(): DeepLinkPort;
+interface WebPushTokenOptions {
+  /** The VAPID public key, base64url-encoded. */
+  readonly vapidPublicKey: string;
+  /**
+   * The service worker that receives the pushes. Default
+   * `navigator.serviceWorker.ready`.
+   */
+  readonly registration?: () => Promise<PushRegistrationLike>;
+}
+/**
+ * The push token port over the Push API: the token is the JSON of the browser's
+ * push subscription, which a Web Push sender needs.
+ */
+declare function webPushToken(options: WebPushTokenOptions): PushTokenPort;
+/**
+ * The web ports `createClient` uses: storage, the keyboard, the file picker and
+ * deep links.
+ */
+declare function webPorts(): ClientPorts;
+//#endregion
+//#region src/client/index.d.ts
+interface ClientOptions {
+  /** URL and publishable key. Not needed when `client` is given. */
+  readonly env?: PublicEnv;
+  /**
+   * Bring your own supabase-js client (custom storage). React Native apps use
+   * `better-supabase/client/native`, which doesn't load `@supabase/ssr`.
+   */
+  readonly client?: SupabaseClient;
+  /**
+   * `cookies` (default) shares the session with the server through
+   * `@supabase/ssr`; `local` keeps it in localStorage for SPAs without a
+   * server.
+   */
+  readonly storage?: "cookies" | "local";
+  readonly cookies?: {
+    /**
+     * `tokens-only` keeps the user object out of the cookie (it lives in
+     * `auth.userStorage`, localStorage by default), so cookies stay small. Use
+     * the same value as the server's `encode`. Defaults to `user-and-tokens`.
+     */
+    readonly encode?: SessionEncoding;
+  };
+  readonly auth?: {
+    /** Where auth-js keeps the user object with `cookies.encode: 'tokens-only'`. */
+    readonly userStorage?: UserStorage;
+  };
+  /**
+   * `staleTime` for every query option in `bsb.queries`. Above zero, a remount
+   * or a window focus reuses cached rows instead of refetching.
+   */
+  readonly staleTime?: number;
+  /**
+   * Platform services for the block hooks, over the web defaults (`webPorts()`
+   * and an upload port over Supabase Storage).
+   */
+  readonly ports?: ClientPorts;
+  /**
+   * `blockConfig` from `blocks.generated.ts`: the block hooks call the schema,
+   * function names and topics `gen` wrote.
+   */
+  readonly blocks?: BindClientOptions["blocks"];
+  /**
+   * The organization `db` and the hooks act in; default the session's
+   * organization claim. Pass a function for one picked in the UI.
+   */
+  readonly organization?: BindClientOptions["organization"];
+  /**
+   * Where the data hooks keep their reads: `queryEngine(queryClient)` from
+   * `better-supabase/query`, an engine over a local database, or one in memory
+   * by default.
+   */
+  readonly engine?: BindClientOptions["engine"];
+}
+type UserStorage = NonNullable<NonNullable<SupabaseClientOptions<"public">["auth"]>["userStorage"]>;
+/**
+ * The browser side: a supabase-js client, repositories that follow the session,
+ * TanStack Query options and an auth store for UI state.
+ *
+ * ```ts
+ * export const bsb = createClient(betterSupabase, {
+ *   env: { url, publishableKey },
+ * });
+ * ```
+ */
+declare function createClient$1<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P, B>, options?: ClientOptions): BetterClient<M, F, E, C, P, B>;
+//#endregion
+export { webDeepLinks as a, webPorts as c, FunctionContracts as d, FunctionsHost as f, functions as h, WebPushTokenOptions as i, webPushToken as l, TypedFunctions as m, createClient$1 as n, webFilePicker as o, InvokeOptions as p, PushRegistrationLike as r, webKeyboard as s, ClientOptions as t, webStorage as u };