better-supabase 0.12.0 → 0.13.0

package/dist/message-Bg4TKA12.d.ts

@@ -0,0 +1,99 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/ai-chat/message.d.ts
+/** `$id` of `schemas/ai-message-v1.json`, the JSON Schema of `AiMessage`. */
+declare const AI_MESSAGE_SCHEMA_ID = "https://unpkg.com/better-supabase/schemas/ai-message-v1.json";
+type ProviderMetadata = Readonly<Record<string, unknown>>;
+interface PartBase {
+  /** What the provider attached, kept for replay; never read for logic. */
+  readonly providerMetadata?: ProviderMetadata;
+}
+interface AiTextPart extends PartBase {
+  readonly type: "text";
+  readonly text: string;
+  readonly state?: "streaming" | "done";
+}
+interface AiReasoningPart extends PartBase {
+  readonly type: "reasoning";
+  readonly text: string;
+  readonly state?: "streaming" | "done";
+}
+interface AiFilePart extends PartBase {
+  readonly type: "file";
+  /** IANA media type, e.g. `image/png`. */
+  readonly mediaType: string;
+  /**
+   * A URL the reader can fetch: `https:`, `data:` or a storage path the app
+   * signs.
+   */
+  readonly url: string;
+  readonly filename?: string;
+}
+interface AiToolCallPart extends PartBase {
+  readonly type: "tool-call";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  /** The provider ran the tool itself (web search on the model's side). */
+  readonly providerExecuted?: boolean;
+}
+interface AiToolResultPart extends PartBase {
+  readonly type: "tool-result";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly output: unknown;
+  readonly isError?: boolean;
+}
+interface AiToolApprovalPart extends PartBase {
+  readonly type: "tool-approval";
+  readonly toolCallId: string;
+  readonly approvalId: string;
+  readonly state: "requested" | "approved" | "denied";
+  readonly reason?: string;
+}
+interface AiSourcePart extends PartBase {
+  readonly type: "source";
+  readonly sourceType: "url" | "document";
+  readonly id: string;
+  readonly url?: string;
+  readonly title?: string;
+  readonly mediaType?: string;
+}
+/**
+ * App data in the message (`data-weather` in the AI SDK becomes `name:
+ * "weather"`).
+ */
+interface AiDataPart extends PartBase {
+  readonly type: "data";
+  readonly name: string;
+  readonly id?: string;
+  readonly data: unknown;
+}
+/** Where a model step starts or ends, for multi-step tool loops. */
+interface AiStepPart extends PartBase {
+  readonly type: "step";
+  readonly boundary: "start" | "finish";
+  readonly stepId?: string;
+}
+/**
+ * A part of a canonical message. Adapters map their SDK's parts onto these; a
+ * part with no counterpart becomes a `data` part rather than being lost.
+ */
+type AiMessagePart = AiTextPart | AiReasoningPart | AiFilePart | AiToolCallPart | AiToolResultPart | AiToolApprovalPart | AiSourcePart | AiDataPart | AiStepPart;
+type AiMessagePartType = AiMessagePart["type"];
+type AiMessageRole = "system" | "user" | "assistant" | "tool";
+/** A message in the SDK-neutral format `ai_messages.parts` stores (version 1). */
+interface AiMessage {
+  readonly id: string;
+  readonly role: AiMessageRole;
+  readonly parts: readonly AiMessagePart[];
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * A Standard Schema for `AiMessage`, matching `schemas/ai-message-v1.json`.
+ * Pass it to `validate()` or any library that takes a Standard Schema.
+ */
+declare const aiMessageSchema: StandardSchemaV1<unknown, AiMessage>;
+/** Whether `value` is a canonical message, without collecting the issues. */
+declare function isAiMessage(value: unknown): value is AiMessage;
+//#endregion
+export { AiMessagePart as a, AiReasoningPart as c, AiTextPart as d, AiToolApprovalPart as f, isAiMessage as g, aiMessageSchema as h, AiMessage as i, AiSourcePart as l, AiToolResultPart as m, AiDataPart as n, AiMessagePartType as o, AiToolCallPart as p, AiFilePart as r, AiMessageRole as s, AI_MESSAGE_SCHEMA_ID as t, AiStepPart as u };

package/dist/messages-Bd5-5ZjP.js

@@ -0,0 +1,492 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { s as nowInstant } from "./temporal-DLZlWbOi.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { o as problemResponse } from "./problem-D0KDiYPk.js";
+//#region src/ai-sdk/gateway.ts
+const count = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+/** Parses a USD amount (`"0.00042"` or a number) into micro-USD. */
+function microUsd(value) {
+	const amount = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+	return Number.isFinite(amount) && amount >= 0 ? Math.round(amount * 1e6) : void 0;
+}
+/** The usage of a finished generation, with the gateway's cost when it has one. */
+function usageOf(source) {
+	const usage = source.totalUsage ?? source.usage ?? {};
+	const input = count(usage.inputTokens);
+	const output = count(usage.outputTokens);
+	const gateway = isRecord(source.providerMetadata) && isRecord(source.providerMetadata["gateway"]) ? source.providerMetadata["gateway"] : {};
+	const generationId = gateway["generationId"];
+	return {
+		inputTokens: input,
+		outputTokens: output,
+		totalTokens: count(usage.totalTokens) || input + output,
+		cachedInputTokens: count(usage.inputTokenDetails?.cacheReadTokens),
+		reasoningTokens: count(usage.outputTokenDetails?.reasoningTokens),
+		generationId: typeof generationId === "string" ? generationId : void 0,
+		costMicroUsd: microUsd(gateway["cost"])
+	};
+}
+/** What `runs.release` stores for a generation that ended. */
+function runRelease(status, usage, error) {
+	return {
+		status,
+		...usage === void 0 ? {} : { usage: {
+			inputTokens: usage.inputTokens,
+			outputTokens: usage.outputTokens,
+			totalTokens: usage.totalTokens,
+			cachedInputTokens: usage.cachedInputTokens,
+			reasoningTokens: usage.reasoningTokens
+		} },
+		...usage?.generationId === void 0 ? {} : { generationId: usage.generationId },
+		...usage?.costMicroUsd === void 0 ? {} : { costMicroUsd: usage.costMicroUsd },
+		...error === void 0 ? {} : { error }
+	};
+}
+/** The entries to pass to `usage.recordMany` for a generation. */
+function usageEntries(usage, meters = {}) {
+	const entries = [{
+		meter: meters.input ?? "ai.input_tokens",
+		quantity: usage.inputTokens
+	}, {
+		meter: meters.output ?? "ai.output_tokens",
+		quantity: usage.outputTokens
+	}];
+	if (meters.cost !== void 0 && usage.costMicroUsd !== void 0) entries.push({
+		meter: meters.cost,
+		quantity: usage.costMicroUsd
+	});
+	return entries.filter((entry) => (entry.quantity ?? 0) > 0);
+}
+/**
+* A 429 Problem Details response for a quota or rate limit: pass the
+* `quota_exceeded` or `rate_limited` error a block returned, or the
+* `UsageStatus` of a meter with nothing left. It carries `Retry-After`.
+*/
+function problem429(decision, now = nowInstant()) {
+	if ("kind" in decision) return problemResponse(decision);
+	const retryAfter = Math.max(1, Math.ceil(now.until(decision.resetsAt).total("seconds")));
+	return problemResponse(dbError("quota_exceeded", `The ${decision.meter} quota is used up.`, {
+		meter: decision.meter,
+		...decision.limit === void 0 ? {} : { limit: decision.limit },
+		retryAfter
+	}));
+}
+/**
+* The quota check `createAssistant` runs before a generation: the error when
+* `meter` has nothing left for the tenant, otherwise `undefined`.
+*/
+function usageQuota(usage, meter) {
+	return async (organizationId) => {
+		const status = await usage.current(organizationId, meter);
+		if (!status.ok) return status.error;
+		const { remaining, limit } = status.data;
+		if (remaining === void 0 || remaining > 0) return;
+		const retryAfter = Math.max(1, Math.ceil(nowInstant().until(status.data.resetsAt).total("seconds")));
+		return dbError("quota_exceeded", `The ${meter} quota is used up.`, {
+			meter,
+			...limit === void 0 ? {} : { limit },
+			retryAfter
+		});
+	};
+}
+/**
+* A job handler that looks up a generation's cost in the AI Gateway and writes
+* it to the run (`runs.setCost`). Enqueue it when `usageOf` found no cost; it
+* throws so the queue retries while the gateway doesn't know it yet.
+*/
+function costBackfill(options) {
+	return async (payload) => {
+		const info = await options.gateway.getGenerationInfo({ id: payload.generationId });
+		const cost = microUsd(info.totalCost) ?? 0;
+		await options.chats.runs.setCost(payload.generationId, cost, {
+			...info.promptTokens === void 0 ? {} : { inputTokens: info.promptTokens },
+			...info.completionTokens === void 0 ? {} : { outputTokens: info.completionTokens }
+		}).orThrow();
+		if (options.usage !== void 0 && options.meter !== void 0 && payload.organizationId !== void 0 && cost > 0) await options.usage.record(payload.organizationId, options.meter, {
+			quantity: cost,
+			idempotencyKey: `ai-cost:${payload.generationId}`,
+			source: "ai:gateway"
+		}).orThrow();
+		return cost;
+	};
+}
+const isLanguageModel = (model) => model.modelType === void 0 || model.modelType === null || model.modelType === "language";
+/** The catalog row for a gateway model. */
+function modelInputOf(model, plans) {
+	const pricing = {};
+	for (const [key, value] of Object.entries(model.pricing ?? {})) if (typeof value === "string") pricing[key] = value;
+	return {
+		id: model.id,
+		provider: model.id.split("/", 1)[0] ?? "gateway",
+		name: model.name,
+		pricing,
+		capabilities: {
+			...model.modelType ? { modelType: model.modelType } : {},
+			...model.description ? { description: model.description } : {}
+		},
+		...plans === void 0 ? {} : { plans }
+	};
+}
+/**
+* A job handler that copies the AI Gateway's model list into the chat block's
+* catalog (`models.upsert`); schedule it daily.
+*/
+function modelCatalogRefresh(options) {
+	const keep = options.filter ?? isLanguageModel;
+	return async () => {
+		const { models } = await options.gateway.getAvailableModels();
+		const rows = models.filter(keep).map((model) => modelInputOf(model, options.plans?.(model)));
+		return options.chats.models.upsert(rows, { prune: options.prune ?? false }).orThrow();
+	};
+}
+//#endregion
+//#region src/ai-sdk/messages.ts
+/** The `format` the chat tree stores next to an AI SDK message it keeps as is. */
+const AI_SDK_UI_FORMAT = "ai-sdk-ui";
+/** The output a denied tool call gets in the canonical history. */
+const DENIED_TOOL_OUTPUT = "The tool call was denied.";
+const meta = (value) => isRecord(value) ? { providerMetadata: value } : {};
+/** Provider metadata is an object of objects per provider; JSON values inside. */
+function isProviderMetadata(value) {
+	return isRecord(value) && Object.values(value).every(isRecord);
+}
+const isToolPart = (part) => part.type === "dynamic-tool" || part.type.startsWith("tool-");
+/** Whether `value` has the shape of an AI SDK `UIMessage`. */
+function isUIMessage(value) {
+	return isRecord(value) && typeof value["id"] === "string" && (value["role"] === "system" || value["role"] === "user" || value["role"] === "assistant") && Array.isArray(value["parts"]);
+}
+function toolParts(part) {
+	const toolName = part.type === "dynamic-tool" ? part.toolName : part.type.slice(5);
+	const parts = [{
+		type: "tool-call",
+		toolCallId: part.toolCallId,
+		toolName,
+		input: part.input ?? {},
+		...part.providerExecuted === void 0 ? {} : { providerExecuted: part.providerExecuted },
+		...meta(part.callProviderMetadata)
+	}];
+	const { approval } = part;
+	if (approval !== void 0) {
+		let state = "requested";
+		if (approval.approved === true) state = "approved";
+		else if (approval.approved === false) state = "denied";
+		parts.push({
+			type: "tool-approval",
+			toolCallId: part.toolCallId,
+			approvalId: approval.id,
+			state,
+			...approval.reason === void 0 ? {} : { reason: approval.reason }
+		});
+	}
+	const result = (output, isError, metadata) => ({
+		type: "tool-result",
+		toolCallId: part.toolCallId,
+		toolName,
+		output,
+		...isError ? { isError } : {},
+		...meta(metadata)
+	});
+	switch (part.state) {
+		case "output-available":
+			parts.push(result(part.output, false, part.resultProviderMetadata));
+			break;
+		case "output-error":
+			parts.push(result(part.errorText, true, part.resultProviderMetadata));
+			break;
+		case "output-denied":
+			parts.push(result(part.approval.reason ?? "The tool call was denied.", true));
+			break;
+		case "input-streaming":
+		case "input-available":
+		case "approval-requested":
+		case "approval-responded": break;
+		default: return part;
+	}
+	return parts;
+}
+function fromPart(part) {
+	if (isToolPart(part)) return toolParts(part);
+	switch (part.type) {
+		case "text":
+		case "reasoning": return [{
+			type: part.type,
+			text: part.text,
+			...part.state === void 0 ? {} : { state: part.state },
+			...meta(part.providerMetadata)
+		}];
+		case "file": return [{
+			type: "file",
+			mediaType: part.mediaType,
+			url: part.url,
+			...part.filename === void 0 ? {} : { filename: part.filename },
+			...meta(part.providerMetadata)
+		}];
+		case "source-url": return [{
+			type: "source",
+			sourceType: "url",
+			id: part.sourceId,
+			url: part.url,
+			...part.title === void 0 ? {} : { title: part.title },
+			...meta(part.providerMetadata)
+		}];
+		case "source-document": return [{
+			type: "source",
+			sourceType: "document",
+			id: part.sourceId,
+			title: part.title,
+			mediaType: part.mediaType,
+			...meta(part.providerMetadata)
+		}];
+		case "step-start": return [{
+			type: "step",
+			boundary: "start"
+		}];
+		case "custom": return [{
+			type: "data",
+			name: "ui.custom",
+			data: { kind: part.kind },
+			...meta(part.providerMetadata)
+		}];
+		case "reasoning-file": return [{
+			type: "data",
+			name: "ui.reasoning-file",
+			data: {
+				mediaType: part.mediaType,
+				url: part.url
+			},
+			...meta(part.providerMetadata)
+		}];
+		default:
+			if (part.type.startsWith("data-") && "data" in part) return [{
+				type: "data",
+				name: part.type.slice(5),
+				..."id" in part && typeof part.id === "string" ? { id: part.id } : {},
+				data: part.data
+			}];
+			return [];
+	}
+}
+/**
+* The canonical form of an AI SDK `UIMessage`. Tool parts become a `tool-call`,
+* then a `tool-approval` and a `tool-result` as far as the call got; parts with
+* no canonical counterpart become `data` parts named `ui.<type>`.
+*/
+function fromUIMessage(message) {
+	return {
+		id: message.id,
+		role: message.role,
+		parts: message.parts.flatMap(fromPart),
+		...isRecord(message.metadata) ? { metadata: message.metadata } : {}
+	};
+}
+function toToolPart({ call, approval, result }) {
+	const base = {
+		type: `tool-${call.toolName}`,
+		toolCallId: call.toolCallId,
+		input: call.input,
+		...call.providerExecuted === void 0 ? {} : { providerExecuted: call.providerExecuted },
+		...isProviderMetadata(call.providerMetadata) ? { callProviderMetadata: call.providerMetadata } : {}
+	};
+	const reason = approval?.reason === void 0 ? {} : { reason: approval.reason };
+	if (approval?.state === "denied") return result === void 0 ? {
+		...base,
+		state: "approval-responded",
+		approval: {
+			id: approval.approvalId,
+			approved: false,
+			...reason
+		}
+	} : {
+		...base,
+		state: "output-denied",
+		approval: {
+			id: approval.approvalId,
+			approved: false,
+			...reason
+		}
+	};
+	const approved = approval?.state === "approved" ? { approval: {
+		id: approval.approvalId,
+		approved: true
+	} } : {};
+	if (result !== void 0) {
+		const resultMeta = isProviderMetadata(result.providerMetadata) ? { resultProviderMetadata: result.providerMetadata } : {};
+		if (result.isError === true) return {
+			...base,
+			...approved,
+			...resultMeta,
+			state: "output-error",
+			errorText: typeof result.output === "string" ? result.output : JSON.stringify(result.output)
+		};
+		return {
+			...base,
+			...approved,
+			...resultMeta,
+			state: "output-available",
+			output: result.output
+		};
+	}
+	if (approval?.state === "requested") return {
+		...base,
+		state: "approval-requested",
+		approval: { id: approval.approvalId }
+	};
+	if (approval?.state === "approved") return {
+		...base,
+		state: "approval-responded",
+		approval: {
+			id: approval.approvalId,
+			approved: true,
+			...reason
+		}
+	};
+	return {
+		...base,
+		state: "input-available"
+	};
+}
+function toPart(part) {
+	const providerMetadata = isProviderMetadata(part.providerMetadata) ? { providerMetadata: part.providerMetadata } : {};
+	switch (part.type) {
+		case "text":
+		case "reasoning": return {
+			type: part.type,
+			text: part.text,
+			...part.state === void 0 ? {} : { state: part.state },
+			...providerMetadata
+		};
+		case "file": return {
+			type: "file",
+			mediaType: part.mediaType,
+			url: part.url,
+			...part.filename === void 0 ? {} : { filename: part.filename },
+			...providerMetadata
+		};
+		case "source": return part.sourceType === "url" ? {
+			type: "source-url",
+			sourceId: part.id,
+			url: part.url ?? "",
+			...part.title === void 0 ? {} : { title: part.title },
+			...providerMetadata
+		} : {
+			type: "source-document",
+			sourceId: part.id,
+			mediaType: part.mediaType ?? "application/octet-stream",
+			title: part.title ?? "",
+			...providerMetadata
+		};
+		case "step": return part.boundary === "start" ? { type: "step-start" } : void 0;
+		case "data":
+			if (part.name === "ui.custom" && isRecord(part.data)) {
+				const kind = part.data["kind"];
+				return typeof kind === "string" && kind.includes(".") ? {
+					type: "custom",
+					kind,
+					...providerMetadata
+				} : void 0;
+			}
+			if (part.name === "ui.reasoning-file" && isRecord(part.data)) {
+				const { mediaType, url } = part.data;
+				return typeof mediaType === "string" && typeof url === "string" ? {
+					type: "reasoning-file",
+					mediaType,
+					url,
+					...providerMetadata
+				} : void 0;
+			}
+			return {
+				type: `data-${part.name}`,
+				...part.id === void 0 ? {} : { id: part.id },
+				data: part.data
+			};
+		case "tool-call":
+		case "tool-result":
+		case "tool-approval": return;
+		default: return part;
+	}
+}
+function render(parts, tools, into, slots) {
+	for (const part of parts) {
+		if (part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-approval") {
+			let state = tools.get(part.toolCallId);
+			if (part.type === "tool-call") {
+				state = {
+					...state,
+					call: part
+				};
+				tools.set(part.toolCallId, state);
+				if (!slots.has(part.toolCallId)) {
+					slots.set(part.toolCallId, into.length);
+					into.push(toToolPart(state));
+				}
+			} else if (state !== void 0) {
+				if (part.type === "tool-result") state.result = part;
+				else state.approval = part;
+			}
+			const slot = slots.get(part.toolCallId);
+			if (state !== void 0 && slot !== void 0) into[slot] = toToolPart(state);
+			continue;
+		}
+		const converted = toPart(part);
+		if (converted !== void 0) into.push(converted);
+	}
+}
+function nativeOf(message) {
+	const stored = message;
+	return stored.format === "ai-sdk-ui" && isUIMessage(stored.native) ? stored.native : void 0;
+}
+/**
+* The AI SDK form of a canonical message: the stored native message when the
+* tree kept one (`format: "ai-sdk-ui"`), otherwise a conversion. A `tool`
+* message becomes an assistant message.
+*/
+function toUIMessage(message) {
+	const native = nativeOf(message);
+	if (native !== void 0) return native;
+	const parts = [];
+	render(message.parts, /* @__PURE__ */ new Map(), parts, /* @__PURE__ */ new Map());
+	return {
+		id: message.id,
+		role: message.role === "tool" ? "assistant" : message.role,
+		parts,
+		...message.metadata === void 0 ? {} : { metadata: message.metadata }
+	};
+}
+/**
+* Converts a history. Tool results and approvals in later messages, such as the
+* `tool` messages of other SDKs, update the tool part of the assistant message
+* that made the call.
+*/
+function toUIMessages(messages) {
+	const out = [];
+	const tools = /* @__PURE__ */ new Map();
+	let owner;
+	for (const message of messages) {
+		const native = nativeOf(message);
+		if (native !== void 0) {
+			out.push(native);
+			owner = void 0;
+			continue;
+		}
+		if (message.role === "tool" && owner !== void 0) {
+			render(message.parts, tools, owner.parts, owner.slots);
+			continue;
+		}
+		const parts = [];
+		const slots = /* @__PURE__ */ new Map();
+		render(message.parts, tools, parts, slots);
+		out.push({
+			id: message.id,
+			role: message.role === "tool" ? "assistant" : message.role,
+			parts,
+			...message.metadata === void 0 ? {} : { metadata: message.metadata }
+		});
+		owner = message.role === "user" ? void 0 : {
+			parts,
+			slots
+		};
+	}
+	return out;
+}
+//#endregion
+export { meta as a, costBackfill as c, problem429 as d, runRelease as f, usageQuota as h, isUIMessage as i, modelCatalogRefresh as l, usageOf as m, DENIED_TOOL_OUTPUT as n, toUIMessage as o, usageEntries as p, fromUIMessage as r, toUIMessages as s, AI_SDK_UI_FORMAT as t, modelInputOf as u };

package/dist/metric-definition-EAYI1r2n.d.ts

@@ -0,0 +1,69 @@
+//#region src/core/metric-definition.d.ts
+/** What a metric adds up per bucket. */
+type MetricMeasure = "count" | {
+  readonly sum: string;
+} | {
+  readonly avg: string;
+};
+/** The bucket sizes of a series. */
+declare const METRIC_GRAINS: readonly ["hour", "day", "week", "month"];
+type MetricGrain = (typeof METRIC_GRAINS)[number];
+/** A literal a metric's rows must equal, such as `meter: "api_calls"`. */
+type MetricWhereValue = string | number | boolean | null;
+/**
+ * One metric over a table (`defineMetric`): what to measure, in which time
+ * column, per tenant. The SQL module reads the same definitions from
+ * `blocks.metrics.options.metrics`.
+ */
+interface MetricDefinition<K extends string = string, D extends string = string> {
+  /** Lowercase letters, digits and underscores. */
+  readonly key: K;
+  /** `schema.table`, or a table in `public`. */
+  readonly table: string;
+  readonly measure: MetricMeasure;
+  /** The `timestamptz` column a row is bucketed by. */
+  readonly timeColumn: string;
+  /** Columns a series can filter and group by. */
+  readonly dimensions?: readonly D[];
+  /** The tenant column. Default `organization_id`. */
+  readonly tenant?: string;
+  /** The IANA time zone buckets start in. Default `UTC`. */
+  readonly tz?: string;
+  /** The key a caller needs in the tenant. Default `metrics.read`. */
+  readonly permission?: string;
+  /** Column equalities every counted row meets. */
+  readonly where?: Readonly<Record<string, MetricWhereValue>>;
+  /**
+   * Counts rows of a subject table whose `deletedAt` column is set. By default
+   * the SQL module adds `deletedAt is null` unless `where` names that column.
+   */
+  readonly includeDeleted?: boolean;
+  /**
+   * The grains `metric_points` keeps, default `["day"]`. `false` queries the
+   * table directly, for small tables.
+   */
+  readonly rollup?: readonly MetricGrain[] | false;
+  readonly label?: string;
+  readonly unit?: string;
+}
+/** Checks one definition and returns it with its defaults left unset. */
+declare function checkMetric(value: unknown, where?: string): MetricDefinition;
+/**
+ * Declares a metric. The key and dimensions are kept as literal types, so
+ * `createMetrics({ metrics })` types `series("revenue", ...)`.
+ *
+ * ```ts
+ * export const revenue = defineMetric({
+ *   key: "revenue",
+ *   table: "public.orders",
+ *   measure: { sum: "total" },
+ *   timeColumn: "placed_at",
+ *   dimensions: ["channel"],
+ * });
+ * ```
+ */
+declare function defineMetric<const K extends string, const D extends string = never>(definition: MetricDefinition<K, D>): MetricDefinition<K, D>;
+/** `options.metrics`: a list of definitions, or an object of key to definition. */
+declare function metricsOf(value: unknown, where?: string): readonly MetricDefinition[];
+//#endregion
+export { MetricWhereValue as a, metricsOf as c, MetricMeasure as i, MetricDefinition as n, checkMetric as o, MetricGrain as r, defineMetric as s, METRIC_GRAINS as t };

package/dist/mfa-Dt8AdWht.d.ts

@@ -0,0 +1,36 @@
+import { b as DbError } from "./result-mijqfoJN.js";
+//#region src/auth/mfa.d.ts
+/**
+ * Authenticator assurance level: `aal2` once a second factor is verified in
+ * this session.
+ */
+type Aal = "aal1" | "aal2";
+/** One way the user proved who they are in this session (the JWT `amr` claim). */
+interface AmrEntry {
+  /** `password`, `otp`, `oauth`, `totp`, `sso/saml`, `anonymous`, ... */
+  readonly method: string;
+  /** Seconds since epoch. */
+  readonly timestamp: number;
+  /** SSO provider id, for `sso/saml`. */
+  readonly provider?: string;
+}
+/**
+ * The session's assurance level from its claims; anything but `aal2` reads as
+ * `aal1`.
+ */
+declare function aalOf(claims: Readonly<Record<string, unknown>>): Aal;
+/** The `amr` claim as typed entries, skipping malformed ones. */
+declare function amrOf(claims: Readonly<Record<string, unknown>>): readonly AmrEntry[];
+/**
+ * `undefined` when a user session meets `required`; otherwise a `forbidden`
+ * error with `required` and code `INSUFFICIENT_AAL`, for the client to start an
+ * MFA challenge. Non-user sessions pass: `allow` decides about them.
+ */
+declare function checkAal(auth: {
+  readonly kind: "user";
+  readonly claims: object;
+} | {
+  readonly kind: string;
+}, required: Aal): DbError | undefined;
+//#endregion
+export { checkAal as a, amrOf as i, AmrEntry as n, aalOf as r, Aal as t };