better-supabase 0.8.0 → 0.10.0

package/dist/executor-D3K3tycZ.js

@@ -0,0 +1,147 @@
+import { a as evaluateCondition, c as isGraphRecord, i as durationMs, n as conditionOf, p as validateGraph, t as approved, u as topologicalOrder } from "./graph-Cs28bOlK.js";
+//#region src/blocks/workflow-builder/executor.ts
+/** The hook token of an approval node without `requestApproval`. */
+const approvalToken = (runKey, node) => `${runKey}:${node}`;
+const active = (edge, ran) => {
+	const outcome = ran.get(edge.source);
+	if (outcome === void 0) return false;
+	return edge.branch === void 0 || String(outcome) === edge.branch;
+};
+/**
+* The runtime fields of a static executor's `meta`: spread them into the
+* runtime passed to `executeGraph`, so a run starts at its trigger node,
+* conditions read its subject, and a test run returns its stubs instead of
+* running steps.
+*/
+function graphRunFields(meta) {
+	const record = isGraphRecord(meta) ? meta : {};
+	const text = (key) => typeof record[key] === "string" ? record[key] : void 0;
+	const subject = record["subject"];
+	const stubs = record["stubs"];
+	const version = text("versionId");
+	const tenant = text("tenant");
+	const triggerNode = text("triggerNode");
+	return {
+		runKey: text("runKey") ?? "",
+		...version === void 0 ? {} : { version },
+		...tenant === void 0 ? {} : { tenant },
+		...isGraphRecord(subject) ? { subject: {
+			type: String(subject["type"]),
+			id: String(subject["id"])
+		} } : {},
+		...triggerNode === void 0 ? {} : { triggerNode },
+		...record["mode"] === "test" ? { stubs: isGraphRecord(stubs) ? stubs : {} } : {}
+	};
+}
+/** A test run's stub for `node`, or `fallback` when it has none. */
+function stubOf(stubs, node, fallback) {
+	return Object.hasOwn(stubs, node) ? stubs[node] : fallback;
+}
+/**
+* The trigger node a run starts at: `requested` when the graph has it, else
+* the graph's only trigger. Throws when neither picks one.
+*/
+function startNodeOf(graph, requested) {
+	const triggers = graph.nodes.filter((node) => node.kind === "trigger");
+	const start = requested === void 0 ? triggers.length === 1 ? triggers[0]?.id : void 0 : triggers.find((node) => node.id === requested)?.id;
+	if (start === void 0) throw new TypeError("workflow-builder: pass the trigger node the run starts at, the id of one of the graph's trigger nodes");
+	return start;
+}
+/**
+* Runs `graph` in dependency order from its start trigger
+* (`runtime.triggerNode`): a node runs when the trigger reaches it through
+* edges whose sources ran (and, from a condition or an approval, took the
+* edge's branch). Returns each node's output by id. It only calls
+* `runtime`, so it is deterministic and runs inside a `"use workflow"`
+* function as the static executor.
+*/
+async function executeGraph(graph, input, runtime) {
+	const errors = validateGraph(graph);
+	if (errors.length > 0) throw new TypeError(`workflow-builder: ${errors.join("; ")}`);
+	const start = startNodeOf(graph, runtime.triggerNode);
+	const order = topologicalOrder(graph) ?? [];
+	const incoming = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) incoming.set(edge.target, [...incoming.get(edge.target) ?? [], edge]);
+	const results = {};
+	const ran = /* @__PURE__ */ new Map();
+	for (const node of order) {
+		if (node.kind === "trigger") {
+			if (node.id !== start) continue;
+		} else if (!(incoming.get(node.id) ?? []).some((edge) => active(edge, ran))) continue;
+		const { output, outcome } = await runNode(node, input, results, runtime);
+		results[node.id] = output;
+		ran.set(node.id, outcome);
+	}
+	return results;
+}
+const extrasOf = (runtime) => ({
+	...runtime.version === void 0 ? {} : { version: runtime.version },
+	...runtime.tenant === void 0 ? {} : { tenant: runtime.tenant },
+	...runtime.subject === void 0 ? {} : { subject: runtime.subject }
+});
+async function runNode(node, input, results, runtime) {
+	switch (node.kind) {
+		case "trigger": return {
+			output: input,
+			outcome: true
+		};
+		case "step": return {
+			output: (runtime.stubs === void 0 ? await runtime.step({
+				node: node.id,
+				step: node.step ?? "",
+				config: node.config ?? {},
+				input,
+				results: { ...results },
+				runKey: runtime.runKey,
+				...extrasOf(runtime)
+			}) : stubOf(runtime.stubs, node.id, { stubbed: true })) ?? null,
+			outcome: true
+		};
+		case "sleep":
+			if (runtime.stubs === void 0) await runtime.sleep(durationMs(node.config?.["duration"]) ?? 0);
+			return {
+				output: null,
+				outcome: true
+			};
+		case "approval": {
+			if (runtime.stubs !== void 0) {
+				const payload = stubOf(runtime.stubs, node.id, { approved: true });
+				return {
+					output: payload ?? null,
+					outcome: approved(payload)
+				};
+			}
+			const token = runtime.requestApproval === void 0 ? approvalToken(runtime.runKey, node.id) : await runtime.requestApproval({
+				node: node.id,
+				config: node.config ?? {},
+				input,
+				results: { ...results },
+				runKey: runtime.runKey,
+				...extrasOf(runtime)
+			});
+			const payload = await runtime.approval(token, node.id);
+			return {
+				output: payload ?? null,
+				outcome: approved(payload)
+			};
+		}
+		case "condition": {
+			const condition = conditionOf(node);
+			const outcome = condition !== void 0 && evaluateCondition(condition, {
+				input,
+				results,
+				subject: runtime.subject
+			});
+			return {
+				output: outcome,
+				outcome
+			};
+		}
+		default: {
+			const unknown = node.kind;
+			throw new TypeError(`workflow-builder: unknown node kind ${String(unknown)}`);
+		}
+	}
+}
+//#endregion
+export { startNodeOf as i, executeGraph as n, graphRunFields as r, approvalToken as t };

