better-supabase 0.8.0 → 0.10.0

package/dist/blocks/metrics/index.d.ts

@@ -0,0 +1,174 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "../../result-Cj3yWhjH.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { n as BlockOptions } from "../../block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "../../block-hooks-C_WaodoA.js";
+import { g as JobHandler } from "../../types-P1S1cj6N.js";
+import { i as EventSink, t as CloudEvent } from "../../cloud-event-bwsBwVNG.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+import { a as MetricWhereValue, c as metricsOf, i as MetricMeasure, n as MetricDefinition, o as checkMetric, r as MetricGrain, s as defineMetric, t as METRIC_GRAINS } from "../../metric-definition-95HFoW1V.js";
+//#region src/blocks/metrics/sink.d.ts
+interface MetricsSinkOptions {
+  /**
+   * Event type (without `typePrefix`) to the metrics whose rows the event
+   * adds, such as `{ "order.placed": ["orders", "revenue"] }`.
+   */
+  readonly on: Readonly<Record<string, string | readonly string[] | undefined>>;
+  /** Stripped from each event type. Defaults to `dev.better-supabase`. */
+  readonly typePrefix?: string;
+  /**
+   * When the event's rows sit in time, for events about rows bucketed by
+   * another time than when the event happened, such as time logged for a
+   * past day (`timeEntryMetricTime`). Several times re-aggregate each of
+   * their buckets, for an event that moves a row from one day to another.
+   * Default: the event's `time`.
+   */
+  readonly time?: (event: CloudEvent) => string | readonly string[] | undefined;
+}
+/**
+ * An outbox sink that re-aggregates the buckets an event's rows fall in,
+ * so charts catch up without waiting for the periodic rollup:
+ * `outbox.relay('metrics', metricsSink(metrics, { on }))`. It reads the
+ * event's `time` (or `options.time`, now when neither has one) and runs one
+ * rollup per metric for each UTC day the batch's times fall on, so a row
+ * moved to another day fixes both days without re-aggregating the days
+ * between. Build `metrics` with a service transport.
+ */
+export declare function metricsSink(metrics: Pick<Metrics, "rollup">, options: MetricsSinkOptions): EventSink;
+//#endregion
+//#region src/blocks/metrics/metrics.d.ts
+/** The queue `metrics.job` handles: re-aggregates a window of rollups. */
+export declare const METRICS_ROLLUP_QUEUE = "metrics.rollup";
+/** The key of one of `M`'s metrics, any string without definitions. */
+type MetricKey<M extends readonly MetricDefinition[]> = M[number]["key"];
+/** The dimensions of metric `K` in `M`. */
+type MetricDimension<M extends readonly MetricDefinition[], K extends string> = Extract<M[number], {
+  readonly key: K;
+}> extends MetricDefinition<string, infer D> ? D : never;
+interface MetricsOptions<M extends readonly MetricDefinition[]> extends Pick<BlockOptions, "transport" | "service" | "schema" | "mappers"> {
+  /**
+   * The same `defineMetric` definitions as `blocks.metrics.options.metrics`,
+   * so `series` and `kpi` type the keys and dimensions.
+   */
+  readonly metrics?: M;
+  /** `withBlockHooks` hooks around the methods. */
+  readonly hooks?: BlockHooks<Metrics<M>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  /**
+   * The events that add rows, for the outbox sink `createBlocks` puts in
+   * `sinks` (`metricsSink`). Without it, the block provides no sink.
+   */
+  readonly sink?: Pick<MetricsSinkOptions, "on" | "time">;
+}
+/** `[from, until)`. */
+interface MetricRange {
+  readonly from: Temporal.Instant;
+  readonly until: Temporal.Instant;
+}
+interface MetricReadOptions<D extends string = string> {
+  readonly organizationId: string;
+  /** Rows whose dimensions equal these values. */
+  readonly filter?: Readonly<Partial<Record<D, MetricWhereValue>>>;
+  /** Also reads the range of the same length just before. */
+  readonly compare?: "previous";
+}
+interface MetricSeriesOptions<D extends string = string> extends MetricReadOptions<D> {
+  /** Default `day`. */
+  readonly grain?: MetricGrain;
+  /** Splits each bucket by one dimension into `groups`. */
+  readonly groupBy?: D;
+}
+interface MetricPoint {
+  /** The bucket's start, in the metric's time zone. */
+  readonly bucket: Temporal.Instant;
+  /** `null` for an average over no rows. */
+  readonly value: number | null;
+  /** The rows counted. */
+  readonly count: number;
+  /** The value per dimension value with `groupBy`; `""` collects nulls. */
+  readonly groups?: Readonly<Record<string, number | null>>;
+}
+interface MetricSeries {
+  readonly metric: string;
+  readonly grain: MetricGrain;
+  readonly range: MetricRange;
+  readonly points: readonly MetricPoint[];
+  /** With `compare: "previous"`: the range before, bucket for bucket. */
+  readonly previous?: readonly MetricPoint[];
+}
+interface Kpi {
+  readonly metric: string;
+  readonly value: number | null;
+  readonly count: number;
+  /** With `compare: "previous"`: the value over the range before. */
+  readonly previous?: number | null;
+  /** `(value - previous) / |previous|`, `null` when there is nothing to compare. */
+  readonly change?: number | null;
+  readonly trend?: "up" | "down" | "flat";
+}
+/** A declared metric, as `metric_definitions()` returns it. */
+interface MetricInfo {
+  readonly key: string;
+  readonly label: string | null;
+  readonly unit: string | null;
+  readonly measure: "count" | "sum" | "avg";
+  readonly dimensions: readonly string[];
+  readonly grains: readonly MetricGrain[];
+  readonly tz: string;
+}
+interface MetricsRollupRequest {
+  /** One metric. Default: all of them. */
+  readonly metric?: string;
+  /** Default: `blocks.metrics.options.window` ago. */
+  readonly since?: Temporal.Instant;
+  /** Default: now. */
+  readonly until?: Temporal.Instant;
+}
+interface Metrics<M extends readonly MetricDefinition[] = readonly MetricDefinition[]> {
+  /** One point per bucket of `range`, gaps filled. Checked against the metric's permission. */
+  series<K extends MetricKey<M>>(metric: K, range: MetricRange, options: MetricSeriesOptions<MetricDimension<M, K>>): AsyncResult<MetricSeries>;
+  /** The total over `range`, for a stat card. */
+  kpi<K extends MetricKey<M>>(metric: K, range: MetricRange, options: MetricReadOptions<MetricDimension<M, K>>): AsyncResult<Kpi>;
+  definitions(): AsyncResult<readonly MetricInfo[]>;
+  /**
+   * Re-aggregates the rollups of a window, so late or changed rows land.
+   * Service only. Resolves to the number of points written.
+   */
+  rollup(request?: MetricsRollupRequest): AsyncResult<number>;
+  /** The handler for `metrics.rollup` jobs, whose payload is a `MetricsRollupRequest` as JSON. */
+  readonly job: JobHandler<unknown>;
+}
+/** The range of the same length that ends where `range` starts. */
+export declare function previousRange(range: MetricRange): MetricRange;
+/** How `value` moved from `previous`. */
+export declare function compareValues(value: number | null, previous: number | null): Pick<Kpi, "change" | "trend">;
+/**
+ * The `metrics` SQL module as typed calls: `series` and `kpi` for charts
+ * and stat cards as the caller, and `rollup` with a service transport.
+ */
+export declare function createMetrics<const M extends readonly MetricDefinition[] = readonly MetricDefinition[]>(options: MetricsOptions<M>): Metrics<M>;
+//#endregion
+//#region src/blocks/metrics/chart.d.ts
+/** One row of chart data: the bucket, its value and one key per group. */
+type MetricChartRow = Readonly<Record<string, string | number | null>> & {
+  readonly date: string;
+  readonly value: number | null;
+};
+interface MetricChartOptions {
+  /** The label of each bucket. Default: its ISO 8601 instant. */
+  readonly format?: (bucket: Temporal.Instant) => string;
+}
+/**
+ * Rows in the shape Recharts (and chart components built on it) read:
+ * `{ date, value, previous?, ...groups }`, one per bucket. `previous` is
+ * the bucket at the same position of the compared range.
+ */
+export declare function toChartData(series: MetricSeries, options?: MetricChartOptions): readonly MetricChartRow[];
+//#endregion
+//#region src/blocks/metrics/manifest.d.ts
+/** The `metrics` block's manifest (ADR 0029). */
+export declare const metricsBlock: BlockOf<"metrics", typeof createMetrics, Record<never, never>, Record<never, never>, "sink">;
+//#endregion
+export { type BlockTransport, type Kpi, METRIC_GRAINS, type MetricChartOptions, type MetricChartRow, type MetricDefinition, type MetricDimension, type MetricGrain, type MetricInfo, type MetricKey, type MetricMeasure, type MetricPoint, type MetricRange, type MetricReadOptions, type MetricSeries, type MetricSeriesOptions, type MetricWhereValue, type Metrics, type MetricsOptions, type MetricsRollupRequest, type MetricsSinkOptions, checkMetric, dbTransport, defineMetric, metricsOf, rpcTransport, sqlTransport };

