better-supabase 0.13.0 → 0.15.0

package/dist/stripe-X22LjuH-.d.ts

@@ -0,0 +1,156 @@
+//#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 customer_account?: 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>;
+    };
+  };
+  /**
+   * Stripe's v2 API. `billing` with `customerAccounts` creates the tenant's
+   * Accounts v2 account through it.
+   */
+  readonly v2?: {
+    readonly core: {
+      readonly accounts: {
+        create(params: Readonly<Record<string, unknown>>, options?: {
+          readonly idempotencyKey?: string;
+        }): Promise<{
+          readonly id: string;
+        }>;
+      };
+    };
+  };
+  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, a function that returns a client (`stripeFromKey()` from
+ * `better-supabase/stripe` in a bundled app), or the secret key to create one
+ * from the `stripe` package: the plain Node shortcut, which needs a runtime
+ * that resolves `stripe` when the call runs. 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.
+ * `C` is the part of the SDK the caller uses (`StripeClient` for billing and
+ * usage).
+ */
+type StripeSource<C extends object = StripeClient> = C | {
+  readonly secretKey: string;
+  readonly apiVersion?: string;
+} | (() => C | Promise<C>);
+//#endregion
+export { StripeSource as n, StripeTaxId as r, StripeClient as t };

package/dist/subject-readers-B-pQ9Mmo.js