package/dist/executor-DzJQVTE2.d.ts

@@ -0,0 +1,39 @@
+import { r as Executor } from "./executor-BicyP8Nl.js";
+//#region src/postgres/executor.d.ts
+/**
+ * Anything that runs parameterized SQL: `ctx.postgres` from
+ * `@supabase/server/middleware/postgres`, or a client from `createPostgres()`.
+ */
+interface SqlClient {
+  queryRaw<T = Record<string, unknown>>(text: string, params?: unknown[]): Promise<T[]>;
+  /**
+   * Runs `fn` on one connection in one transaction. Optional; without it
+   * `db.$many` sends its statements separately.
+   */
+  transaction?<T>(fn: (client: SqlClient) => Promise<T>): Promise<T>;
+}
+interface PostgresExecutorOptions {
+  /**
+   * Rows an `estimated` count counts exactly before it switches to the
+   * planner's estimate, like PostgREST's `db-max-rows`. Defaults to 1000.
+   */
+  readonly estimatedCountThreshold?: number;
+}
+/**
+ * Executes repository operations as SQL on a direct Postgres connection.
+ * Rows have the same shape as over PostgREST. RLS applies when the client
+ * runs as the caller (`ctx.postgres`, `createPostgres().asUser()`).
+ *
+ * `maxAffected` fails the statement itself, so its writes roll back.
+ * A call's `timeout` is checked before the statement starts; set
+ * `statement_timeout` on the connection to bound a running statement.
+ * `retry` does nothing here.
+ *
+ * `count: "planned"` reads the planner's row estimate from
+ * `explain (format json)`; `count: "estimated"` counts exactly up to
+ * `estimatedCountThreshold` rows and uses the estimate past it, like
+ * PostgREST.
+ */
+declare function postgresExecutor(client: SqlClient, options?: PostgresExecutorOptions): Executor;
+//#endregion
+export { SqlClient as n, postgresExecutor as r, PostgresExecutorOptions as t };

package/dist/executor-aKUo_Xyb.js

