measurr 0.6.0 → 0.7.0

package/dist/{index-pgccd363.js → index-rgqsrd72.js}

@@ -62,8 +62,19 @@ var measure2 = {
       numerator,
       denominator
     };
-  }
+  },
+  resolved
 };
+function resolved(options) {
+  return {
+    kind: "resolved",
+    result: options.result,
+    label: options.label,
+    description: options.description,
+    access: options.access,
+    uses: options.uses ?? []
+  };
+}
 function base(options) {
   return {
     label: options.label,
@@ -222,6 +233,15 @@ function validateDataset(dataset) {
     }
     if (entry.kind === "ratio")
       checkRatio(measures, key, [], fail);
+    if (entry.kind === "resolved") {
+      for (const used of entry.uses) {
+        const usedEntry = measures[used];
+        if (!usedEntry)
+          fail(`measure ${key} uses unknown measure ${used}`);
+        if (usedEntry?.kind === "resolved")
+          fail(`measure ${key} uses ${used}, which is resolved too`);
+      }
+    }
   }
   const dimensions = dataset.dimensions;
   for (const [key, entry] of Object.entries(dimensions)) {
@@ -266,6 +286,8 @@ function checkRatio(measures, key, path, fail) {
   const entry = measures[key];
   if (!entry)
     fail(`ratio measure ${path.at(-1)} names unknown measure ${key}`);
+  if (entry?.kind === "resolved")
+    fail(`ratio measure ${path.at(-1)} names ${key}, which is resolved`);
   if (entry?.kind !== "ratio")
     return;
   checkRatio(measures, entry.numerator, [...path, key], fail);

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { type AccessKey, type Analytics, type AnalyticsCache, AnalyticsError, type AnalyticsErrorCode, type AnalyticsErrorDetails, type AnalyticsErrorOf, type AnalyticsOptions, type AnalyticsQuery, type AnalyticsQueryEvent, type AnalyticsResult, type AnalyticsSource, createAnalytics, type DatasetCatalogEntry, type FieldKey, isAnalyticsError } from './analytics.js';
+export { type AccessKey, type Analytics, type AnalyticsCache, AnalyticsError, type AnalyticsErrorCode, type AnalyticsErrorDetails, type AnalyticsErrorOf, type AnalyticsOptions, type AnalyticsQuery, type AnalyticsQueryEvent, type AnalyticsResolvers, type AnalyticsResult, type AnalyticsSource, createAnalytics, type DatasetCatalogEntry, type FieldKey, isAnalyticsError, type MeasureResolver, type ResolvedKey, type ResolverInput, type ResolverOutput } from './analytics.js';
 export { CompileError, type CompiledStatement, type Dialect, type JoinClause, type SelectItem, type SelectStatement, type SqlRenderer, decodeNumber, renderStatement } from './compile.js';
-export { type AnyDataset, type AnyDimension, type AnyMeasure, type Dataset, type DimensionValue, defineDataset, dimension, type MeasureValue, measure, type Ratio } from './dataset.js';
+export { type AnyDataset, type AnyDimension, type AnyMeasure, type Dataset, type DimensionValue, defineDataset, dimension, type MeasureValue, measure, type Ratio, type ResolvedMeasure } from './dataset.js';
 export { and, caseWhen, coalesce, type ColumnKey, eq, Expr, type ExprNode, exists, gt, gte, inList, isNotNull, isNull, literal, lt, lte, minutesAgo, ne, not, or, type SqlType, Table, type TableRef, table, toText } from './expr.js';
 export { analyticsToolGuidance } from './guidance.js';
 export type { PeriodInput, PeriodPreset } from './period.js';
-export { allTenants, type Tenant, type TenantId } from './plan.js';
+export { allTenants, type NormalizedFilter, type Tenant, type TenantId } from './plan.js';
 export { AnalyticsResultSchema, type DatasetFilter, type DatasetQuery, type QueryResult, type ResultOf, type ResultPeriod } from './query.js';

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   AnalyticsError2,
   isAnalyticsError2,
   createAnalytics2
-} from "./index-z5xv3ffk.js";
+} from "./index-g0ah4ehn.js";
 import {
   CompileError2,
   decodeNumber2,
@@ -14,7 +14,7 @@ import {
   measure2,
   dimension2,
   defineDataset2
-} from "./index-pgccd363.js";
+} from "./index-rgqsrd72.js";
 import {
   Expr2,
   Table2,

package/dist/metrics.js

@@ -1,7 +1,7 @@
-import"./index-z5xv3ffk.js";
+import"./index-g0ah4ehn.js";
 import {
   streamBatch2
-} from "./index-xf6qpmgy.js";
+} from "./index-psw9s799.js";
 import {
   localDate
 } from "./index-115syy01.js";

package/dist/plan.d.ts

@@ -64,6 +64,11 @@ export type PlanContext = {
     /** Keys for filters on open dimensions, after label resolution, by dimension. */
     resolvedValues: ReadonlyMap<string, readonly (string | number)[]>;
 };
+/**
+ * The measures the database computes for `keys`: a resolved measure brings the measures it
+ * uses instead of itself.
+ */
+export declare function sqlMeasures(dataset: AnyDataset, keys: readonly string[]): string[];
 /** Output column aliases. Keys come from definitions, never from input. */
 export declare const columnAlias: {
     measure: (key: string) => string;
@@ -85,10 +90,11 @@ export type ShapedValue = {
     label: string;
 };
 export type ShapedRow = Record<string, ShapedValue | number | null>;
-/** Decodes measures in one raw row; counts are never null. */
+/** Decodes measures in one raw row; counts are never null. Resolved measures are left out. */
 export declare function shapeMeasures(dataset: AnyDataset, measures: readonly string[], raw: Record<string, unknown>, dialect: Dialect): Record<string, number | null>;
 export declare function shapeRows(dataset: AnyDataset, query: NormalizedQuery, rawRows: readonly Record<string, unknown>[], dialect: Dialect): {
     rows: ShapedRow[];
+    kept: readonly Record<string, unknown>[];
     truncated: boolean;
 };
 /** Notes a reader needs to read the numbers right. */

package/dist/query.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { AnyDataset, Dataset, DimensionValue, MeasureValue } from './dataset.js';
+import type { AnyDataset, Dataset, DimensionValue, MeasureValue, SqlMeasureKey } from './dataset.js';
 import { type PeriodInput } from './period.js';
 export declare const MAX_MEASURES = 4;
 export declare const MAX_GROUP_BY = 2;
@@ -61,7 +61,7 @@ export type DatasetQuery<DS> = DS extends Dataset<infer K, infer M, infer Dm, in
     time?: T | undefined;
     compareToPrevious?: boolean | undefined;
     sort?: {
-        by: (keyof M & string) | GroupableKey<Dm>;
+        by: SqlMeasureKey<M> | GroupableKey<Dm>;
         direction?: 'asc' | 'desc' | undefined;
     } | undefined;
     limit?: number | undefined;

package/dist/testing.js

@@ -3,11 +3,11 @@ import {
   allTenants2,
   isAnalyticsError2,
   createAnalytics2
-} from "./index-z5xv3ffk.js";
+} from "./index-g0ah4ehn.js";
 import {
   measure2,
   dimension2
-} from "./index-pgccd363.js";
+} from "./index-rgqsrd72.js";
 
 // src/testing.ts
 var COUNT = "__contractCount";
