@hypequery/datasets 0.24.0 → 0.25.0

package/dist/utils/build-dataset-query-builder.d.ts

@@ -1,5 +1,5 @@
 import type { AnyDatasetInstance, DatasetQuery } from '../types.js';
 import type { QueryBuilderLike } from '../query-builder-protocol.js';
 import type { DatasetQueryExecutionOptions } from '../dataset-query.js';
-export declare function buildDatasetQueryBuilder(ds: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions): QueryBuilderLike;
+export declare function buildDatasetQueryBuilder(dataset: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions): QueryBuilderLike;
 //# sourceMappingURL=build-dataset-query-builder.d.ts.map

package/dist/utils/build-dataset-query-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-dataset-query-builder.d.ts","sourceRoot":"","sources":["../../src/utils/build-dataset-query-builder.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAqBrE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,GACpC,gBAAgB,CAwElB"}
+{"version":3,"file":"build-dataset-query-builder.d.ts","sourceRoot":"","sources":["../../src/utils/build-dataset-query-builder.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAgBrE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,GACpC,gBAAgB,CAoElB"}

package/dist/utils/build-dataset-query-builder.js

@@ -1,4 +1,4 @@
-import { datasetSourceBuilder } from './dataset-source.js';
+import { scopedDatasetSource } from './scoped-dataset-source.js';
 import { relationshipMeasureExpressions } from './relationship-measure-sql.js';
 import { measureToAggregationSpec } from './dataset-normalization.js';
 import { applyAggregationSpec } from '../query-planner.js';
@@ -7,31 +7,33 @@ import { assertRawSqlForDialect } from './raw-sql-dialect-check.js';
 import { queryTimeFilter } from './query-timezone.js';
 import { selectedTimeMeasures } from './time-query-measures.js';
 import { baseMeasureNames, getBaseMeasure } from './dataset-measures.js';
-import { appendOrderLimitOffset, applyMeasureDefinition, buildDimensionSelectionPlan, resolveDimensionExpression, resolveFilterField, resolveTenantFilterColumn, } from '../query-planner.js';
+import { appendOrderLimitOffset, applyMeasureDefinition, buildDimensionSelectionPlan, resolveDimensionExpression, resolveFilterField, } from '../query-planner.js';
 import { validateDatasetQueryInput } from './dataset-query-validation.js';
-import { getRuntimeTenantPredicate } from './tenant-runtime.js';
-import { applyRelationshipJoins, buildRelationshipBuilderContext, qualifyBaseColumn, } from './relationship-builder-plan.js';
+import { buildRelationshipBuilderContext } from './relationship-builder-plan.js';
 import { hasSelectedDerivedMeasure, } from './dataset-derived-query.js';
 import { segmentFilters } from './segments.js';
-export function buildDatasetQueryBuilder(ds, query, options) {
-    if (selectedTimeMeasures(ds, query).size) {
+import { datasetOnTimeKey } from './dataset-time-keys.js';
+export function buildDatasetQueryBuilder(dataset, query, options) {
+    if (selectedTimeMeasures(dataset, query).size) {
         throw new Error('A time-based dataset query needs the time-measure SQL planner; use createDatasetClient().toSQL().');
     }
-    if (hasSelectedDerivedMeasure(ds, query)) {
+    if (hasSelectedDerivedMeasure(dataset, query)) {
         throw new Error('A derived dataset query needs the outer SQL projection; use createDatasetClient().toSQL().');
     }
     if (query.having?.length) {
         throw new Error('A dataset query with having needs the outer SQL projection; use createDatasetClient().toSQL().');
     }
-    const validation = validateDatasetQueryInput(ds, query, options.context);
+    const validation = validateDatasetQueryInput(dataset, query, options.context);
     if (!validation.valid) {
         throw new Error(`Invalid dataset query: ${validation.errors.join('; ')}`);
     }
+    const ds = datasetOnTimeKey(dataset, query.timeKey);
     const dialect = resolveDatasetSqlDialect(options.builderFactory);
     assertRawSqlForDialect(ds, dialect);
     const joinCtx = buildRelationshipBuilderContext(ds, query, options.context, dialect);
-    let qb = datasetSourceBuilder(options.builderFactory, ds);
-    qb = applyRelationshipJoins(qb, joinCtx);
+    let qb = scopedDatasetSource({
+        builderFactory: options.builderFactory, ds, context: options.context, joinCtx, dialect, timezone: query.timezone,
+    });
     const { selectParts, groupByParts } = buildDimensionSelectionPlan(ds, query.dimensions ?? [], query.by, joinCtx, query.timezone, dialect);
     const measureNames = query.measures ?? baseMeasureNames(ds.measures);
     if (selectParts.length > 0) {
@@ -51,11 +53,6 @@ export function buildDatasetQueryBuilder(ds, query, options) {
             throw new Error(`Measure "${measureName}" is not a base measure.`);
         qb = applyMeasureDefinition(qb, ds, measureName, definition, joinCtx, dialect);
     }
-    const tenantColumn = resolveTenantFilterColumn(ds, options.context);
-    const tenantPredicate = getRuntimeTenantPredicate(options.context);
-    if (tenantPredicate && tenantColumn) {
-        qb = qb.where(qualifyBaseColumn(joinCtx, tenantColumn), tenantPredicate.operator, tenantPredicate.value);
-    }
     for (const filter of query.filters ?? []) {
         const resolvedField = resolveFilterField(ds, filter.field, joinCtx);
         for (const predicate of queryTimeFilter(dialect, ds, filter, resolvedField, query.timezone)) {

package/dist/utils/clickhouse-dataset-sql-dialect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clickhouse-dataset-sql-dialect.d.ts","sourceRoot":"","sources":["../../src/utils/clickhouse-dataset-sql-dialect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAwClG,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,EAAE,sBA8GP,CAAC"}
+{"version":3,"file":"clickhouse-dataset-sql-dialect.d.ts","sourceRoot":"","sources":["../../src/utils/clickhouse-dataset-sql-dialect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAwClG,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,EAAE,sBAiHP,CAAC"}

package/dist/utils/clickhouse-dataset-sql-dialect.js

@@ -69,6 +69,9 @@ export const clickhouseDatasetSqlDialect = Object.freeze({
         throw new Error(`Unsupported literal type in measure filter: ${typeof value}`);
     },
     truncateTime: (time, grain) => `${TRUNCATE_FUNCTIONS[grain]}(${time})`,
+    // Calendar truncation returns a zone-less Date; later day arithmetic on it
+    // would run in the server zone, not the query zone.
+    truncateTimeInZone: (time, grain, timezone) => `toDateTime64(${TRUNCATE_FUNCTIONS[grain]}(${time}), 9, ${timezone})`,
     addTime: (time, amount, grain) => `add${INTERVAL_UNITS[grain]}(${time}, ${amount})`,
     subtractTime: (time, amount, grain) => `subtract${INTERVAL_UNITS[grain]}(${time}, ${amount})`,
     timeDiff: (grain, start, end) => `dateDiff('${grain}', ${start}, ${end})`,

package/dist/utils/compile-dataset-query.d.ts

@@ -6,5 +6,5 @@ export interface PreparedDatasetQuery {
     execute(): Promise<Record<string, unknown>[]>;
 }
 /** The one dispatch point for dataset preview and query-builder execution. */
-export declare function prepareDatasetQuery(dataset: AnyDatasetInstance, input: DatasetQuery, options: DatasetQueryExecutionOptions, mode?: 'execution' | 'logical'): PreparedDatasetQuery;
+export declare function prepareDatasetQuery(source: AnyDatasetInstance, input: DatasetQuery, options: DatasetQueryExecutionOptions, mode?: 'execution' | 'logical'): PreparedDatasetQuery;
 //# sourceMappingURL=compile-dataset-query.d.ts.map

package/dist/utils/compile-dataset-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile-dataset-query.d.ts","sourceRoot":"","sources":["../../src/utils/compile-dataset-query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAA2D,MAAM,2BAA2B,CAAC;AAC7H,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAUpE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;CAC/C;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,IAAI,GAAE,WAAW,GAAG,SAAuB,GAC1C,oBAAoB,CA+DtB"}
+{"version":3,"file":"compile-dataset-query.d.ts","sourceRoot":"","sources":["../../src/utils/compile-dataset-query.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAA2D,MAAM,2BAA2B,CAAC;AAC7H,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAWpE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;CAC/C;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,IAAI,GAAE,WAAW,GAAG,SAAuB,GAC1C,oBAAoB,CAyEtB"}

package/dist/utils/compile-dataset-query.js

@@ -1,3 +1,6 @@
+import { queryReadsFinal, withFinalSafety } from './dataset-source.js';
+import { buildRelationshipBuilderContext } from './relationship-builder-plan.js';
+import { resolveDatasetSqlDialect } from './dataset-sql-dialect.js';
 import { queryMeasureDefinitions } from './relationship-measures.js';
 import { buildDatasetQueryBuilder } from './build-dataset-query-builder.js';
 import { baseMeasureNames } from './dataset-measures.js';
@@ -8,8 +11,12 @@ import { resolveResultLimit } from './result-limits.js';
 import { buildTimeMeasureDatasetSql } from './time-measure-dataset-sql.js';
 import { selectedTimeMeasures } from './time-query-measures.js';
 import { renderStatement } from './statement-parameters.js';
+import { datasetOnTimeKey, selectedTimeKeyError } from './dataset-time-keys.js';
 /** The one dispatch point for dataset preview and query-builder execution. */
-export function prepareDatasetQuery(dataset, input, options, mode = 'execution') {
+export function prepareDatasetQuery(source, input, options, mode = 'execution') {
+    // Every planner below compiles against the selected time axis. An unknown
+    // axis is left for each planner's validation to report as a query error.
+    const dataset = selectedTimeKeyError(source, input.timeKey) ? source : datasetOnTimeKey(source, input.timeKey);
     const query = structuredClone({
         ...input,
         limit: mode === 'execution' ? resolveResultLimit(input.limit, dataset.limits).limit : input.limit,
@@ -24,11 +31,14 @@ export function prepareDatasetQuery(dataset, input, options, mode = 'execution')
     let execute;
     let plan;
     const abortSignal = options.context?.abortSignal;
+    // Raw-SQL plans lose builder settings, so they carry the FINAL pin in their SQL.
+    // Called after planning, which validates the query and its enforced constraints.
+    const readsFinal = () => queryReadsFinal(dataset, buildRelationshipBuilderContext(dataset, query, options.context, resolveDatasetSqlDialect(options.builderFactory)));
     if (selectedTimeMeasures(dataset, query).size) {
         plan = 'time';
         const planned = buildTimeMeasureDatasetSql(dataset, query, executionOptions);
-        const main = renderStatement(planned.statement);
-        const preflight = renderStatement(planned.preflight);
+        const main = withFinalSafety(readsFinal(), renderStatement(planned.statement));
+        const preflight = withFinalSafety(readsFinal(), renderStatement(planned.preflight));
         statement = main;
         preflightStatements.push(preflight);
         execute = async () => {
@@ -38,7 +48,8 @@ export function prepareDatasetQuery(dataset, input, options, mode = 'execution')
     }
     else if (needsOuterDatasetQuery(dataset, query)) {
         plan = hasSelectedDerivedMeasure(dataset, query) ? 'derived' : 'aggregate';
-        statement = renderStatement(buildDerivedDatasetSql(dataset, query, executionOptions, buildDatasetQueryBuilder));
+        const derived = renderStatement(buildDerivedDatasetSql(dataset, query, executionOptions, buildDatasetQueryBuilder));
+        statement = withFinalSafety(readsFinal(), derived);
         execute = () => options.builderFactory.rawQuery(statement.sql, statement.parameters, { abortSignal });
     }
     else {
@@ -56,7 +67,7 @@ export function prepareDatasetQuery(dataset, input, options, mode = 'execution')
         filters: Object.freeze((query.filters ?? []).map(({ field, operator }) => Object.freeze({ field, operator }))),
         having: Object.freeze((query.having ?? []).map(({ measure, operator }) => Object.freeze({ measure, operator }))),
         segments: Object.freeze([...(query.segments ?? [])]),
-        by: query.by, timezone: query.timezone,
+        by: query.by, timeKey: query.timeKey, timezone: query.timezone,
         effectiveLimit: query.limit, executionLimit, offset: query.offset ?? 0,
         parameterCount: statement.parameters.length,
         preflightStatementCount: preflightStatements.length,

package/dist/utils/dataset-definition-validation.d.ts

@@ -11,7 +11,7 @@
  *
  * Two categories of check live here:
  *
- * - **Identifier safety.** `source`, `tenantKey`, `timeKey`, dimension columns
+ * - **Identifier safety.** `source`, `tenantKey`, `timeKey`, `timeKeys`, dimension columns
  *   and measure fields are all interpolated into SQL as identifiers. They are
  *   validated once here rather than trusted at every call site that builds a
  *   predicate from them.

package/dist/utils/dataset-definition-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-definition-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-definition-validation.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EAGnB,sBAAsB,EAEvB,MAAM,aAAa,CAAC;AAWrB,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AACzD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC5D,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AA2R/D;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,CAAC,aAAa,EAAE,WAAW,EAAE,gBAAgB,CAAC,GAClE,IAAI,CA+DN"}
+{"version":3,"file":"dataset-definition-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-definition-validation.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EAGnB,sBAAsB,EAEvB,MAAM,aAAa,CAAC;AAWrB,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AACzD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC5D,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AA2R/D;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,CAAC,aAAa,EAAE,WAAW,EAAE,gBAAgB,CAAC,GAClE,IAAI,CAmFN"}

package/dist/utils/dataset-definition-validation.js

@@ -253,6 +253,25 @@ export function validateDatasetDefinition(name, config) {
             assertSafeColumn(name, config.timeKey, 'timeKey');
         }
     }
+    if (config.timeKeys !== undefined) {
+        if (!Array.isArray(config.timeKeys)) {
+            fail(name, 'timeKeys must be an array of dimension names or columns.');
+        }
+        if (config.timeKey === undefined) {
+            fail(name, 'timeKeys requires timeKey, the default time axis.');
+        }
+        if (new Set(config.timeKeys).size !== config.timeKeys.length) {
+            fail(name, 'timeKeys must not contain duplicates.');
+        }
+        for (const timeKey of config.timeKeys) {
+            if (typeof timeKey !== 'string' || timeKey.trim().length === 0) {
+                fail(name, 'timeKeys entries must be non-empty strings.');
+            }
+            if (!(timeKey in (config.dimensions ?? {}))) {
+                assertSafeColumn(name, timeKey, 'timeKeys');
+            }
+        }
+    }
     // A dataset with no dimensions is not rejected here: the query layer already
     // refuses an empty dataset query, which is the honest place for it — a
     // measure-only model is a legitimate thing to define.

package/dist/utils/dataset-query-validation.d.ts

@@ -1,4 +1,4 @@
 import type { AnyDatasetInstance, DatasetQuery, ExecutionContext } from '../types.js';
 import { type ValidationResult } from '../validation.js';
-export declare function validateDatasetQueryInput(ds: AnyDatasetInstance, query: DatasetQuery, context?: ExecutionContext): ValidationResult;
+export declare function validateDatasetQueryInput(dataset: AnyDatasetInstance, query: DatasetQuery, context?: ExecutionContext): ValidationResult;
 //# sourceMappingURL=dataset-query-validation.d.ts.map

package/dist/utils/dataset-query-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-query-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-query-validation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAkB9E,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CA6KlB"}
+{"version":3,"file":"dataset-query-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-query-validation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAoB9E,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CAqLlB"}

package/dist/utils/dataset-query-validation.js

@@ -9,10 +9,19 @@ import { getRuntimeTenantPredicate, validateTenantRuntime, } from './tenant-runt
 import { isQualifiedField, resolveQualifiedField, } from './relationship-fields.js';
 import { validateQualifiedFilter, validateRelationshipTenantRuntime, } from './relationship-validation.js';
 import { segmentSelectionErrors } from './segments.js';
+import { enforcedConstraintErrors } from './enforced-constraints.js';
 import { analyzeTimeMeasureAxis } from './time-measure-axis.js';
 import { datasetHavingErrors } from './dataset-having.js';
-export function validateDatasetQueryInput(ds, query, context) {
-    const errors = [...semanticQuerySyntaxErrors(query), ...queryTimezoneErrors(query.timezone)];
+import { datasetOnTimeKey, selectedTimeKeyError } from './dataset-time-keys.js';
+export function validateDatasetQueryInput(dataset, query, context) {
+    // Validate against the selected time axis, so grain and window checks see it.
+    const timeKeyError = selectedTimeKeyError(dataset, query.timeKey);
+    const ds = timeKeyError ? dataset : datasetOnTimeKey(dataset, query.timeKey);
+    const errors = [
+        ...semanticQuerySyntaxErrors(query),
+        ...queryTimezoneErrors(query.timezone),
+        ...(timeKeyError ? [timeKeyError] : []),
+    ];
     const dimensionNames = Object.keys(ds.dimensions);
     const measureNames = Object.keys(ds.measures);
     const selectedDimensions = query.dimensions ?? [];
@@ -36,6 +45,7 @@ export function validateDatasetQueryInput(ds, query, context) {
     if (relationshipTenantError) {
         errors.push(relationshipTenantError);
     }
+    errors.push(...enforcedConstraintErrors(ds, context, query.filters?.length ?? 0));
     if (selectedDimensions.length === 0 && selectedMeasures.length === 0) {
         errors.push(`Dataset "${ds.name}" query must select at least one dimension or measure.`);
     }

package/dist/utils/dataset-source.d.ts

@@ -1,9 +1,42 @@
 import type { AnyDatasetInstance } from '../types.js';
 import type { QueryBuilderFactoryLike, QueryBuilderLike } from '../query-builder-protocol.js';
+import type { RelationshipBuilderContext } from './relationship-builder-plan.js';
 /**
  * The dataset's source table as a builder, read with `FINAL` when the dataset
- * is declared `final: true`. Every builder-path read of a dataset source goes
+ * declares `rowResolution`. Every builder-path read of a dataset source goes
  * through here so no query can skip row-version resolution.
  */
-export declare function datasetSourceBuilder(builderFactory: Pick<QueryBuilderFactoryLike, 'table'>, ds: Pick<AnyDatasetInstance, 'name' | 'source' | 'final'>): QueryBuilderLike;
+export declare function datasetSourceBuilder(builderFactory: Pick<QueryBuilderFactoryLike, 'table'>, ds: Pick<AnyDatasetInstance, 'name' | 'source' | 'rowResolution'>): QueryBuilderLike;
+/**
+ * A filter moved to PREWHERE runs before `FINAL` and can match an older version
+ * of a row. The server default forbids that; pinning it also covers profiles
+ * that enable it. `readonly = 1` accepts a setting equal to the profile's and
+ * refuses it exactly where the profile is unsafe, so the query fails closed.
+ */
+export declare const FINAL_SAFETY_SETTINGS: {
+    readonly optimize_move_to_prewhere_if_final: 0;
+};
+/**
+ * Whether a query reads a source with `FINAL`: the dataset's own, or a
+ * relationship target it actually joins. Unused relationships don't count, so
+ * a plain query never carries the pin.
+ */
+export declare function queryReadsFinal(ds: Pick<AnyDatasetInstance, 'rowResolution'>, joinCtx: Pick<RelationshipBuilderContext, 'joins'> | undefined): boolean;
+/**
+ * The statement with `FINAL_SAFETY_SETTINGS` in its own SQL, for paths that run
+ * rendered SQL (`rawQuery`), where builder settings don't travel.
+ */
+export declare function withFinalSafety<T extends {
+    sql: string;
+}>(readsFinal: boolean, statement: T): T;
+/**
+ * After `FINAL`, the rows that are current state: not deleted in a
+ * ReplacingMergeTree, positive in a collapsing engine. `FINAL` alone removes
+ * engine-declared deletions on current ClickHouse; the filter covers deletion
+ * columns the engine doesn't declare, older servers and unmatched cancel rows.
+ */
+export declare function currentRowPredicate(ds: Pick<AnyDatasetInstance, 'rowResolution'>): {
+    column: string;
+    value: 0 | 1;
+} | undefined;
 //# sourceMappingURL=dataset-source.d.ts.map

package/dist/utils/dataset-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-source.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAE9F;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,IAAI,CAAC,uBAAuB,EAAE,OAAO,CAAC,EACtD,EAAE,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,GACxD,gBAAgB,CAYlB"}
+{"version":3,"file":"dataset-source.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAC9F,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAEjF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,IAAI,CAAC,uBAAuB,EAAE,OAAO,CAAC,EACtD,EAAE,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,QAAQ,GAAG,eAAe,CAAC,GAChE,gBAAgB,CAgBlB;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;CAAqD,CAAC;AAExF;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,IAAI,CAAC,kBAAkB,EAAE,eAAe,CAAC,EAC7C,OAAO,EAAE,IAAI,CAAC,0BAA0B,EAAE,OAAO,CAAC,GAAG,SAAS,GAC7D,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,CAI/F;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,IAAI,CAAC,kBAAkB,EAAE,eAAe,CAAC,GAC5C;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAA;CAAE,GAAG,SAAS,CAM9C"}

package/dist/utils/dataset-source.js

@@ -1,16 +1,59 @@
 /**
  * The dataset's source table as a builder, read with `FINAL` when the dataset
- * is declared `final: true`. Every builder-path read of a dataset source goes
+ * declares `rowResolution`. Every builder-path read of a dataset source goes
  * through here so no query can skip row-version resolution.
  */
 export function datasetSourceBuilder(builderFactory, ds) {
     const qb = builderFactory.table(ds.source);
-    if (!ds.final) {
+    if (!ds.rowResolution) {
         return qb;
     }
     if (typeof qb.final !== 'function') {
-        throw new Error(`Dataset "${ds.name}" is declared final: true, but the query builder does not implement final(). ` +
+        throw new Error(`Dataset "${ds.name}" reads its source with FINAL, but the query builder does not implement final(). ` +
             'Reading it without FINAL would count every unmerged row version, so the query is refused.');
     }
-    return qb.final();
+    const resolved = qb.final();
+    const safe = resolved.settings ? resolved.settings(FINAL_SAFETY_SETTINGS) : resolved;
+    const current = currentRowPredicate(ds);
+    // Qualified like every base column, so it stays unambiguous once joins are added.
+    return current ? safe.where(`${ds.source}.${current.column}`, 'eq', current.value) : safe;
+}
+/**
+ * A filter moved to PREWHERE runs before `FINAL` and can match an older version
+ * of a row. The server default forbids that; pinning it also covers profiles
+ * that enable it. `readonly = 1` accepts a setting equal to the profile's and
+ * refuses it exactly where the profile is unsafe, so the query fails closed.
+ */
+export const FINAL_SAFETY_SETTINGS = { optimize_move_to_prewhere_if_final: 0 };
+/**
+ * Whether a query reads a source with `FINAL`: the dataset's own, or a
+ * relationship target it actually joins. Unused relationships don't count, so
+ * a plain query never carries the pin.
+ */
+export function queryReadsFinal(ds, joinCtx) {
+    return Boolean(ds.rowResolution) || Boolean(joinCtx?.joins.some(join => join.final));
+}
+/**
+ * The statement with `FINAL_SAFETY_SETTINGS` in its own SQL, for paths that run
+ * rendered SQL (`rawQuery`), where builder settings don't travel.
+ */
+export function withFinalSafety(readsFinal, statement) {
+    if (!readsFinal)
+        return statement;
+    const pins = Object.entries(FINAL_SAFETY_SETTINGS).map(([name, value]) => `${name} = ${value}`);
+    return { ...statement, sql: `${statement.sql} SETTINGS ${pins.join(', ')}` };
+}
+/**
+ * After `FINAL`, the rows that are current state: not deleted in a
+ * ReplacingMergeTree, positive in a collapsing engine. `FINAL` alone removes
+ * engine-declared deletions on current ClickHouse; the filter covers deletion
+ * columns the engine doesn't declare, older servers and unmatched cancel rows.
+ */
+export function currentRowPredicate(ds) {
+    const policy = ds.rowResolution;
+    if (!policy || !('engine' in policy))
+        return undefined;
+    if (policy.engine === 'replacing')
+        return policy.deletedColumn === undefined ? undefined : { column: policy.deletedColumn, value: 0 };
+    return { column: policy.signColumn, value: 1 };
 }

package/dist/utils/dataset-time-keys.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Multiple time axes per dataset (HQ-80).
+ *
+ * `timeKey` is a dataset's default time axis; `timeKeys` names the other axes
+ * a query may select with `query.timeKey`, such as `shipped_at` beside
+ * `created_at`. A query on another axis compiles against a view of the dataset
+ * whose `timeKey` is that axis, so grains, windows, shifts and time-range
+ * checks follow the selection without each of them knowing about it.
+ */
+interface TimeAxes {
+    readonly name?: string;
+    readonly timeKey?: string;
+    readonly timeKeys?: readonly string[];
+}
+/** Every time axis a query may select, the default first; empty without a `timeKey`. */
+export declare function datasetTimeKeys(dataset: TimeAxes): string[];
+/** The validation message for a query's `timeKey` selection, or undefined. */
+export declare function selectedTimeKeyError(dataset: TimeAxes, timeKey: unknown): string | undefined;
+/**
+ * True when a query selects an axis other than the dataset's default. Naming
+ * the default explicitly is the same query as omitting it.
+ */
+export declare function selectsAlternateTimeKey(dataset: TimeAxes, timeKey: string | undefined): timeKey is string;
+/**
+ * The dataset as seen by a query on `timeKey`: the selected axis becomes
+ * `timeKey` and the rest stay declared, so the view is itself a valid dataset
+ * and rebasing it again is a no-op. Throws for an axis the dataset does not
+ * declare; validate first to report it as a query error.
+ */
+export declare function datasetOnTimeKey<TDataset extends TimeAxes>(dataset: TDataset, timeKey: string | undefined): TDataset;
+export {};
+//# sourceMappingURL=dataset-time-keys.d.ts.map

package/dist/utils/dataset-time-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-time-keys.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-time-keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,UAAU,QAAQ;IAChB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,EAAE,CAG3D;AAED,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAW5F;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,IAAI,MAAM,CAEzG;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,SAAS,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CASpH"}

package/dist/utils/dataset-time-keys.js

@@ -0,0 +1,55 @@
+/**
+ * Multiple time axes per dataset (HQ-80).
+ *
+ * `timeKey` is a dataset's default time axis; `timeKeys` names the other axes
+ * a query may select with `query.timeKey`, such as `shipped_at` beside
+ * `created_at`. A query on another axis compiles against a view of the dataset
+ * whose `timeKey` is that axis, so grains, windows, shifts and time-range
+ * checks follow the selection without each of them knowing about it.
+ */
+/** Every time axis a query may select, the default first; empty without a `timeKey`. */
+export function datasetTimeKeys(dataset) {
+    if (!dataset.timeKey)
+        return [];
+    return [dataset.timeKey, ...(dataset.timeKeys ?? []).filter(key => key !== dataset.timeKey)];
+}
+/** The validation message for a query's `timeKey` selection, or undefined. */
+export function selectedTimeKeyError(dataset, timeKey) {
+    if (timeKey === undefined)
+        return undefined;
+    if (typeof timeKey !== 'string')
+        return 'Invalid timeKey: expected a string.';
+    const keys = datasetTimeKeys(dataset);
+    if (keys.length === 0) {
+        return `Cannot select timeKey "${timeKey}" — dataset "${dataset.name}" has no timeKey.`;
+    }
+    if (!keys.includes(timeKey)) {
+        return `Unknown timeKey "${timeKey}" on dataset "${dataset.name}". Available: ${keys.join(', ')}`;
+    }
+    return undefined;
+}
+/**
+ * True when a query selects an axis other than the dataset's default. Naming
+ * the default explicitly is the same query as omitting it.
+ */
+export function selectsAlternateTimeKey(dataset, timeKey) {
+    return timeKey !== undefined && timeKey !== dataset.timeKey;
+}
+/**
+ * The dataset as seen by a query on `timeKey`: the selected axis becomes
+ * `timeKey` and the rest stay declared, so the view is itself a valid dataset
+ * and rebasing it again is a no-op. Throws for an axis the dataset does not
+ * declare; validate first to report it as a query error.
+ */
+export function datasetOnTimeKey(dataset, timeKey) {
+    if (!selectsAlternateTimeKey(dataset, timeKey))
+        return dataset;
+    const error = selectedTimeKeyError(dataset, timeKey);
+    if (error)
+        throw new Error(error);
+    return {
+        ...dataset,
+        timeKey,
+        timeKeys: Object.freeze(datasetTimeKeys(dataset).filter(key => key !== timeKey)),
+    };
+}

package/dist/utils/enforced-constraints.d.ts

@@ -0,0 +1,14 @@
+import type { AnyDatasetInstance, ExecutionContext } from '../types.js';
+/** Constraints are policy, not queries; a handful per call is plenty (RFC 0019). */
+export declare const MAX_ENFORCED_CONSTRAINTS = 32;
+/**
+ * Errors for the call's RFC 0019 enforced constraints on `ds`. A constraint
+ * the dataset cannot enforce refuses the call, with a message that does not
+ * describe the constraint: it is the provider's policy, not the caller's
+ * input. `callerFilters` is the number of filters the caller supplied, which
+ * share the dataset's filter ceiling with the constraints.
+ */
+export declare function enforcedConstraintErrors(ds: AnyDatasetInstance, context: ExecutionContext | undefined, callerFilters: number): string[];
+/** Throws when the call's constraints cannot all be enforced on `ds`. */
+export declare function assertEnforcedConstraints(ds: AnyDatasetInstance, context?: ExecutionContext): void;
+//# sourceMappingURL=enforced-constraints.d.ts.map

package/dist/utils/enforced-constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforced-constraints.d.ts","sourceRoot":"","sources":["../../src/utils/enforced-constraints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAgB,MAAM,aAAa,CAAC;AAKtF,oFAAoF;AACpF,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAiB3C;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,kBAAkB,EACtB,OAAO,EAAE,gBAAgB,GAAG,SAAS,EACrC,aAAa,EAAE,MAAM,GACpB,MAAM,EAAE,CAaV;AAED,yEAAyE;AACzE,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAGlG"}

package/dist/utils/enforced-constraints.js

@@ -0,0 +1,57 @@
+import { isSemanticFilterOperator } from '../constants.js';
+import { validateFilterValue } from '../validation.js';
+import { isQualifiedField, resolveQualifiedField } from './relationship-fields.js';
+import { validateQualifiedFilter } from './relationship-validation.js';
+/** Constraints are policy, not queries; a handful per call is plenty (RFC 0019). */
+export const MAX_ENFORCED_CONSTRAINTS = 32;
+function constraintError(ds, constraint, context) {
+    if (typeof constraint !== 'object' || constraint === null)
+        return true;
+    const filter = constraint;
+    if (typeof filter.field !== 'string' || !isSemanticFilterOperator(filter.operator))
+        return true;
+    if (isQualifiedField(filter.field)) {
+        if (!resolveQualifiedField(ds, filter.field)?.resolved)
+            return true;
+        return validateQualifiedFilter(ds, filter, context) !== null;
+    }
+    if (!Object.hasOwn(ds.filters, filter.field))
+        return true;
+    const definition = ds.filters[filter.field];
+    if (definition.operators && !definition.operators.includes(filter.operator))
+        return true;
+    const fieldType = ds.dimensions[definition.field ?? filter.field]?.fieldType;
+    return !!fieldType && validateFilterValue(filter, fieldType) !== null;
+}
+/**
+ * Errors for the call's RFC 0019 enforced constraints on `ds`. A constraint
+ * the dataset cannot enforce refuses the call, with a message that does not
+ * describe the constraint: it is the provider's policy, not the caller's
+ * input. `callerFilters` is the number of filters the caller supplied, which
+ * share the dataset's filter ceiling with the constraints.
+ */
+export function enforcedConstraintErrors(ds, context, callerFilters) {
+    const constraints = context?.runtime?.constraints;
+    if (constraints === undefined)
+        return [];
+    const unenforceable = [`Dataset "${ds.name}" cannot enforce a runtime constraint.`];
+    if (!Array.isArray(constraints) || constraints.length > MAX_ENFORCED_CONSTRAINTS)
+        return unenforceable;
+    if (constraints.length === 0)
+        return [];
+    const maxFilters = ds.limits?.maxFilters;
+    if (maxFilters && constraints.length > maxFilters)
+        return unenforceable;
+    if (constraints.some(constraint => constraintError(ds, constraint, context)))
+        return unenforceable;
+    if (maxFilters && callerFilters > maxFilters - constraints.length) {
+        return [`Too many filters: ${callerFilters} (max ${maxFilters - constraints.length} under the enforced constraints)`];
+    }
+    return [];
+}
+/** Throws when the call's constraints cannot all be enforced on `ds`. */
+export function assertEnforcedConstraints(ds, context) {
+    const [error] = enforcedConstraintErrors(ds, context, 0);
+    if (error)
+        throw new Error(error);
+}

package/dist/utils/metric-derived-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metric-derived-query.d.ts","sourceRoot":"","sources":["../../src/utils/metric-derived-query.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,uBAAuB,EAAoB,MAAM,8BAA8B,CAAC;AAS9F,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAUvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAKrD,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,cAAc,EAAE,uBAAuB,EACvC,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CAyHlB"}
+{"version":3,"file":"metric-derived-query.d.ts","sourceRoot":"","sources":["../../src/utils/metric-derived-query.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,uBAAuB,EAAoB,MAAM,8BAA8B,CAAC;AAQ9F,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAKvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAMrD,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,cAAc,EAAE,uBAAuB,EACvC,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CAmHlB"}

package/dist/utils/metric-derived-query.js

@@ -1,30 +1,29 @@
-import { datasetSourceBuilder } from './dataset-source.js';
+import { scopedDatasetSource } from './scoped-dataset-source.js';
 import { semanticQuerySyntaxErrors, semanticOrderDirection } from './semantic-query-syntax.js';
 /** Metric SQL compilation; factory selection and execution belong to the client. */
 import { resolveDatasetSqlDialect } from './dataset-sql-dialect.js';
 import { assertRawSqlForDialect } from './raw-sql-dialect-check.js';
-import { applyAggregationSpec, buildDimensionSelectionPlan, resolveDimensionExpression, resolveFilterField, resolveTenantFilterColumn, } from '../query-planner.js';
+import { applyAggregationSpec, buildDimensionSelectionPlan, resolveDimensionExpression, resolveFilterField, } from '../query-planner.js';
 import { queryTimeFilter } from './query-timezone.js';
 import { StatementParameters } from './statement-parameters.js';
 import { formulaExpressionSql } from './derived-measure-sql.js';
 import { isTenantScopedFilter } from './metric-handle.js';
-import { getRuntimeTenantPredicate } from './tenant-runtime.js';
-import { applyRelationshipJoins, buildRelationshipBuilderContext, qualifyBaseColumn, } from './relationship-builder-plan.js';
+import { buildRelationshipBuilderContext } from './relationship-builder-plan.js';
 import { segmentFilters } from './segments.js';
 import { validateSQLIdentifier } from '../sql-utils.js';
 import { isQualifiedField } from './relationship-fields.js';
 import { validateDerivedCteGrouping } from './derived-cte-validation.js';
+import { datasetOnTimeKey } from './dataset-time-keys.js';
 export function buildDerivedMetricSql(ref, spec, query, grain, builderFactory, context) {
     const syntaxErrors = semanticQuerySyntaxErrors(query);
     if (syntaxErrors.length)
         throw new Error(syntaxErrors.join('; '));
     const dialect = resolveDatasetSqlDialect(builderFactory);
     assertRawSqlForDialect(ref.dataset, dialect);
-    const ds = ref.dataset;
+    const ds = datasetOnTimeKey(ref.dataset, query.timeKey);
     const joinCtx = buildRelationshipBuilderContext(ds, query, context, dialect);
     // Build the CTE inner query using the builder
-    let cteBuilder = datasetSourceBuilder(builderFactory, ds);
-    cteBuilder = applyRelationshipJoins(cteBuilder, joinCtx);
+    let cteBuilder = scopedDatasetSource({ builderFactory, ds, context, joinCtx, dialect, timezone: query.timezone });
     const { selectParts, groupByParts } = buildDimensionSelectionPlan(ds, query.dimensions ?? [], grain, joinCtx, query.timezone, dialect);
     if (selectParts.length > 0) {
         cteBuilder = cteBuilder.select(selectParts);
@@ -50,11 +49,6 @@ export function buildDerivedMetricSql(ref, spec, query, grain, builderFactory, c
         aggregateAliases.push(quoted);
     }
     // Filters on CTE
-    const tenantColumn = resolveTenantFilterColumn(ds, context);
-    const tenantPredicate = getRuntimeTenantPredicate(context);
-    if (tenantPredicate && tenantColumn) {
-        cteBuilder = cteBuilder.where(qualifyBaseColumn(joinCtx, tenantColumn), tenantPredicate.operator, tenantPredicate.value);
-    }
     for (const filter of query.filters ?? []) {
         if (isTenantScopedFilter(ds, filter, context)) {
             throw new Error(`Cannot filter on tenant field "${filter.field}" when runtime tenancy enforcement is active.`);

package/dist/utils/metric-query-builder.d.ts

@@ -1,5 +1,5 @@
 import type { MetricRef, MetricQuery, ExecutionContext, TimeGrain } from '../types.js';
 import type { QueryBuilderFactoryLike, QueryBuilderLike } from '../query-builder-protocol.js';
 import type { AggregationSpec, AnyDatasetInstance } from '../types.js';
-export declare function buildMetricQueryBuilder(ref: MetricRef, spec: AggregationSpec, ds: AnyDatasetInstance, query: MetricQuery, grain: TimeGrain | undefined, builderFactory: QueryBuilderFactoryLike, context?: ExecutionContext): QueryBuilderLike;
+export declare function buildMetricQueryBuilder(ref: MetricRef, spec: AggregationSpec, dataset: AnyDatasetInstance, query: MetricQuery, grain: TimeGrain | undefined, builderFactory: QueryBuilderFactoryLike, context?: ExecutionContext): QueryBuilderLike;
 //# sourceMappingURL=metric-query-builder.d.ts.map

package/dist/utils/metric-query-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metric-query-builder.d.ts","sourceRoot":"","sources":["../../src/utils/metric-query-builder.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAkB9F,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEvE,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,eAAe,EACrB,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,cAAc,EAAE,uBAAuB,EACvC,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CA6DlB"}
+{"version":3,"file":"metric-query-builder.d.ts","sourceRoot":"","sources":["../../src/utils/metric-query-builder.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAa9F,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEvE,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,cAAc,EAAE,uBAAuB,EACvC,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CAsDlB"}