@@ -0,0 +1,206 @@
+import { r as isPlainObject } from "./clone-dN9XOL1K.js";
+import { c as mapDbError, n as dbError, u as withMaxAffected } from "./errors-8i6tSICm.js";
+import { a as ok, r as err, s as toDbError } from "./result-COkvI9t5.js";
+import { n as quoteIdent, t as compileSql } from "./sql-BQshMgmB.js";
+import { t as fromPgError } from "./pg-error-BV_X8Isq.js";
+//#region src/postgres/executor.ts
+/**
+* A `count(*)::bigint`, which node-postgres returns as text. A count past
+* `Number.MAX_SAFE_INTEGER` fails instead of losing precision.
+*/
+function countOf(value) {
+	const count = value === null || value === void 0 ? 0 : typeof value === "number" ? value : typeof value === "bigint" || typeof value === "string" ? Number(value) : NaN;
+	if (!Number.isSafeInteger(count) || count < 0) throw new TypeError(`Unreadable row count: ${String(value)}`);
+	return count;
+}
+/** `Plan Rows` of the top node of an `explain (format json)` result. */
+async function plannedRows(client, query) {
+	const [first] = await client.queryRaw(query.text, [...query.params]);
+	const raw = first?.["QUERY PLAN"];
+	const plan = typeof raw === "string" ? JSON.parse(raw) : raw;
+	const top = Array.isArray(plan) ? plan[0] : void 0;
+	const rows = isPlainObject(top) && isPlainObject(top["Plan"]) ? top["Plan"]["Plan Rows"] : void 0;
+	if (typeof rows !== "number" || !Number.isFinite(rows) || rows < 0) throw new TypeError("The query plan has no row estimate");
+	return Math.min(Math.round(rows), Number.MAX_SAFE_INTEGER);
+}
+async function run(client, plan, op) {
+	const rows = plan.rows ? (await client.queryRaw(plan.rows.text, [...plan.rows.params])).map((entry) => entry.row) : [];
+	let count = null;
+	if (plan.count) {
+		const [first] = await client.queryRaw(plan.count.text, [...plan.count.params]);
+		count = first ? countOf(first.count) : 0;
+		if (plan.plannedCount && plan.countThreshold !== void 0 && count > plan.countThreshold) count = Math.max(count, await plannedRows(client, plan.plannedCount));
+	} else if (plan.plannedCount) count = await plannedRows(client, plan.plannedCount);
+	else if (op.kind !== "select") count = rows.length;
+	for (const next of plan.chunks ?? []) {
+		const more = await run(client, next, op);
+		rows.push(...more.rows);
+		count = (count ?? 0) + (more.count ?? 0);
+	}
+	return {
+		rows,
+		count
+	};
+}
+/**
+* Executes repository operations as SQL on a direct Postgres connection.
+* Rows have the same shape as over PostgREST. RLS applies when the client
+* runs as the caller (`ctx.postgres`, `createPostgres().asUser()`).
+*
+* `maxAffected` fails the statement itself, so its writes roll back.
+* A call's `timeout` is checked before the statement starts; set
+* `statement_timeout` on the connection to bound a running statement.
+* `retry` does nothing here.
+*
+* `count: "planned"` reads the planner's row estimate from
+* `explain (format json)`; `count: "estimated"` counts exactly up to
+* `estimatedCountThreshold` rows and uses the estimate past it, like
+* PostgREST.
+*/
+function postgresExecutor(client, options = {}) {
+	const signatures = /* @__PURE__ */ new Map();
+	const compile = options.estimatedCountThreshold === void 0 ? {} : { estimatedCountThreshold: options.estimatedCountThreshold };
+	const executeOn = (scoped, op, context) => executeWith(scoped, op, context, compile);
+	return {
+		name: "postgres",
+		functionSources: true,
+		execute: (op, context) => executeOn(client, op, context),
+		rpc: (name, args, context) => callFunction(client, name, args, context, signatures),
+		async batch(ops, context) {
+			if (!client.transaction) return Promise.all(ops.map((op) => executeOn(client, op, context)));
+			try {
+				return await client.transaction(async (scoped) => {
+					const results = [];
+					for (const op of ops) {
+						const result = await executeOn(scoped, op, context);
+						if (!result.ok) throw new BatchFailed();
+						results.push(result);
+					}
+					return results;
+				});
+			} catch (cause) {
+				if (!(cause instanceof BatchFailed)) {
+					const raw = fromPgError(cause);
+					if (!raw) throw cause;
+					const error = mapDbError(raw, context.errorMappers);
+					return ops.map(() => err(error));
+				}
+				return Promise.all(ops.map((op) => executeOn(client, op, context)));
+			}
+		}
+	};
+}
+var BatchFailed = class extends Error {};
+async function executeWith(client, op, context, options) {
+	let plan;
+	try {
+		plan = compileSql(op, options);
+	} catch (cause) {
+		return err(toDbError(cause));
+	}
+	if (plan.never) return ok({
+		rows: [],
+		count: 0
+	});
+	if (context.signal?.aborted) return err(dbError("aborted", "The request was aborted"));
+	const together = plan.chunks !== void 0 || plan.rows !== void 0 && plan.count !== void 0;
+	let result;
+	try {
+		result = together && client.transaction ? await client.transaction((scoped) => run(scoped, plan, op)) : await run(client, plan, op);
+	} catch (cause) {
+		const raw = fromPgError(cause);
+		const error = raw ? mapDbError(raw, context.errorMappers) : toDbError(cause);
+		return err(withMaxAffected(error, op.kind === "update" || op.kind === "delete" ? op.maxAffected : void 0));
+	}
+	if (op.kind === "select" && op.single) {
+		if (result.rows.length > 1) return err(dbError("multiple_rows", `Expected one ${op.table.key} row`));
+		if (result.rows.length === 0 && op.single === "one") return err(dbError("not_found", `No ${op.table.key} row matched`));
+	}
+	return ok(result);
+}
+const JSON_TYPES = /* @__PURE__ */ new Set(["json", "jsonb"]);
+const NO_NAMES = /* @__PURE__ */ new Set();
+/** undefined_function, invalid_function_definition and datatype_mismatch: the function changed. */
+const CHANGED_FUNCTION = /* @__PURE__ */ new Set([
+	"42883",
+	"42P13",
+	"42804"
+]);
+async function signatureOf(client, name, context, cache) {
+	const fn = context.function;
+	if (fn) return {
+		returnsSet: fn.returnsSet,
+		returnsVoid: fn.returns === "void",
+		json: new Set(fn.args.filter((arg) => JSON_TYPES.has(arg.type)).map((arg) => arg.name)),
+		outputOnly: NO_NAMES
+	};
+	const key = `${context.schema}.${name}`;
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const found = await lookUp(client, name, context.schema);
+	if (found) cache.set(key, found);
+	return found;
+}
+async function lookUp(client, name, schema) {
+	const [found] = await client.queryRaw("select p.proretset as returns_set, p.prorettype = 'pg_catalog.void'::pg_catalog.regtype as returns_void, p.proargnames as arg_names, p.proargmodes::text[] as arg_modes, (select array_agg(t.typname::text order by a.ordinality) from unnest(p.proargtypes::oid[]) with ordinality as a(oid, ordinality) join pg_catalog.pg_type t on t.oid = a.oid) as arg_types from pg_catalog.pg_proc p join pg_catalog.pg_namespace n on n.oid = p.pronamespace where n.nspname = $1 and p.proname = $2 limit 1", [schema, name]);
+	if (!found) return;
+	const json = /* @__PURE__ */ new Set();
+	const outputOnly = /* @__PURE__ */ new Set();
+	if (found.arg_names && found.arg_types) {
+		const modes = found.arg_modes;
+		for (const [index, mode] of (modes ?? []).entries()) {
+			const argName = found.arg_names[index];
+			if ((mode === "o" || mode === "t") && argName) outputOnly.add(argName);
+		}
+		const inputIndexes = modes ? modes.flatMap((mode, index) => mode === "i" || mode === "v" || mode === "b" ? [index] : []) : found.arg_names.map((_, index) => index);
+		for (const [position, index] of inputIndexes.entries()) {
+			const argName = found.arg_names[index];
+			const type = found.arg_types[position];
+			if (argName != null && type !== void 0 && JSON_TYPES.has(type)) json.add(argName);
+		}
+	}
+	return {
+		returnsSet: found.returns_set,
+		returnsVoid: found.returns_void,
+		json,
+		outputOnly
+	};
+}
+function argValue(value, json) {
+	if (value === null) return null;
+	if (json) return JSON.stringify(value);
+	if (typeof value === "bigint") return value.toString();
+	if (Array.isArray(value)) return value.map((item) => argValue(item, false));
+	if (isPlainObject(value)) return JSON.stringify(value);
+	if (typeof value === "object" && !(value instanceof Date) && !(value instanceof Uint8Array)) return String(value);
+	return value;
+}
+async function callFunction(client, name, args, context, cache) {
+	if (context.signal?.aborted) return err(dbError("aborted", "The request was aborted"));
+	try {
+		const signature = await signatureOf(client, name, context, cache);
+		if (!signature) return err(mapDbError({
+			code: "PGRST202",
+			message: `Could not find the function ${context.schema}.${name} in the database`
+		}, context.errorMappers));
+		const params = [];
+		const named = Object.entries(args).filter(([key, value]) => value !== void 0 && !signature.outputOnly.has(key)).map(([key, value]) => {
+			params.push(argValue(value, signature.json.has(key)));
+			return `${quoteIdent(key)} => $${String(params.length)}`;
+		});
+		const call = `${quoteIdent(context.schema)}.${quoteIdent(name)}(${named.join(", ")})`;
+		if (signature.returnsVoid) {
+			await client.queryRaw(`select ${call}`, params);
+			return ok(null);
+		}
+		const source = context.select ? `(select ${context.select.map(({ column, cast }) => cast ? `bs_call.${quoteIdent(column)}::${cast} as ${quoteIdent(column)}` : `bs_call.${quoteIdent(column)}`).join(", ")} from ${call} as bs_call)` : call;
+		const values = (await client.queryRaw(`select to_json(bs_call) as value from ${source} as bs_call`, params)).map((row) => row.value);
+		return ok(signature.returnsSet ? values : values[0] ?? null);
+	} catch (cause) {
+		const raw = fromPgError(cause);
+		if (raw?.code && CHANGED_FUNCTION.has(raw.code)) cache.delete(`${context.schema}.${name}`);
+		return err(raw ? mapDbError(raw, context.errorMappers) : toDbError(cause));
+	}
+}
+//#endregion
+export { postgresExecutor as t };

