better-supabase 0.8.0 → 0.9.0

package/dist/messages-Cx4ttLJJ.js

@@ -0,0 +1,493 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { s as nowInstant } from "./temporal-CB5Fpo5d.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { o as problemResponse } from "./problem-pIiL3WbE.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-95HFoW1V.d.ts

@@ -0,0 +1,70 @@
+//#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/metric-definition-BjxVn4R5.js

@@ -0,0 +1,117 @@
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+//#region src/core/metric-definition.ts
+/** The bucket sizes of a series. */
+const METRIC_GRAINS = [
+	"hour",
+	"day",
+	"week",
+	"month"
+];
+const KEY = /^[a-z][a-z0-9_]{0,62}$/;
+const COLUMN = /^[a-z_][a-z0-9_]{0,62}$/;
+const TABLE = /^(?:[a-z_][a-z0-9_]{0,62}\.)?[a-z_][a-z0-9_]{0,62}$/;
+const PERMISSION = /^[a-z][a-z0-9_.*-]{0,127}$/;
+function column(where, value) {
+	if (typeof value !== "string" || !COLUMN.test(value)) throw new TypeError(`${where} must be a column name`);
+	return value;
+}
+function timeZone(where, value) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${where} must be an IANA time zone such as UTC`);
+	try {
+		Intl.DateTimeFormat("en", { timeZone: value }).resolvedOptions();
+	} catch {
+		throw new TypeError(`${where}: "${value}" is not an IANA time zone`);
+	}
+	return value;
+}
+function measureOf(where, value) {
+	if (value === "count") return "count";
+	if (isRecord(value)) {
+		const keys = Object.keys(value);
+		if (keys.length === 1 && (keys[0] === "sum" || keys[0] === "avg")) {
+			const name = column(`${where}.${keys[0]}`, value[keys[0]]);
+			return keys[0] === "sum" ? { sum: name } : { avg: name };
+		}
+	}
+	throw new TypeError(`${where} must be "count", { sum: "column" } or { avg: "column" }`);
+}
+/** Checks one definition and returns it with its defaults left unset. */
+function checkMetric(value, where = "metric") {
+	assertMetric(value, where);
+	return value;
+}
+function assertMetric(value, where) {
+	if (!isRecord(value)) throw new TypeError(`${where} must be an object`);
+	const key = value["key"];
+	if (typeof key !== "string" || !KEY.test(key)) throw new TypeError(`${where}.key must be lowercase letters, digits and underscores`);
+	const at = `${where} ${key}`;
+	const table = value["table"];
+	if (typeof table !== "string" || !TABLE.test(table)) throw new TypeError(`${at}.table must be "table" or "schema.table"`);
+	const dimensions = value["dimensions"] ?? [];
+	if (!Array.isArray(dimensions)) throw new TypeError(`${at}.dimensions must be a list of columns`);
+	const dims = dimensions.map((name) => column(`${at}.dimensions`, name));
+	if (new Set(dims).size !== dims.length) throw new TypeError(`${at}.dimensions lists a column twice`);
+	const rollup = value["rollup"];
+	if (rollup !== void 0 && rollup !== false && !(Array.isArray(rollup) && rollup.length > 0 && rollup.every((grain) => METRIC_GRAINS.some((known) => known === grain)))) throw new TypeError(`${at}.rollup must be false or a list of ${METRIC_GRAINS.join(", ")}`);
+	const permission = value["permission"];
+	if (permission !== void 0 && (typeof permission !== "string" || !PERMISSION.test(permission))) throw new TypeError(`${at}.permission must be a permission key`);
+	const filter = value["where"];
+	if (filter !== void 0) {
+		if (!isRecord(filter)) throw new TypeError(`${at}.where must be an object of column to value`);
+		for (const [name, literal] of Object.entries(filter)) {
+			column(`${at}.where`, name);
+			if (!(literal === null || typeof literal === "string" || typeof literal === "boolean" || typeof literal === "number" && Number.isFinite(literal))) throw new TypeError(`${at}.where.${name} must be a string, number, boolean or null`);
+		}
+	}
+	if (value["includeDeleted"] !== void 0 && typeof value["includeDeleted"] !== "boolean") throw new TypeError(`${at}.includeDeleted must be a boolean`);
+	for (const name of ["label", "unit"]) if (value[name] !== void 0 && typeof value[name] !== "string") throw new TypeError(`${at}.${name} must be a string`);
+	measureOf(`${at}.measure`, value["measure"]);
+	column(`${at}.timeColumn`, value["timeColumn"]);
+	if (value["tenant"] !== void 0) column(`${at}.tenant`, value["tenant"]);
+	if (value["tz"] !== void 0) timeZone(`${at}.tz`, value["tz"]);
+}
+/**
+* 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"],
+* });
+* ```
+*/
+function defineMetric(definition) {
+	checkMetric(definition, "defineMetric");
+	return definition;
+}
+/** `options.metrics`: a list of definitions, or an object of key to definition. */
+function metricsOf(value, where = "blocks.metrics.options.metrics") {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) && !isRecord(value)) throw new TypeError(`${where} must be a list of defineMetric() definitions or an object of key to definition`);
+	const metrics = (Array.isArray(value) ? value : Object.entries(value).map(([key, entry]) => isRecord(entry) ? {
+		key,
+		...entry
+	} : entry)).map((entry, index) => checkMetric(entry, `${where}[${String(index)}]`));
+	const keys = /* @__PURE__ */ new Set();
+	for (const metric of metrics) {
+		if (keys.has(metric.key)) throw new TypeError(`${where}: metric "${metric.key}" is defined twice`);
+		keys.add(metric.key);
+	}
+	return metrics;
+}
+/** The grain a stored rollup at `stored` can be summed into. */
+function grainDivides(stored, grain) {
+	switch (stored) {
+		case "hour": return true;
+		case "day": return grain !== "hour";
+		case "week": return grain === "week";
+		case "month": return grain === "month";
+		default: return stored;
+	}
+}
+//#endregion
+export { metricsOf as a, grainDivides as i, checkMetric as n, defineMetric as r, METRIC_GRAINS as t };