@@ -0,0 +1,49 @@
+import "./block-helpers-CtBdjgO4.js";
+//#region src/core/subject-readers.ts
+/**
+* A registered subject's type and id, from `subjects/<type>/<id>` or
+* `<type>/<id>`.
+*/
+function parseSubject(subject, types) {
+	const rest = subject.startsWith("subjects/") ? subject.slice(9) : subject;
+	const slash = rest.indexOf("/");
+	if (slash <= 0 || slash === rest.length - 1) return;
+	const type = rest.slice(0, slash);
+	return types.has(type) ? {
+		type,
+		id: rest.slice(slash + 1)
+	} : void 0;
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* The default subscriber policy under an authorization provider: a subscriber
+* gets an event about a subject in `config.records` only when `can_subject_for`
+* says it may `read` the subject (the key in
+* `config.subjects.<type>.permissions`, never a share-link grant). Events
+* without a subject, or about a type the registry doesn't list, keep every
+* subscriber, so the block's own tenant check decides them. `transport` must
+* run as the service role.
+*/
+function subjectReaders(transport, options = {}) {
+	const schema = options.schema ?? "better_supabase";
+	const action = options.action ?? "read";
+	let types;
+	const registered = () => types ??= transport.call(schema, "subject_types", {}).then((value) => new Set(Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [])).catch((cause) => {
+		types = void 0;
+		throw cause;
+	});
+	return async (event, subscribers) => {
+		if (typeof event.subject !== "string" || subscribers.length === 0) return subscribers;
+		const subject = parseSubject(event.subject, await registered());
+		if (subject === void 0) return subscribers;
+		const allowed = await Promise.all(subscribers.map(async (subscriber) => UUID.test(subscriber.principal) ? await transport.call(schema, "can_subject_for", {
+			member: subscriber.principal,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			action
+		}) === true : false));
+		return subscribers.filter((_, index) => allowed[index]);
+	};
+}
+//#endregion
+export { subjectReaders as t };

package/dist/subject-readers-BNSzkqw_.d.ts

@@ -0,0 +1,21 @@
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+import { g as SubscriberPolicy } from "./authorization-hooks-Cs1vP_ej.js";
+//#region src/core/subject-readers.d.ts
+interface SubjectReadersOptions {
+  /** The schema of the `subjects` module. Default `better_supabase`. */
+  readonly schema?: string;
+  /** The `config.records` action to check. Default `read`. */
+  readonly action?: string;
+}
+/**
+ * The default subscriber policy under an authorization provider: a subscriber
+ * gets an event about a subject in `config.records` only when `can_subject_for`
+ * says it may `read` the subject (the key in
+ * `config.subjects.<type>.permissions`, never a share-link grant). Events
+ * without a subject, or about a type the registry doesn't list, keep every
+ * subscriber, so the block's own tenant check decides them. `transport` must
+ * run as the service role.
+ */
+declare function subjectReaders(transport: BlockTransport, options?: SubjectReadersOptions): SubscriberPolicy;
+//#endregion
+export { subjectReaders as n, SubjectReadersOptions as t };

package/dist/subjects-BpIEN1MS.d.ts

@@ -0,0 +1,90 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "./result-DZeA5KS6.js";
+import { $ as RecordRef } from "./types-DFdg_4yN.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-CRpAHrp_.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+//#region src/blocks/subjects/my-work-kinds.d.ts
+/** What a `my_work` item waits on. */
+type MyWorkKind = "assigned" | "approval" | "reminder" | "mention" | "sla";
+/** The kinds `my_work` returns, in the order the docs list them. */
+declare const MY_WORK_KINDS: readonly MyWorkKind[];
+//#endregion
+//#region src/blocks/subjects/subjects.d.ts
+/** The most refs one `subject_titles` call takes; `resolve` splits above it. */
+declare const SUBJECT_TITLES_LIMIT = 500;
+interface SubjectsOptions extends BlockOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Subjects>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A subject with its title and path, from `config.records`. */
+interface ResolvedSubject extends RecordRef {
+  /** The `title` column's value, when the type names one. */
+  readonly title?: string;
+  /** The `url` template filled in, such as `/customers/42`. */
+  readonly url?: string;
+}
+/** A record page's header and tab badges, from `record_summary`. */
+interface RecordSummary extends ResolvedSubject {
+  /** Rows per section the caller can read, for each installed section asked. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** Per section, whether a row is newer than `seenAt`. */
+  readonly unread: Readonly<Record<string, boolean>>;
+}
+interface RecordSummaryOptions {
+  /** When the caller last saw the record; every section is read without it. */
+  readonly seenAt?: Temporal.Instant | null;
+}
+/** One thing waiting on the caller, from `my_work`. */
+interface MyWorkItem {
+  readonly kind: MyWorkKind;
+  /** The record it is about: the work item, or the approval's subject. */
+  readonly subject: RecordRef;
+  /**
+   * The row that put it here: the work item, approval request, reminder,
+   * comment or SLA clock id.
+   */
+  readonly ref: string;
+  readonly title?: string;
+  readonly url?: string;
+  /** The due date, or when it arrived. */
+  readonly at?: Temporal.Instant;
+}
+/** The most items one `my_work` call returns. */
+declare const MY_WORK_LIMIT = 200;
+interface MyWorkOptions {
+  /** Only this organization's work. Default: every organization. */
+  readonly tenant?: string;
+  /** At most this many items, newest first. Default 50, at most 200. */
+  readonly pageSize?: number;
+}
+/** The subjects block's registry as typed calls. */
+interface Subjects {
+  /**
+   * Titles and paths for many subjects in one call, keyed by `subjectKey`
+   * (`type:id`). A subject the caller can't read, a soft-deleted row or an
+   * unknown type is left out.
+   */
+  resolve(refs: readonly RecordRef[]): AsyncResult<Readonly<Record<string, ResolvedSubject>>>;
+  /**
+   * The subject's title and path with a count and unread state for each of
+   * `sections` (`comments`, `attachments`), in one round trip; `undefined` when
+   * the caller can't read the subject.
+   */
+  summary(subject: RecordRef, sections: readonly string[], options?: RecordSummaryOptions): AsyncResult<RecordSummary | undefined>;
+  /**
+   * What waits on the caller across the installed blocks, newest first: open
+   * work items assigned to them, approvals they can decide, their reminders
+   * sent this week, recent mentions and SLA clocks warned on their work.
+   */
+  myWork(options?: MyWorkOptions): AsyncResult<readonly MyWorkItem[]>;
+}
+/**
+ * The `subjects` module's `subject_titles` as a typed call, for lists and
+ * mentions that show a link to each subject.
+ */
+declare function createSubjects(options: SubjectsOptions): Subjects;
+//#endregion
+export { RecordSummaryOptions as a, Subjects as c, MY_WORK_KINDS as d, MyWorkKind as f, RecordSummary as i, SubjectsOptions as l, MyWorkItem as n, ResolvedSubject as o, MyWorkOptions as r, SUBJECT_TITLES_LIMIT as s, MY_WORK_LIMIT as t, createSubjects as u };

package/dist/subjects-DvmQeF_F.d.ts

@@ -0,0 +1,79 @@
+//#region src/config/types/subjects.d.ts
+/**
+ * One entity the app's blocks attach to (`subjects.<type>`): a task, a
+ * customer, a document. Every subject-bound SQL module reads these entries
+ * unless its own `on` says otherwise. ADR 0020.
+ */
+interface SubjectConfig {
+  /** `schema.table`, or a table in `public`. */
+  readonly table: string;
+  /** The id column. Defaults to `id`. */
+  readonly id?: string;
+  /**
+   * The id column's type, such as `uuid` or `bigint`, so lookups compare on the
+   * primary key's own type. Without it the column is compared as text.
+   */
+  readonly idType?: string;
+  /**
+   * The tenant column. Defaults to `organization_id`, or
+   * `<blocks.memberships.names.organization>_id` when the tenant is renamed.
+   * `false` for a subject without a tenant, which modules that keep a tenant on
+   * every row skip.
+   */
+  readonly tenant?: string | false;
+  /** The column `subject_title` returns. */
+  readonly title?: string;
+  /**
+   * The path `subject_url` returns, with `{column}` placeholders:
+   * `/tasks/{id}`.
+   */
+  readonly url?: string;
+  /**
+   * A permission key per action (`read`, `write`, or an app action) that
+   * `can_subject` checks in the subject's tenant, on top of the row being
+   * visible to the caller. `read` is also the permission modules check before
+   * they attach rows to the subject.
+   */
+  readonly permissions?: Readonly<Record<string, string>>;
+  /**
+   * A scope the authorization provider declares whose ids are this subject's
+   * ids, so a grant on the record counts as well as one on the tenant.
+   */
+  readonly scope?: string;
+  /** Delete module rows for a subject when its row is deleted. */
+  readonly cascade?: boolean;
+  /**
+   * The column holding the soft-delete time. Blocks hide rows where it is set,
+   * metrics skip them, and `gen` makes it the table's `trashExtension()`
+   * column.
+   */
+  readonly deletedAt?: string;
+  /** The columns a search index reads. */
+  readonly search?: {
+    readonly title?: string;
+    readonly body?: readonly string[];
+  };
+  /**
+   * The text column holding the subject's rank key, and the column it is
+   * grouped by (a board stage), for `move()`. ADR 0021.
+   */
+  readonly rank?: {
+    readonly column: string;
+    readonly group?: string;
+  };
+  /**
+   * The columns the versions block snapshots and restores, and whether it
+   * snapshots on each change. An app table's `subject.versions` sets it.
+   */
+  readonly versions?: {
+    readonly columns: readonly string[];
+    readonly auto: boolean;
+  };
+}
+/**
+ * The app's subject types, keyed by type name (lowercase, digits and
+ * underscores).
+ */
+type SubjectsConfig = Readonly<Record<string, SubjectConfig>>;
+//#endregion
+export { SubjectsConfig as n, SubjectConfig as t };

package/dist/summaries-8jQTELIX.d.ts

@@ -0,0 +1,69 @@
+/// <reference lib="esnext.temporal" />
+//#region src/blocks/messaging/summaries.d.ts
+/** What a summary covers: a whole conversation or one thread. */
+type SummaryTarget = {
+  readonly conversationId: string;
+} | {
+  readonly threadId: string;
+};
+/**
+ * A summary of a thread, or of a conversation's top-level messages. `stale`
+ * turns true once a message in it is sent, edited or deleted after it.
+ */
+interface ThreadSummary {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly conversationId: string;
+  /** The thread's root message; `undefined` for a conversation's summary. */
+  readonly threadId: string | undefined;
+  readonly summary: string;
+  /** The model the summarizer named, such as `anthropic/claude-sonnet-4.5`. */
+  readonly model: string | undefined;
+  readonly messageCount: number;
+  /** When the newest summarized message was sent. */
+  readonly throughAt: Temporal.Instant;
+  readonly stale: boolean;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** One message a summarizer reads. */
+interface SummaryMessage {
+  readonly id: string;
+  readonly authorId: string | undefined;
+  /** With the `profiles` module. */
+  readonly authorName: string | undefined;
+  readonly body: string;
+  readonly sentAt: Temporal.Instant;
+}
+interface ThreadSummaryInput {
+  readonly organizationId: string;
+  readonly conversationId: string;
+  readonly threadId: string | undefined;
+  /** Oldest first: the caller's sent messages, without internal notes. */
+  readonly messages: readonly SummaryMessage[];
+  /** The summary saved before, to update instead of starting over. */
+  readonly previous: string | undefined;
+  readonly signal?: AbortSignal;
+}
+interface ThreadSummaryOutput {
+  readonly summary: string;
+  readonly model?: string;
+}
+/**
+ * Writes a summary from a thread's messages. The block calls no model itself:
+ * `summarizeWith(model)` from `better-supabase/ai-sdk` is one, and any object
+ * with this shape is another.
+ */
+interface ThreadSummarizer {
+  readonly apiVersion: 1;
+  summarize(input: ThreadSummaryInput): Promise<ThreadSummaryOutput>;
+}
+interface SummarizeOptions {
+  /** Summarizes again even when the saved summary is current. */
+  readonly force?: boolean;
+  /** The newest messages to read, at most 200. Default 200. */
+  readonly maxMessages?: number;
+  readonly signal?: AbortSignal;
+}
+//#endregion
+export { ThreadSummary as a, ThreadSummarizer as i, SummaryMessage as n, ThreadSummaryInput as o, SummaryTarget as r, ThreadSummaryOutput as s, SummarizeOptions as t };

package/dist/support-view-BYOgwXsJ.d.ts

@@ -0,0 +1,17 @@
+import { t as AuthSession } from "./view-DyFdMCqg.js";
+//#region src/auth/support-view.d.ts
+/** A running support session as the target's view shows it, for a banner. */
+interface SupportView {
+  readonly sessionId: string;
+  /** The admin viewing the app. */
+  readonly adminId: string;
+  readonly targetUserId: string;
+  readonly reason?: string;
+  readonly readOnly: boolean;
+  /** Seconds since epoch. */
+  readonly expiresAt: number | null;
+}
+/** The support session behind `session`, or `undefined` outside one. */
+declare function supportOf(session: AuthSession): SupportView | undefined;
+//#endregion
+export { supportOf as n, SupportView as t };

package/dist/svelte/index.d.ts

@@ -1,12 +1,67 @@
-import { b as DbError } from "../result-mijqfoJN.js";
-import { J as QuerySpec } from "../define-D0LSXmUP.js";
-import { $ as TemplateValues } from "../bucket-DBay-ICp.js";
-import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-CZvLXFND.js";
-import { t as AuthSnapshot } from "../bind-DcXLU1ul.js";
-import { t as AuthSession } from "../view-CKzCp8FW.js";
-import { a as BroadcastOptions, c as LiveCountHookOptions, d as PresenceHookOptions, f as PresenceTopic, i as ActionState, l as LiveCountSource, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, t as fieldErrorsOf, u as LiveQueryHookOptions } from "../field-errors-CKEqR38q.js";
+import { b as DbError } from "../result-DZeA5KS6.js";
+import { Ct as Events, D as BlockEventPattern, T as BlockEvent, bt as EventMap, k as BlockEventsMatching } from "../events-vcqenSYU.js";
+import { pt as QuerySpec } from "../define-DFBnQyYg.js";
+import { $ as TemplateValues } from "../bucket-CiNi8sIw.js";
+import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-CJrQZQaa.js";
+import { t as AuthSnapshot } from "../bind-CrMBwrPN.js";
+import { t as AuthSession } from "../view-DyFdMCqg.js";
+import { n as Controller } from "../controller-BrP0gn47.js";
+import { C as LiveCountSource, D as ProfileOf, E as PresenceTopic, O as UseActionOptions, S as LiveCountHookOptions, T as PresenceHookOptions, _ as ActionResultOf, a as DataRows, b as ClaimsOf, c as DataWrites, d as BlockMutationState, f as BlockQueryActions, g as ActionInputOf, h as BlockRefetchOn, i as DataRow, l as BlockEventSource, m as BlockQueryState, n as DataId, o as DataSource, p as BlockQueryOptions, r as DataListArgs, s as DataState, t as fieldErrorsOf, u as BlockMutationActions, v as ActionState, w as LiveQueryHookOptions, x as ClientLike, y as BroadcastOptions } from "../field-errors-fsbFktYF.js";
+import { n as BlockOptions } from "../block-env-B_uEM2xz.js";
+import { n as BlockDataOf, r as BlockMethodName, t as BlockArgsOf } from "../block-method-CiVa2G-J.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { QueryClient } from "@tanstack/query-core";
+import { Readable } from "svelte/store";
+//#region src/blocks/svelte-bind.d.ts
+/**
+ * A block controller in a Svelte component: a readable store of its state, with
+ * its actions.
+ */
+interface SvelteController<S, A> extends Readable<S> {
+  readonly actions: A;
+  readonly controller: Controller<S, A>;
+}
+//#endregion
+//#region src/svelte/block-hooks.d.ts
+/**
+ * Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
+ * from mount. `refetchOn` calls it again on block events.
+ */
+export declare function useBlockQuery<C extends object, const K extends BlockMethodName<C>>(client: C, method: K, args: BlockArgsOf<C, K>, options?: BlockQueryOptions): SvelteController<BlockQueryState<BlockDataOf<C, K>>, BlockQueryActions>;
+/** Calls a write method of any block client and tracks its state. */
+export declare function useBlockMutation<C extends object, const K extends BlockMethodName<C>>(client: C, method: K): SvelteController<BlockMutationState<BlockDataOf<C, K>>, BlockMutationActions<BlockArgsOf<C, K>, BlockDataOf<C, K>>>;
+/**
+ * Calls `handler` for each block event matching `pattern` (`"task.*"`), typed
+ * by `events` (`blockEvents` from `blocks.generated.ts`), from mount until the
+ * component goes away. `source` is the client's `betterSupabase`.
+ */
+export declare function useBlockEvent<M extends EventMap, const P extends BlockEventPattern<M>>(source: BlockEventSource, events: Events<M>, pattern: P, handler: (event: BlockEvent<M, BlockEventsMatching<M, P>>) => void): void;
+//#endregion
+//#region src/blocks/svelte-controller.d.ts
+/**
+ * Makes a controller once, during component setup. The store follows it from
+ * mount (never during server rendering) while it has subscribers, and the
+ * controller is disposed with the component.
+ */
+export declare function useBlockController<O, S, A>(create: (options: O) => Controller<S, A>, options: BlockOptions<O>, usesEnv?: boolean): SvelteController<S, A>;
+//#endregion
+//#region src/svelte/data-hooks.d.ts
+/** What `useList` and `useOne` return: a store of the read, with the writes. */
+type DataView<S extends DataSource, T> = SvelteController<DataState<T>, DataWrites<S>>;
+/** The stores `defineDataHooks` makes for one table or block instance. */
+interface DataHooks<S extends DataSource> {
+  /** `source.list(args)`, kept fresh after every write. */
+  readonly useList: (args?: DataListArgs<S>) => DataView<S, DataRows<S>>;
+  /** `source.get(id)`, kept fresh after every write. */
+  readonly useOne: (id: DataId<S>) => DataView<S, DataRow<S>>;
+}
+/**
+ * The list and record stores for one table or block instance. Call them during
+ * component setup. The generated `hooks.ts` calls it once per table; `select`
+ * picks the source from the bound client's `db`.
+ */
+export declare function defineDataHooks<D, S extends DataSource>(name: string, select: (db: D) => S): DataHooks<S>;
+//#endregion
 //#region src/svelte/index.d.ts
 /**
  * A value read through `.current`, reactive in templates, `$derived` and
@@ -51,7 +106,7 @@ export interface BetterSvelte<B extends ClientLike = ClientLike> {
   readonly db: B["db"];
   /**
    * TanStack Query option factories: `createQuery(() =>
-   * bs.queries.customers.findMany())`.
+   * bsb.queries.customers.list())`.
    */
   readonly queries: B["queries"];
   readonly supabase: SupabaseClient;
@@ -78,14 +133,14 @@ export declare function createBetterSvelte<B extends ClientLike>(client: B, opti
  *
  * ```svelte
  * <script lang="ts">
- *   setBetterSupabase(bs, { queryClient });
+ *   setBetterSupabase(bsb, { queryClient });
  * <\/script>
  * ```
  */
 export declare function setBetterSupabase<B extends ClientLike>(client: B, options?: BetterSvelteOptions): BetterSvelte<B>;
 /**
  * The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof
- * bs>()`.
+ * bsb>()`.
  */
 export declare function getBetterSupabase<B extends ClientLike = ClientLike>(): BetterSvelte<B>;
 /** The session state for UI. Call during component setup. */
@@ -97,7 +152,7 @@ export declare function useBroadcast<P extends string, E extends EventSchemas>(t
  *
  * ```svelte
  * <script lang="ts">
- *   const live = useLiveQuery(() => betterSupabase.spec.customers.findMany());
+ *   const live = useLiveQuery(() => betterSupabase.spec.customers.list());
  * <\/script>
  * <span data-status={live.current}></span>
  * ```
@@ -120,4 +175,4 @@ export declare function setSession(session: () => AuthSession): void;
  */
 export declare function useSession<C = unknown, P = unknown>(): Current<AuthSession<C, P>>;
 //#endregion
-export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type UseActionOptions, fieldErrorsOf };
+export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BlockEventSource, type BlockMutationActions, type BlockMutationState, type BlockOptions, type BlockQueryActions, type BlockQueryOptions, type BlockQueryState, type BlockRefetchOn, type BroadcastOptions, type ClaimsOf, type ClientLike, type DataHooks, type DataSource, type DataState, type DataView, type DataWrites, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type SvelteController, type UseActionOptions, fieldErrorsOf };