package/dist/expo/index.d.ts

@@ -1,7 +1,7 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-CoE5Zwy4.js";
-import { t as BetterSupabase } from "../define-DmcfoNXB.js";
-import { i as ServerContext, n as ContextOptions, s as ServerOptions, t as BetterServer } from "../server-types-CrAmZ8jv.js";
-import { i as MiddlewareOptions, r as GuardOptions } from "../respond-Cw-zanCm.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-BO8lVTun.js";
+import { t as BetterSupabase } from "../define-DXTC706J.js";
+import { i as ServerContext, n as ContextOptions, s as ServerOptions, t as BetterServer } from "../server-types-fXwJoFjt.js";
+import { i as MiddlewareOptions, r as GuardOptions } from "../respond-Cdg5ibH5.js";
 import { t as Validated } from "../shared-DDSjEGDR.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { ImmutableRequest, MiddlewareFunction } from "expo-server";

package/dist/expo/index.js

@@ -1,10 +1,10 @@
 import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { s as toProblem } from "../problem-CJvFeGu7.js";
-import { a as unexpectedResponse, b as refreshFor, c as extendServer, s as createServer } from "../adapter-CN45ibbV.js";
-import { p as serializeCookie } from "../resolve-Bvgf3ut_.js";
-import { a as respond, r as guard, t as defaultExpose } from "../respond-volM3ByS.js";
-import { t as withBetterSupabase } from "../composite-zTe0TCqj.js";
-import { r as handoffOf } from "../shared-CBxosKK3.js";
+import { c as toProblem } from "../problem-pIiL3WbE.js";
+import { a as unexpectedResponse, c as extendServer, s as createServer, x as refreshFor } from "../adapter-rmWaLNe3.js";
+import { m as serializeCookie } from "../resolve-CAR9oaKW.js";
+import { a as respond, r as guard, t as defaultExpose } from "../respond-Dpx48ATq.js";
+import { t as withBetterSupabase } from "../composite-CPV0thLs.js";
+import { r as handoffOf } from "../shared-BmMcMoW9.js";
 import { bufferRequest, pipeline, seedContext } from "@supabase/middleware";
 import { StatusError, setResponseHeaders } from "expo-server";
 //#region src/bridges/expo.ts