@@ -17,10 +17,11 @@ async function checkDatasetContract(options) {
   const timezone = options.timezone ?? "Pacific/Auckland";
   const period = options.period ?? { last: { days: 365 } };
   const emptyTenant = options.emptyTenant ?? (typeof options.tenant === "number" ? -1 : "__contract_empty_tenant__");
+  const sqlMeasures = Object.entries(dataset.measures).filter(([, entry]) => entry.kind !== "resolved");
   const probe = {
     ...dataset,
     measures: {
-      ...dataset.measures,
+      ...Object.fromEntries(sqlMeasures),
       [COUNT]: measure2.count({ label: "Rows" })
     },
     dimensions: {
@@ -67,7 +68,7 @@ async function checkDatasetContract(options) {
       message: `${scope} has no rows in the period; the checks below prove little`
     });
   }
-  for (const key of Object.keys(dataset.measures)) {
+  for (const [key] of sqlMeasures) {
     await check(`measure ${key}`, async () => {
       const value = (await run({ measures: [key] })).totals[key];
       if (value !== null && typeof value !== "number")

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "measurr",
-	"version": "0.6.0",
+	"version": "0.7.0",
 	"description": "A small typed semantic layer: datasets of measures and dimensions compiled to one SQL statement per dialect.",
 	"type": "module",
 	"module": "./dist/index.js",
@@ -22,6 +22,7 @@
 		"analytics",
 		"sql",
 		"postgres",
+		"clickhouse",
 		"zod",
 		"llm-tools"
 	],
@@ -45,6 +46,12 @@
 			"import": "./dist/dialects/postgres.js",
 			"default": "./dist/dialects/postgres.js"
 		},
+		"./clickhouse": {
+			"types": "./dist/dialects/clickhouse.d.ts",
+			"bun": "./src/dialects/clickhouse.ts",
+			"import": "./dist/dialects/clickhouse.js",
+			"default": "./dist/dialects/clickhouse.js"
+		},
 		"./shapes": {
 			"types": "./dist/shapes.d.ts",
 			"bun": "./src/shapes.ts",
@@ -72,7 +79,7 @@
 	},
 	"scripts": {
 		"build": "rm -rf dist && bun run build:js && bun run build:types",
-		"build:js": "bun build ./src/index.ts ./src/dialects/postgres.ts ./src/shapes.ts ./src/handler.ts ./src/metrics.ts ./src/testing.ts --root ./src --outdir ./dist --target node --packages external --splitting",
+		"build:js": "bun build ./src/index.ts ./src/dialects/postgres.ts ./src/dialects/clickhouse.ts ./src/shapes.ts ./src/handler.ts ./src/metrics.ts ./src/testing.ts --root ./src --outdir ./dist --target node --packages external --splitting",
 		"build:types": "tsgo -p tsconfig.build.json",
 		"prepublishOnly": "bun run build",
 		"test": "bun test",

package/src/analytics.ts

@@ -4,9 +4,13 @@ import type {
 	AnyDataset,
 	AnyDimension,
 	AnyMeasure,
-	Dataset
+	Dataset,
+	DimensionValue,
+	MeasureValue,
+	ResolvedMeasure
 } from './dataset.js'
 import {
+	type NormalizedFilter,
 	type NormalizedQuery,
 	type ParsedQuery,
 	type PlanContext,
@@ -31,6 +35,7 @@ import {
 	type DatasetQuery,
 	type QueryResult,
 	type ResultOf,
+	type ResultPeriod,
 	buildQuerySchema,
 	datasetResultSchema
 } from './query.js'
@@ -128,6 +133,65 @@ export type AccessKey<D> =
 		? NonNullable<(M & Dm)[keyof (M & Dm)]['access']>
 		: never
 
+/** The resolved measures of a dataset. */
+export type ResolvedKey<D> =
+	D extends Dataset<string, infer M>
+		? {
+				[K in keyof M & string]: M[K] extends { kind: 'resolved' } ? K : never
+			}[keyof M & string]
+		: never
+
+/** The values of the measures resolved measure `K` uses. */
+type UsedValues<D, K> =
+	D extends Dataset<string, infer M>
+		? M[K & keyof M] extends ResolvedMeasure<MeasureResult, infer U>
+			? { [Used in U & keyof M]: MeasureValue<M[Used]> }
+			: never
+		: never
+
+type MeasureResult = ResolvedMeasure['result']
+
+/** What a resolver gets for one period of one query. */
+export type ResolverInput<D, K, Ctx> =
+	D extends Dataset<string, infer _M, infer Dm>
+		? {
+				/**
+				 * The result rows in order: their grouped dimensions and the measures `K` uses. One
+				 * row when the query has no `groupBy`.
+				 */
+				rows: readonly {
+					dimensions: { [G in keyof Dm]?: DimensionValue<Dm[G]> }
+					values: UsedValues<D, K>
+				}[]
+				/** The used measures over every row of the period, ungrouped. */
+				totals: UsedValues<D, K>
+				groupBy: readonly (keyof Dm & string)[]
+				/** The query's filters, open-dimension labels already resolved to keys. */
+				filters: readonly NormalizedFilter[]
+				/** The period being resolved: the query's, or its previous one. */
+				period: ResultPeriod
+				tenant: Tenant
+				ctx: Ctx
+			}
+		: never
+
+/** One value per row, in the same order, and one for the totals. */
+export type ResolverOutput = {
+	rows: readonly (number | null)[]
+	totals: number | null
+}
+
+export type MeasureResolver<D, K, Ctx> = (
+	input: ResolverInput<D, K, Ctx>
+) => ResolverOutput | Promise<ResolverOutput>
+
+/** The code for every resolved measure, by dataset and measure. */
+export type AnalyticsResolvers<DS extends readonly AnyDataset[], Ctx> = {
+	[D in DS[number] as [ResolvedKey<D>] extends [never] ? never : D['key']]: {
+		[K in ResolvedKey<D>]: MeasureResolver<D, K, Ctx>
+	}
+}
+
 export type AnalyticsOptions<DS extends readonly AnyDataset[], Ctx> = {
 	datasets: DS
 	/** Databases by name; a dataset's `source` picks one, or the only one is used. */
@@ -179,6 +243,13 @@ export type AnalyticsOptions<DS extends readonly AnyDataset[], Ctx> = {
 	 * swallowed: a failing cache is a miss, never a failed query.
 	 */
 	cache?: AnalyticsCache<Ctx, DS[number]['key']> | undefined
+	/**
+	 * The code for `measure.resolved` measures, by dataset and measure key: called once per
+	 * period with the result rows and the values of the measures each one uses. Required for
+	 * every resolved measure (`createAnalytics` throws otherwise). What it throws fails the
+	 * query; a value that is not a finite number counts as null.
+	 */
+	resolvers?: NoInfer<AnalyticsResolvers<DS, Ctx>> | undefined
 }
 
 /**
@@ -272,6 +343,9 @@ export type AnalyticsResult<A, Q> =
 
 type ShapedResult = QueryResult<Row, Row>
 
+// biome-ignore lint/suspicious/noExplicitAny: resolvers are typed per dataset where they are declared.
+type AnyResolver = (input: any) => ResolverOutput | Promise<ResolverOutput>
+
 /** A measure or dimension marked with `access`, with every access key it needs. */
 type RestrictedField = {
 	kind: 'measure' | 'dimension'
@@ -318,6 +392,33 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 		restrictedOf.set(dataset.key, restricted)
 	}
 
+	const resolvers = (options.resolvers ?? {}) as Record<
+		string,
+		Record<string, AnyResolver> | undefined
+	>
+	for (const [datasetKey, entries] of Object.entries(resolvers)) {
+		const dataset = byKey.get(datasetKey)
+		if (!dataset)
+			throw new Error(`Resolvers name unknown dataset ${datasetKey}`)
+		for (const key of Object.keys(entries ?? {})) {
+			const entry: AnyMeasure | undefined = dataset.measures[key]
+			if (entry?.kind !== 'resolved') {
+				throw new Error(
+					`Resolvers name ${datasetKey}.${key}, which is not a resolved measure`
+				)
+			}
+		}
+	}
+	for (const dataset of datasets) {
+		for (const [key, entry] of Object.entries<AnyMeasure>(dataset.measures)) {
+			if (entry.kind === 'resolved' && !resolvers[dataset.key]?.[key]) {
+				throw new Error(
+					`Dataset ${dataset.key} resolves ${key} in the app, but createAnalytics has no resolver for it`
+				)
+			}
+		}
+	}
+
 	const now = options.now ?? (() => new Date())
 	const querySchemas = new Map<string, z.ZodType>()
 	const resultSchemas = new Map<string, z.ZodType>()
@@ -507,7 +608,10 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 		return { dataset, query, tenant, timezone, period, previous, now: at }
 	}
 
-	const runQuery = async (prepared: Prepared): Promise<ShapedResult> => {
+	const runQuery = async (
+		prepared: Prepared,
+		ctx: Ctx
+	): Promise<ShapedResult> => {
 		const { dataset, query, tenant, timezone, period, previous, now } = prepared
 		const source = sourceFor(dataset)
 		const { dialect } = source
@@ -523,6 +627,8 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 			dialect
 		)
 
+		const range = ({ from, to }: ResolvedPeriod) => ({ from, to, timezone })
+
 		const runPeriod = async (target: ResolvedPeriod | null) => {
 			const statements = periodStatements(dataset, query, {
 				tenant,
@@ -536,14 +642,63 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 				statements.totals ? run(statements.totals) : null
 			])
 
-			const { rows, truncated } = shapeRows(dataset, query, rawRows, dialect)
+			const { rows, kept, truncated } = shapeRows(
+				dataset,
+				query,
+				rawRows,
+				dialect
+			)
 			const totalsRow = (rawTotals ?? rawRows)[0] ?? {}
 			const totals = shapeMeasures(dataset, query.measures, totalsRow, dialect)
 
+			for (const key of query.measures) {
+				const entry: AnyMeasure | undefined = dataset.measures[key]
+				if (entry?.kind !== 'resolved') continue
+
+				const used = (raw: Row) =>
+					shapeMeasures(dataset, entry.uses, raw, dialect)
+				const resolver = resolvers[dataset.key]?.[key]
+				if (!resolver) throw new Error(`No resolver for ${dataset.key}.${key}`)
+
+				const output = await resolver({
+					rows: kept.map((raw, index) => ({
+						dimensions: Object.fromEntries(
+							query.groupBy.map((group) => [group, rows[index]?.[group]])
+						),
+						values: used(raw)
+					})),
+					totals: used(totalsRow),
+					groupBy: query.groupBy,
+					filters: query.filters.map((filter) => {
+						const resolved = resolvedValues.get(filter.dimension)
+						return resolved && 'values' in filter
+							? { ...filter, values: [...resolved] }
+							: filter
+					}),
+					period: target ? range(target) : { all: true, timezone },
+					tenant,
+					ctx
+				})
+				if (output.rows.length !== rows.length) {
+					throw new Error(
+						`The resolver for ${dataset.key}.${key} returned ${output.rows.length} values for ${rows.length} rows`
+					)
+				}
+
+				const value = (raw: number | null | undefined) => {
+					const finite =
+						typeof raw === 'number' && Number.isFinite(raw) ? raw : null
+					return entry.result === 'count' ? (finite ?? 0) : finite
+				}
+				rows.forEach((row, index) => {
+					row[key] = value(output.rows[index])
+				})
+				totals[key] = value(output.totals)
+			}
+
 			return { rows, totals, truncated }
 		}
 
-		const range = ({ from, to }: ResolvedPeriod) => ({ from, to, timezone })
 		const [current, before] = await Promise.all([
 			runPeriod(period),
 			previous &&
@@ -619,7 +774,7 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 			let result = key ? await cachedResult(key, entry) : null
 			if (key) cache = result ? 'hit' : 'miss'
 			if (!result) {
-				result = await runQuery(prepared)
+				result = await runQuery(prepared, ctx)
 				if (key) store(key, result, entry)
 			}
 
@@ -918,14 +1073,23 @@ function decodeKey(value: unknown, dialect: Dialect): string | number {
  */
 function restrictedFields(dataset: AnyDataset): RestrictedField[] {
 	const measures: Record<string, AnyMeasure> = dataset.measures
-	// defineDataset refuses ratio cycles.
+	// defineDataset refuses ratio cycles, and resolved measures use only SQL measures.
 	const accessOf = (key: string): string[] => {
 		const entry = measures[key]
 		if (!entry) return []
 		const own = entry.access === undefined ? [] : [entry.access]
-		return entry.kind === 'ratio'
-			? [...own, ...accessOf(entry.numerator), ...accessOf(entry.denominator)]
-			: own
+		switch (entry.kind) {
+			case 'ratio':
+				return [
+					...own,
+					...accessOf(entry.numerator),
+					...accessOf(entry.denominator)
+				]
+			case 'resolved':
+				return [...own, ...entry.uses.flatMap(accessOf)]
+			default:
+				return own
+		}
 	}
 
 	return [

package/src/dataset.ts

@@ -76,7 +76,29 @@ export type RatioMeasure<
 	readonly denominator: B
 }
 
-export type AnyMeasure = AggregateMeasure | ShareMeasure | RatioMeasure
+/**
+ * A value the app computes after the query runs, from the measures it `uses` in each row and
+ * from anything else it can reach (another database, a forecast). The `resolvers` option of
+ * `createAnalytics` supplies the code.
+ */
+export type ResolvedMeasure<
+	R extends MeasureResult = MeasureResult,
+	U extends string = string
+> = {
+	readonly kind: 'resolved'
+	readonly result: R
+	readonly label: string
+	readonly description: string | undefined
+	/** A resolved measure also needs the access of the measures it uses. */
+	readonly access: string | undefined
+	readonly uses: readonly U[]
+}
+
+export type AnyMeasure =
+	| AggregateMeasure
+	| ShareMeasure
+	| RatioMeasure
+	| ResolvedMeasure
 
 /** The TypeScript type of a measure's value in a result row. */
 export type MeasureValue<M> = M extends { result: 'count' }
@@ -198,6 +220,41 @@ export const measure = {
 			numerator,
 			denominator
 		}
+	},
+
+	resolved
+}
+
+/**
+ * A value the app computes after the query runs, for numbers one statement cannot give:
+ * another database, a forecast, a per-day average. `uses` names the measures of this dataset
+ * the resolver reads from each row; they are fetched even when the query does not ask for
+ * them. The code goes in `createAnalytics({ resolvers })`. Queries cannot sort by it, since
+ * the database limits the rows before the value exists.
+ */
+function resolved<R extends MeasureResult, Access extends string = never>(
+	options: Described<Access> & { result: R; uses?: undefined }
+): ResolvedMeasure<R, never> & Marked<NoInfer<Access>>
+function resolved<
+	R extends MeasureResult,
+	const U extends string,
+	Access extends string = never
+>(
+	options: Described<Access> & { result: R; uses: readonly U[] }
+): ResolvedMeasure<R, U> & Marked<NoInfer<Access>>
+function resolved(
+	options: Described & {
+		result: MeasureResult
+		uses?: readonly string[] | undefined
+	}
+): ResolvedMeasure {
+	return {
+		kind: 'resolved',
+		result: options.result,
+		label: options.label,
+		description: options.description,
+		access: options.access,
+		uses: options.uses ?? []
 	}
 }
 
@@ -618,14 +675,24 @@ export type Dataset<
 // biome-ignore lint/suspicious/noExplicitAny: the widest dataset, used only as a constraint.
 export type AnyDataset = Dataset<string, any, any, string>
 
-/** Ratio measures may only name other measures of the same dataset. */
+/** Measures the database computes: everything but resolved measures. */
+export type SqlMeasureKey<M> = {
+	[Key in keyof M & string]: M[Key] extends { kind: 'resolved' } ? never : Key
+}[keyof M & string]
+
+/**
+ * Ratio measures may only name other SQL measures of the same dataset, and resolved measures
+ * may only use SQL measures.
+ */
 type CheckMeasures<M> = {
 	[Key in keyof M]: M[Key] extends { kind: 'ratio' }
 		? {
-				numerator: Exclude<keyof M & string, Key>
-				denominator: Exclude<keyof M & string, Key>
+				numerator: Exclude<SqlMeasureKey<M>, Key>
+				denominator: Exclude<SqlMeasureKey<M>, Key>
 			}
-		: unknown
+		: M[Key] extends { kind: 'resolved' }
+			? { uses: readonly SqlMeasureKey<M>[] }
+			: unknown
 }
 
 /** Time dimensions may only name declared time fields. */
@@ -764,6 +831,14 @@ function validateDataset<DS extends AnyDataset>(dataset: DS): DS {
 			if (entry.denominator) check(entry.denominator, `measure ${key}`)
 		}
 		if (entry.kind === 'ratio') checkRatio(measures, key, [], fail)
+		if (entry.kind === 'resolved') {
+			for (const used of entry.uses) {
+				const usedEntry = measures[used]
+				if (!usedEntry) fail(`measure ${key} uses unknown measure ${used}`)
+				if (usedEntry?.kind === 'resolved')
+					fail(`measure ${key} uses ${used}, which is resolved too`)
+			}
+		}
 	}
 
 	const dimensions: Record<string, AnyDimension> = dataset.dimensions
@@ -820,6 +895,8 @@ function checkRatio(
 
 	const entry = measures[key]
 	if (!entry) fail(`ratio measure ${path.at(-1)} names unknown measure ${key}`)
+	if (entry?.kind === 'resolved')
+		fail(`ratio measure ${path.at(-1)} names ${key}, which is resolved`)
 	if (entry?.kind !== 'ratio') return
 
 	checkRatio(measures, entry.numerator, [...path, key], fail)