package/dist/blocks/metrics/index.js

@@ -0,0 +1,217 @@
+import { s as nowInstant } from "../../temporal-CB5Fpo5d.js";
+import { t as temporal } from "../../temporal-required-DqRzr7i0.js";
+import { t as AsyncResult } from "../../result-COkvI9t5.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as metricsSqlOptions } from "../../options-CN7PHkhU.js";
+import { a as metricsOf, n as checkMetric, r as defineMetric, t as METRIC_GRAINS } from "../../metric-definition-BjxVn4R5.js";
+import { a as stripTypePrefix } from "../../cloud-event-CTh9Sr5w.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, F as stringsOf, I as textOf, k as recordsOf, o as blockCall } from "../../block-helpers-BfVCR5Fc.js";
+import { r as withBlockHooks } from "../../block-hooks-ByKlh8Qy.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+//#region src/blocks/metrics/metrics.ts
+/** The queue `metrics.job` handles: re-aggregates a window of rollups. */
+const METRICS_ROLLUP_QUEUE = "metrics.rollup";
+const numberOrNull = (value) => value === null || value === void 0 ? null : Number(value);
+function pointOf(row) {
+	const groups = row["groups"];
+	return {
+		bucket: requiredInstant(row["bucket"], "bucket"),
+		value: numberOrNull(row["value"]),
+		count: Number(row["count"] ?? 0),
+		...isRecord(groups) ? { groups: Object.fromEntries(Object.entries(groups).map(([key, value]) => [key, numberOrNull(value)])) } : {}
+	};
+}
+function infoOf(row) {
+	const measure = textOf(row["measure"]);
+	return {
+		key: textOf(row["key"]),
+		label: optionalText(row["label"]) ?? null,
+		unit: optionalText(row["unit"]) ?? null,
+		measure: measure === "sum" || measure === "avg" ? measure : "count",
+		dimensions: stringsOf(row["dimensions"]),
+		grains: stringsOf(row["grains"]),
+		tz: textOf(row["tz"])
+	};
+}
+/** The range of the same length that ends where `range` starts. */
+function previousRange(range) {
+	return {
+		from: range.from.subtract(range.until.since(range.from)),
+		until: range.from
+	};
+}
+/** How `value` moved from `previous`. */
+function compareValues(value, previous) {
+	if (value === null || previous === null) return { change: null };
+	const trend = value > previous ? "up" : value < previous ? "down" : "flat";
+	return {
+		change: previous === 0 ? null : (value - previous) / Math.abs(previous),
+		trend
+	};
+}
+function requestOf(value) {
+	if (value !== void 0 && value !== null && !isRecord(value)) throw new TypeError(`${METRICS_ROLLUP_QUEUE} needs an object payload`);
+	const payload = value ?? {};
+	const metric = optionalText(payload["metric"]);
+	const since = optionalText(payload["since"]);
+	const until = optionalText(payload["until"]);
+	return {
+		...metric === void 0 ? {} : { metric },
+		...since === void 0 ? {} : { since: temporal().Instant.from(since) },
+		...until === void 0 ? {} : { until: temporal().Instant.from(until) }
+	};
+}
+/**
+* The `metrics` SQL module as typed calls: `series` and `kpi` for charts
+* and stat cards as the caller, and `rollup` with a service transport.
+*/
+function createMetrics(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const readSeries = (metric, range, read, grain) => call("metric_series", {
+		p_metric: metric,
+		p_tenant: read.organizationId,
+		p_from: range.from.toString(),
+		p_until: range.until.toString(),
+		p_grain: grain,
+		p_dims: read.filter ?? {},
+		p_group_by: read.groupBy ?? null
+	}, (value) => recordsOf(value, "metric_series").map(pointOf));
+	const readValue = (metric, range, read) => call("metric_value", {
+		p_metric: metric,
+		p_tenant: read.organizationId,
+		p_from: range.from.toString(),
+		p_until: range.until.toString(),
+		p_dims: read.filter ?? {}
+	}, (value) => {
+		const row = recordOf(value, "metric_value");
+		return {
+			value: numberOrNull(row["value"]),
+			count: Number(row["count"] ?? 0)
+		};
+	});
+	const rollup = (request = {}) => service("metrics_rollup", {
+		p_metric: request.metric ?? null,
+		p_since: request.since?.toString() ?? null,
+		p_until: request.until?.toString() ?? null
+	}, Number);
+	return withBlockHooks({
+		series(metric, range, read) {
+			const grain = read.grain ?? "day";
+			return readSeries(metric, range, read, grain).andThen((points) => read.compare === "previous" ? readSeries(metric, previousRange(range), read, grain).map((previous) => ({
+				metric,
+				grain,
+				range,
+				points,
+				previous
+			})) : AsyncResult.ok({
+				metric,
+				grain,
+				range,
+				points
+			}));
+		},
+		kpi(metric, range, read) {
+			return readValue(metric, range, read).andThen((current) => read.compare === "previous" ? readValue(metric, previousRange(range), read).map((before) => ({
+				metric,
+				...current,
+				previous: before.value,
+				...compareValues(current.value, before.value)
+			})) : AsyncResult.ok({
+				metric,
+				...current
+			}));
+		},
+		definitions: () => call("metric_definitions", {}, (value) => recordsOf(value, "metric_definitions").map(infoOf)),
+		rollup,
+		job: async (payload) => {
+			await rollup(requestOf(payload)).orThrow();
+		}
+	}, options.hooks, {
+		block: "metrics",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/metrics/chart.ts
+/**
+* Rows in the shape Recharts (and chart components built on it) read:
+* `{ date, value, previous?, ...groups }`, one per bucket. `previous` is
+* the bucket at the same position of the compared range.
+*/
+function toChartData(series, options = {}) {
+	const format = options.format ?? ((bucket) => bucket.toString());
+	return series.points.map((point, index) => {
+		const previous = series.previous?.[index];
+		return {
+			...point.groups,
+			date: format(point.bucket),
+			value: point.value,
+			...series.previous === void 0 ? {} : { previous: previous?.value ?? null }
+		};
+	});
+}
+//#endregion
+//#region src/blocks/metrics/sink.ts
+function widen(window, at) {
+	if (window === void 0) return {
+		since: at,
+		until: at
+	};
+	return {
+		since: temporal().Instant.compare(window.since, at) < 0 ? window.since : at,
+		until: temporal().Instant.compare(window.until, at) > 0 ? window.until : at
+	};
+}
+function timesOf(event, options) {
+	const time = options.time?.(event) ?? event.time;
+	const times = time === void 0 ? [] : typeof time === "string" ? [time] : time;
+	return times.length === 0 ? [nowInstant()] : times.map((value) => temporal().Instant.from(value));
+}
+/**
+* An outbox sink that re-aggregates the buckets an event's rows fall in,
+* so charts catch up without waiting for the periodic rollup:
+* `outbox.relay('metrics', metricsSink(metrics, { on }))`. It reads the
+* event's `time` (or `options.time`, now when neither has one) and runs one
+* rollup per metric for each UTC day the batch's times fall on, so a row
+* moved to another day fixes both days without re-aggregating the days
+* between. Build `metrics` with a service transport.
+*/
+function metricsSink(metrics, options) {
+	return { async send(events) {
+		const windows = /* @__PURE__ */ new Map();
+		for (const event of events) {
+			const entry = options.on[stripTypePrefix(event.type, options.typePrefix)];
+			if (entry === void 0) continue;
+			const times = timesOf(event, options);
+			for (const metric of typeof entry === "string" ? [entry] : entry) {
+				const days = windows.get(metric) ?? /* @__PURE__ */ new Map();
+				windows.set(metric, days);
+				for (const at of times) {
+					const day = at.toString().slice(0, 10);
+					days.set(day, widen(days.get(day), at));
+				}
+			}
+		}
+		for (const [metric, days] of windows) for (const window of days.values()) await metrics.rollup({
+			metric,
+			since: window.since,
+			until: window.until.add({ milliseconds: 1 })
+		}).orThrow();
+	} };
+}
+//#endregion
+//#region src/blocks/metrics/manifest.ts
+/** The `metrics` block's manifest (ADR 0029). */
+const metricsBlock = defineBlock({
+	name: "metrics",
+	sql: ["metrics"],
+	options: { metrics: metricsSqlOptions },
+	provides: { sink: (client, options) => options.sink === void 0 ? void 0 : metricsSink(client, options.sink) },
+	create: createMetrics,
+	category: "admin",
+	recipes: ["metrics-dashboard"]
+});
+//#endregion
+export { METRICS_ROLLUP_QUEUE, METRIC_GRAINS, checkMetric, compareValues, createMetrics, dbTransport, defineMetric, metricsBlock, metricsOf, metricsSink, previousRange, rpcTransport, sqlTransport, toChartData };

package/dist/blocks/mfa/index.d.ts

@@ -0,0 +1,7 @@
+import { r as Block } from "../../define-block-BlHQxDIQ.js";
+import { a as MfaControllerOptions, c as MfaSnapshot, d as StepUpController, f as StepUpControllerOptions, g as needsStepUp, h as createStepUpController, i as MfaController, l as RawMfaFactor, m as createMfaController, n as MfaApi, o as MfaEnrollment, p as StepUpSnapshot, r as MfaAssurance, s as MfaFactor, t as MfaActions, u as StepUpActions } from "../../client-B_r4denm.js";
+//#region src/blocks/mfa/manifest.d.ts
+/** The `mfa` block's manifest (ADR 0029). */
+export declare const mfaBlock: Block<"mfa">;
+//#endregion
+export { type MfaActions, type MfaApi, type MfaAssurance, type MfaController, type MfaControllerOptions, type MfaEnrollment, type MfaFactor, type MfaSnapshot, type RawMfaFactor, type StepUpActions, type StepUpController, type StepUpControllerOptions, type StepUpSnapshot, createMfaController, createStepUpController, needsStepUp };

package/dist/blocks/mfa/index.js

@@ -0,0 +1,12 @@
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { n as createStepUpController, r as needsStepUp, t as createMfaController } from "../../client-iB5axfa0.js";
+//#region src/blocks/mfa/manifest.ts
+/** The `mfa` block's manifest (ADR 0029). */
+const mfaBlock = defineBlock({
+	name: "mfa",
+	sql: ["mfa"],
+	category: "identity",
+	recipes: ["mfa-setup"]
+});
+//#endregion
+export { createMfaController, createStepUpController, mfaBlock, needsStepUp };

package/dist/blocks/mfa/react/index.d.ts

@@ -0,0 +1,30 @@
+import { c as MfaSnapshot, g as needsStepUp, o as MfaEnrollment, p as StepUpSnapshot, r as MfaAssurance, s as MfaFactor, t as MfaActions, u as StepUpActions } from "../../../client-B_r4denm.js";
+//#region src/blocks/mfa/react/index.d.ts
+export interface UseMfaOptions {
+  /** The issuer authenticator apps show; default: the Auth Site URL's host. */
+  readonly issuer?: string;
+}
+export interface MfaState extends MfaSnapshot, MfaActions {}
+export interface StepUpState extends StepUpSnapshot, StepUpActions {}
+/**
+ * The user's MFA factors through the browser client, for a security
+ * settings page: `enroll` keeps a QR code in `enrollment`, `verify` confirms
+ * it with the first code, and `unenroll` removes a factor.
+ *
+ * ```tsx
+ * const { factors, enrollment, enroll, verify } = useMfa();
+ * ```
+ */
+export declare function useMfa(options?: UseMfaOptions): MfaState;
+/**
+ * Raises the session to `aal2` with a code from a verified factor. Show it
+ * when a call fails with `needsStepUp(error)`, and retry the call once
+ * `satisfied` is true.
+ *
+ * ```tsx
+ * const { satisfied, verify } = useStepUp();
+ * ```
+ */
+export declare function useStepUp(): StepUpState;
+//#endregion
+export { type MfaAssurance, type MfaEnrollment, type MfaFactor, needsStepUp };

package/dist/blocks/mfa/react/index.js

@@ -0,0 +1,45 @@
+"use client";
+import { t as useController } from "../../../react-controller-Xn-IU44p.js";
+import { t as useBlockEnv } from "../../../react-env-Cc7Vf6eb.js";
+import { n as createStepUpController, r as needsStepUp, t as createMfaController } from "../../../client-iB5axfa0.js";
+//#region src/blocks/mfa/react/index.ts
+/**
+* The user's MFA factors through the browser client, for a security
+* settings page: `enroll` keeps a QR code in `enrollment`, `verify` confirms
+* it with the first code, and `unenroll` removes a factor.
+*
+* ```tsx
+* const { factors, enrollment, enroll, verify } = useMfa();
+* ```
+*/
+function useMfa(options = {}) {
+	const { supabase, auth } = useBlockEnv();
+	const { issuer } = options;
+	return useController(() => createMfaController({
+		mfa: supabase.auth.mfa,
+		auth,
+		...issuer === void 0 ? {} : { issuer }
+	}), [
+		supabase,
+		auth,
+		issuer
+	]).view;
+}
+/**
+* Raises the session to `aal2` with a code from a verified factor. Show it
+* when a call fails with `needsStepUp(error)`, and retry the call once
+* `satisfied` is true.
+*
+* ```tsx
+* const { satisfied, verify } = useStepUp();
+* ```
+*/
+function useStepUp() {
+	const { supabase, auth } = useBlockEnv();
+	return useController(() => createStepUpController({
+		mfa: supabase.auth.mfa,
+		auth
+	}), [supabase, auth]).view;
+}
+//#endregion
+export { needsStepUp, useMfa, useStepUp };

package/dist/blocks/mfa/react/server.d.ts

@@ -0,0 +1,9 @@
+import { g as needsStepUp, o as MfaEnrollment, r as MfaAssurance, s as MfaFactor } from "../../../client-B_r4denm.js";
+import { MfaState, StepUpState, UseMfaOptions } from "./index.js";
+//#region src/blocks/mfa/react/server.d.ts
+/** The `react-server` build of `useMfa`: it runs in Client Components only. */
+export declare const useMfa: (options?: UseMfaOptions) => MfaState;
+/** The `react-server` build of `useStepUp`: it runs in Client Components only. */
+export declare const useStepUp: () => StepUpState;
+//#endregion
+export { type MfaAssurance, type MfaEnrollment, type MfaFactor, type MfaState, type StepUpState, type UseMfaOptions, needsStepUp };

package/dist/blocks/mfa/react/server.js

@@ -0,0 +1,12 @@
+import { r as needsStepUp } from "../../../client-iB5axfa0.js";
+//#region src/blocks/mfa/react/server.ts
+/** The `react-server` build of `useMfa`: it runs in Client Components only. */
+const useMfa = () => {
+	throw new Error("better-supabase: useMfa() runs in Client Components only. In Server Components read the `aal` claim with `aalOf()` instead.");
+};
+/** The `react-server` build of `useStepUp`: it runs in Client Components only. */
+const useStepUp = () => {
+	throw new Error("better-supabase: useStepUp() runs in Client Components only. In Server Components read the `aal` claim with `aalOf()` instead.");
+};
+//#endregion
+export { needsStepUp, useMfa, useStepUp };

package/dist/blocks/mfa/solid/index.d.ts

@@ -0,0 +1,20 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as SolidController } from "../../../solid-controller-CZrt1Tg6.js";
+import { a as MfaControllerOptions, c as MfaSnapshot, f as StepUpControllerOptions, p as StepUpSnapshot, t as MfaActions, u as StepUpActions } from "../../../client-B_r4denm.js";
+//#region src/blocks/mfa/solid/index.d.ts
+/**
+ * `createMfaController` as a Solid primitive: `state()` reads the snapshot.
+ * Call it in a component; the work starts on mount and the controller is
+ * disposed with the owner. `auth` and `ports` default to the client of
+ * `<BetterSupabaseProvider client={bs}>`.
+ */
+export declare function useMfa(options: BlockOptions<MfaControllerOptions>): SolidController<MfaSnapshot, MfaActions>;
+/**
+ * `createStepUpController` as a Solid primitive: `state()` reads the snapshot.
+ * Call it in a component; the work starts on mount and the controller is
+ * disposed with the owner. `auth` and `ports` default to the client of
+ * `<BetterSupabaseProvider client={bs}>`.
+ */
+export declare function useStepUp(options: BlockOptions<StepUpControllerOptions>): SolidController<StepUpSnapshot, StepUpActions>;
+//#endregion
+export type { BlockOptions, MfaActions, MfaControllerOptions, MfaSnapshot, SolidController, StepUpActions, StepUpControllerOptions, StepUpSnapshot };

package/dist/blocks/mfa/solid/index.js

@@ -0,0 +1,23 @@
+import { t as useBlockController } from "../../../solid-controller-DLsmrczT.js";
+import { n as createStepUpController, t as createMfaController } from "../../../client-iB5axfa0.js";
+//#region src/blocks/mfa/solid/index.ts
+/**
+* `createMfaController` as a Solid primitive: `state()` reads the snapshot.
+* Call it in a component; the work starts on mount and the controller is
+* disposed with the owner. `auth` and `ports` default to the client of
+* `<BetterSupabaseProvider client={bs}>`.
+*/
+function useMfa(options) {
+	return useBlockController(createMfaController, options);
+}
+/**
+* `createStepUpController` as a Solid primitive: `state()` reads the snapshot.
+* Call it in a component; the work starts on mount and the controller is
+* disposed with the owner. `auth` and `ports` default to the client of
+* `<BetterSupabaseProvider client={bs}>`.
+*/
+function useStepUp(options) {
+	return useBlockController(createStepUpController, options);
+}
+//#endregion
+export { useMfa, useStepUp };

package/dist/blocks/mfa/svelte/index.d.ts

@@ -0,0 +1,20 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as SvelteController } from "../../../svelte-controller-DDbju9CW.js";
+import { a as MfaControllerOptions, c as MfaSnapshot, f as StepUpControllerOptions, p as StepUpSnapshot, t as MfaActions, u as StepUpActions } from "../../../client-B_r4denm.js";
+//#region src/blocks/mfa/svelte/index.d.ts
+/**
+ * `createMfaController` as a Svelte readable store of the snapshot, with the
+ * actions on `.actions`. Call it in a component's script; the work starts on
+ * mount and the controller is disposed with the component. `auth` and `ports`
+ * default to the client of `setBetterSupabase(bs)`.
+ */
+export declare function useMfa(options: BlockOptions<MfaControllerOptions>): SvelteController<MfaSnapshot, MfaActions>;
+/**
+ * `createStepUpController` as a Svelte readable store of the snapshot, with the
+ * actions on `.actions`. Call it in a component's script; the work starts on
+ * mount and the controller is disposed with the component. `auth` and `ports`
+ * default to the client of `setBetterSupabase(bs)`.
+ */
+export declare function useStepUp(options: BlockOptions<StepUpControllerOptions>): SvelteController<StepUpSnapshot, StepUpActions>;
+//#endregion
+export type { BlockOptions, MfaActions, MfaControllerOptions, MfaSnapshot, StepUpActions, StepUpControllerOptions, StepUpSnapshot, SvelteController };

package/dist/blocks/mfa/svelte/index.js

@@ -0,0 +1,23 @@
+import { t as useBlockController } from "../../../svelte-controller-CDAujo-_.js";
+import { n as createStepUpController, t as createMfaController } from "../../../client-iB5axfa0.js";
+//#region src/blocks/mfa/svelte/index.ts
+/**
+* `createMfaController` as a Svelte readable store of the snapshot, with the
+* actions on `.actions`. Call it in a component's script; the work starts on
+* mount and the controller is disposed with the component. `auth` and `ports`
+* default to the client of `setBetterSupabase(bs)`.
+*/
+function useMfa(options) {
+	return useBlockController(createMfaController, options);
+}
+/**
+* `createStepUpController` as a Svelte readable store of the snapshot, with the
+* actions on `.actions`. Call it in a component's script; the work starts on
+* mount and the controller is disposed with the component. `auth` and `ports`
+* default to the client of `setBetterSupabase(bs)`.
+*/
+function useStepUp(options) {
+	return useBlockController(createStepUpController, options);
+}
+//#endregion
+export { useMfa, useStepUp };

package/dist/blocks/mfa/vue/index.d.ts

@@ -0,0 +1,20 @@
+import { t as BlockOptions } from "../../../block-env-Dxl7rsI0.js";
+import { t as VueController } from "../../../vue-controller-D_ohttBZ.js";
+import { a as MfaControllerOptions, c as MfaSnapshot, f as StepUpControllerOptions, p as StepUpSnapshot, t as MfaActions, u as StepUpActions } from "../../../client-B_r4denm.js";
+//#region src/blocks/mfa/vue/index.d.ts
+/**
+ * `createMfaController` as a Vue composable: `state` is a shallow ref of the
+ * snapshot. Call it in `setup` or an effect scope; the work starts on mount and
+ * the controller is disposed with the scope. `auth` and `ports` default to the
+ * client of `app.use(betterSupabase(bs))`.
+ */
+export declare function useMfa(options: BlockOptions<MfaControllerOptions>): VueController<MfaSnapshot, MfaActions>;
+/**
+ * `createStepUpController` as a Vue composable: `state` is a shallow ref of the
+ * snapshot. Call it in `setup` or an effect scope; the work starts on mount and
+ * the controller is disposed with the scope. `auth` and `ports` default to the
+ * client of `app.use(betterSupabase(bs))`.
+ */
+export declare function useStepUp(options: BlockOptions<StepUpControllerOptions>): VueController<StepUpSnapshot, StepUpActions>;
+//#endregion
+export type { BlockOptions, MfaActions, MfaControllerOptions, MfaSnapshot, StepUpActions, StepUpControllerOptions, StepUpSnapshot, VueController };

package/dist/blocks/mfa/vue/index.js

@@ -0,0 +1,23 @@
+import { t as useBlockController } from "../../../vue-controller-C9tFzqAc.js";
+import { n as createStepUpController, t as createMfaController } from "../../../client-iB5axfa0.js";
+//#region src/blocks/mfa/vue/index.ts
+/**
+* `createMfaController` as a Vue composable: `state` is a shallow ref of the
+* snapshot. Call it in `setup` or an effect scope; the work starts on mount and
+* the controller is disposed with the scope. `auth` and `ports` default to the
+* client of `app.use(betterSupabase(bs))`.
+*/
+function useMfa(options) {
+	return useBlockController(createMfaController, options);
+}
+/**
+* `createStepUpController` as a Vue composable: `state` is a shallow ref of the
+* snapshot. Call it in `setup` or an effect scope; the work starts on mount and
+* the controller is disposed with the scope. `auth` and `ports` default to the
+* client of `app.use(betterSupabase(bs))`.
+*/
+function useStepUp(options) {
+	return useBlockController(createStepUpController, options);
+}
+//#endregion
+export { useMfa, useStepUp };