package/dist/expo-sqlite/index.d.ts

@@ -1,6 +1,6 @@
-import { r as Executor } from "../executor-Drzu3dBK.js";
-import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-DfEtf0cq.js";
-import { a as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-COzRWvVN.js";
+import { r as Executor } from "../executor-BicyP8Nl.js";
+import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-CIxyatuB.js";
+import { a as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-D1wwzZ04.js";
 //#region src/expo-sqlite/executor.d.ts
 /** What an expo-sqlite database or exclusive transaction can run. */
 interface ExpoSqliteContextLike {

package/dist/expo-sqlite/index.js

@@ -1,5 +1,5 @@
-import { n as watch, t as sqliteTables } from "../watch-BcvtAHOd.js";
-import { i as checkSqlite, t as powersyncExecutor } from "../executor-B-fD7DLt.js";
+import { n as watch, t as sqliteTables } from "../watch-Blj1mQ9n.js";
+import { i as checkSqlite, t as powersyncExecutor } from "../executor-Cex-1PFp.js";
 //#region src/expo-sqlite/executor.ts
 const DEFAULT_THROTTLE_MS = 30;
 /** A UUID v4 from SQLite's `randomblob`, for runtimes without `crypto.randomUUID`. */

package/dist/field-errors-nFnYWvB0.d.ts

@@ -0,0 +1,113 @@
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { J as TemplateValues } from "./storage-api-B4Ib2Zpo.js";
+import { at as QuerySpec } from "./define-DXTC706J.js";
+import { _ as TopicMessage, c as RealtimeClient, d as SubscribeOptions, i as PresenceOptions, s as PresenceSubscription } from "./topic-Dgs-eSYQ.js";
+import { t as ClientPorts } from "./ports-Dcnuo3HT.js";
+import { a as ClientAuth } from "./bind-DkaP_0iS.js";
+import { a as LiveSource, r as LiveCountSeed } from "./index-DcijDfh1.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/bindings/client.d.ts
+/** The parts of `createClient()` the bindings need. */
+interface ClientLike {
+  readonly betterSupabase: LiveSource;
+  readonly supabase: SupabaseClient;
+  readonly auth: ClientAuth;
+  readonly db: object;
+  readonly queries: object;
+  /** The platform services block controllers use; see `ClientPorts`. */
+  readonly ports?: ClientPorts;
+}
+/** What a `bs.action()` Server Action or server function resolves to. */
+type ActionResultOf<T> = {
+  readonly ok: true;
+  readonly data: T;
+  readonly error: null;
+} | {
+  readonly ok: false;
+  readonly data: null;
+  readonly error: DbError;
+};
+/**
+ * The input `useAction` passes: a `bs.action()` with an `input` schema also
+ * accepts `FormData`, which belongs to `useActionForm`.
+ */
+type ActionInputOf<I> = [Exclude<I, FormData>] extends [never] ? I : Exclude<I, FormData>;
+interface UseActionOptions<I, T> {
+  readonly onSuccess?: (data: T, input: I) => void;
+  readonly onError?: (error: DbError, input: I) => void;
+}
+interface BroadcastOptions extends Omit<SubscribeOptions, "onStatus"> {
+  /**
+   * A supabase-js client to subscribe with, for apps without the provider.
+   * It resubscribes when the client's user changes. Defaults to the
+   * provider's client.
+   */
+  readonly client?: SupabaseClient;
+  /** The query client `invalidate` refetches with. Defaults to the provider's. */
+  readonly queryClient?: QueryClient;
+  /**
+   * Refetch after each message: table keys (every query that read one of
+   * them), or a function returning query keys. Needs a `queryClient`, here
+   * or on the provider.
+   */
+  readonly invalidate?: readonly string[] | ((message: TopicMessage) => readonly (readonly unknown[])[]);
+}
+interface LiveQueryHookOptions {
+  /**
+   * Tenant for tenant-scoped tables. Defaults to the `config.claims.tenant`
+   * claim (`tenant_id`, top-level or in `app_metadata`).
+   */
+  readonly tenant?: string;
+  /** Defaults to 100 ms. */
+  readonly debounceMs?: number;
+}
+interface LiveCountHookOptions extends LiveQueryHookOptions {
+  /** The count to show before the first fetch, e.g. from the server. */
+  readonly initial?: number;
+}
+interface PresenceHookOptions<I> {
+  /**
+   * The state this client shares while joined. It is tracked after the
+   * join and tracked again when its JSON changes; `null` stays untracked.
+   */
+  readonly state?: I | null;
+  /** A supabase-js client for apps without the provider. */
+  readonly client?: SupabaseClient;
+}
+/** The parts of a `defineTopic(..., { presence })` topic the bindings use. */
+interface PresenceTopic<P extends string, I, O> {
+  topic(values: TemplateValues<P>): string;
+  match(topic: string): TemplateValues<P> | null;
+  subscribe(client: RealtimeClient, values: TemplateValues<P>, handlers: Readonly<Record<string, never>>, options?: SubscribeOptions & PresenceOptions<O>): PresenceSubscription<I, O>;
+}
+/** Who a subscription runs as. */
+/** The claims type of a client's `betterSupabase.claims(schema)`, `unknown` without one. */
+type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
+} ? C : unknown;
+/** The profile type of a client's `betterSupabase.userMetadata(schema)`, `unknown` without one. */
+type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
+} ? P : unknown;
+/** A count spec or a `bs.liveCount()` seed. */
+type LiveCountSource = QuerySpec<string, "count", number> | LiveCountSeed | null | undefined;
+interface ActionState<I, T> {
+  /** True while a run is in flight. */
+  readonly pending: boolean;
+  /** The inputs of the runs in flight, e.g. to dim one table row. */
+  readonly pendingInputs: readonly I[];
+  /** The input of the latest run in flight. */
+  readonly pendingInput: I | undefined;
+  /** The data of the last successful run. */
+  readonly data: T | undefined;
+  /** The error of the last run, until the next one starts. */
+  readonly error: DbError | undefined;
+}
+//#endregion
+//#region src/bindings/field-errors.d.ts
+/** The first message per top-level field of a `validation` error. */
+declare function fieldErrorsOf(error: DbError | undefined): Readonly<Partial<Record<string, string>>>;
+//#endregion
+export { BroadcastOptions as a, LiveCountHookOptions as c, PresenceHookOptions as d, PresenceTopic as f, ActionState as i, LiveCountSource as l, UseActionOptions as m, ActionInputOf as n, ClaimsOf as o, ProfileOf as p, ActionResultOf as r, ClientLike as s, fieldErrorsOf as t, LiveQueryHookOptions as u };

package/dist/field-formats-Cif5gr7c.js

@@ -0,0 +1,102 @@
+//#region src/core/contracts/field-formats.ts
+const FIELD_FORMAT_NAMES = [
+	"email",
+	"url",
+	"phone",
+	"long_text",
+	"color",
+	"rating",
+	"percent",
+	"currency"
+];
+/** The stars a `rating` takes, for a column and for a custom field. */
+const RATING_BOUNDS = [1, 5];
+const EMAIL = String.raw`^[^@\s]+@[^@\s]+\.[^@\s]+$`;
+const URL = String.raw`^https?://\S+$`;
+/**
+* Money is a `currency` `bigint` of minor units next to a `text` column of
+* 3 characters for the code (ADR 0037).
+*/
+const FIELD_FORMATS = {
+	email: {
+		types: ["text"],
+		pattern: EMAIL,
+		input: "email",
+		formType: "email"
+	},
+	url: {
+		types: ["text"],
+		pattern: URL,
+		input: "url",
+		formType: "url"
+	},
+	phone: {
+		types: ["text"],
+		input: "tel",
+		formType: "text"
+	},
+	long_text: {
+		types: ["text"],
+		input: "textarea",
+		formType: "textarea"
+	},
+	color: {
+		types: ["text"],
+		input: "color",
+		formType: "text"
+	},
+	rating: {
+		types: ["integer", "bigint"],
+		bounds: RATING_BOUNDS,
+		input: "number",
+		formType: "integer"
+	},
+	percent: {
+		types: ["integer", "numeric"],
+		bounds: [0, 100],
+		input: "number",
+		formType: "number"
+	},
+	currency: {
+		types: ["bigint"],
+		input: "number",
+		formType: "integer"
+	}
+};
+/**
+* The types of a custom field definition. A value is stored as text either
+* way; the type tells the form and the UI what it holds. `user` holds a user
+* id, `currency` an integer of minor units, and `multi_option` a JSON array
+* of option values.
+*/
+const CUSTOM_FIELD_TYPES = [
+	"text",
+	"number",
+	"date",
+	"bool",
+	"option",
+	"json",
+	"email",
+	"url",
+	"multi_option",
+	"user",
+	"rating",
+	"currency"
+];
+/** The forms block field type that answers each custom field type. */
+const CUSTOM_FIELD_FORM_TYPES = {
+	text: "text",
+	number: "number",
+	date: "date",
+	bool: "bool",
+	option: "option",
+	json: "json",
+	email: FIELD_FORMATS.email.formType,
+	url: FIELD_FORMATS.url.formType,
+	multi_option: "multi",
+	user: "text",
+	rating: FIELD_FORMATS.rating.formType,
+	currency: FIELD_FORMATS.currency.formType
+};
+//#endregion
+export { RATING_BOUNDS as a, FIELD_FORMAT_NAMES as i, CUSTOM_FIELD_TYPES as n, FIELD_FORMATS as r, CUSTOM_FIELD_FORM_TYPES as t };