@hypequery/datasets 0.20.0 → 0.22.0

package/dist/utils/relationship-measures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationship-measures.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-measures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAMjG,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,sBAAsB,CAAC;IACrC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAED,iFAAiF;AACjF,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,2BAA2B,CAkB5G;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAS9H;AAED,yGAAyG;AACzG,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,kBAAkB,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,kEAM1F;AAED,kFAAkF;AAClF,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,MAAM,EAAO;;;;;;;;SAIlH"}

package/dist/utils/relationship-measures.js

@@ -0,0 +1,62 @@
+import { isBaseMeasure } from './dataset-measures.js';
+import { parseQualifiedField, resolveQualifiedField } from './relationship-fields.js';
+const DUPLICATE_INSENSITIVE = new Set(['countDistinct', 'approxCountDistinct', 'min', 'max', 'argMax', 'argMin']);
+/** Resolve only the one-hop, duplicate-safe aggregate vocabulary of RFC 0015. */
+export function resolveRelationshipMeasure(ds, name) {
+    const parsed = parseQualifiedField(name);
+    if (!parsed || parsed.field.includes('.'))
+        throw new Error(`Measure "${name}" must use a one-hop relationship path.`);
+    const relationship = Object.hasOwn(ds.relationships, parsed.relationship) ? ds.relationships[parsed.relationship] : undefined;
+    if (!relationship)
+        throw new Error(`Unknown relationship "${parsed.relationship}" in measure "${name}".`);
+    if (relationship.kind === 'hasMany')
+        throw new Error(`Measure "${name}" cannot traverse hasMany: it would fan out aggregates.`);
+    const target = relationship.target();
+    const definition = Object.hasOwn(target.measures, parsed.field) ? target.measures[parsed.field] : undefined;
+    if (!definition)
+        throw new Error(`Unknown measure "${parsed.field}" on relationship target "${target.name}".`);
+    if (!isBaseMeasure(definition))
+        throw new Error(`Measure "${name}" must reference a base aggregate; derived, window, and shift measures are not selectable through relationships.`);
+    if (relationship.kind === 'belongsTo' && !DUPLICATE_INSENSITIVE.has(definition.aggregation)) {
+        throw new Error(`Measure "${name}" cannot use ${definition.aggregation} through belongsTo: repeated target rows would inflate the aggregation. Use a duplicate-insensitive measure or query the target dataset.`);
+    }
+    const referenced = [definition.field, definition.argField, ...(definition.filters ?? []).map(filter => target.filters[filter.field]?.field ?? filter.field)];
+    if (definition.sql || referenced.some(field => field && target.dimensions[field]?.sql)) {
+        throw new Error(`SQL-backed measure "${name}" or its inputs cannot be traversed through relationships.`);
+    }
+    return { relationshipName: parsed.relationship, relationship, target, definition };
+}
+export function listRelationshipMeasures(name, relationship) {
+    if (relationship.kind === 'hasMany')
+        return {};
+    const ds = { relationships: { [name]: relationship } };
+    const target = relationship.target();
+    return Object.fromEntries(Object.keys(target.measures).flatMap(measure => {
+        const qualified = `${name}.${measure}`;
+        try {
+            return [[qualified, resolveRelationshipMeasure(ds, qualified).definition]];
+        }
+        catch {
+            return [];
+        }
+    }));
+}
+/** Expand selected relationship aggregates for dependency graphs without changing author definitions. */
+export function queryMeasureDefinitions(ds, selected) {
+    const qualified = selected.filter(name => name.includes('.'));
+    return qualified.length ? {
+        ...ds.measures,
+        ...Object.fromEntries(qualified.map(name => [name, resolveRelationshipMeasure(ds, name).definition])),
+    } : ds.measures;
+}
+/** Resolve a selected measure or a dimension reference while collecting joins. */
+export function resolveRelationshipReference(ds, name, measures = []) {
+    if (!measures.includes(name))
+        return resolveQualifiedField(ds, name);
+    try {
+        return { resolved: resolveRelationshipMeasure(ds, name) };
+    }
+    catch (error) {
+        return { error: error.message };
+    }
+}

package/dist/utils/relationship-validation.d.ts

@@ -3,7 +3,7 @@
  * dataset-query and metric-query validators.
  */
 import type { AnyDatasetInstance, DatasetQuery, ExecutionContext, MetricFilter, MetricQuery } from '../types.js';
-type RelationshipQuery = Pick<DatasetQuery & MetricQuery, 'dimensions' | 'filters' | 'orderBy'>;
+type RelationshipQuery = Pick<DatasetQuery & MetricQuery, 'dimensions' | 'filters' | 'orderBy'> & Pick<DatasetQuery, 'measures'>;
 /**
  * Tenant-less base datasets may still reach tenant-scoped data through a
  * relationship. Require either a concrete runtime tenant or the trusted

package/dist/utils/relationship-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationship-validation.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACZ,MAAM,aAAa,CAAC;AAWrB,KAAK,iBAAiB,GAAG,IAAI,CAC3B,YAAY,GAAG,WAAW,EAC1B,YAAY,GAAG,SAAS,GAAG,SAAS,CACrC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,iBAAiB,EACxB,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,GAAG,SAAS,CAmBpB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,kBAAkB,EACtB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,GAAG,IAAI,CA4Bf"}
+{"version":3,"file":"relationship-validation.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-validation.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACZ,MAAM,aAAa,CAAC;AAWrB,KAAK,iBAAiB,GAAG,IAAI,CAC3B,YAAY,GAAG,WAAW,EAC1B,YAAY,GAAG,SAAS,GAAG,SAAS,CACrC,GAAG,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;AAEnC;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,iBAAiB,EACxB,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,GAAG,SAAS,CAoBpB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,kBAAkB,EACtB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,GAAG,IAAI,CA4Bf"}

package/dist/utils/relationship-validation.js

@@ -1,7 +1,4 @@
-/**
- * Shared validation for relationship-qualified filters, used by both the
- * dataset-query and metric-query validators.
- */
+import { resolveRelationshipReference } from './relationship-measures.js';
 import { validateFilterValue } from '../validation.js';
 import { getRuntimeTenantPredicate, hasTenantRuntime, } from './tenant-runtime.js';
 import { isQualifiedField, resolveQualifiedField, } from './relationship-fields.js';
@@ -16,11 +13,12 @@ export function validateRelationshipTenantRuntime(ds, query, context) {
     }
     const referenced = [
         ...(query.dimensions ?? []),
+        ...(query.measures ?? []),
         ...(query.filters ?? []).map((filter) => filter.field),
         ...(query.orderBy ?? []).map((order) => order.field),
     ].filter(isQualifiedField);
     for (const name of referenced) {
-        const resolution = resolveQualifiedField(ds, name);
+        const resolution = resolveRelationshipReference(ds, name, query.measures);
         if (resolution?.resolved?.target.tenantKey) {
             return `Dataset "${ds.name}" requires runtime tenant scoping because relationship "${resolution.resolved.relationshipName}" targets a tenant-scoped dataset.`;
         }

package/dist/utils/semantic-query-syntax.d.ts

@@ -0,0 +1,6 @@
+import type { DatasetQuery, MetricQuery } from '../types.js';
+/** Reject SQL structure outside the semantic contract before reaching a builder. */
+export declare function semanticQuerySyntaxErrors(query: DatasetQuery | MetricQuery): string[];
+/** Never interpolate a caller-provided direction into raw SQL. */
+export declare function semanticOrderDirection(direction: unknown): 'ASC' | 'DESC';
+//# sourceMappingURL=semantic-query-syntax.d.ts.map

package/dist/utils/semantic-query-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-query-syntax.d.ts","sourceRoot":"","sources":["../../src/utils/semantic-query-syntax.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI7D,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,YAAY,GAAG,WAAW,GAAG,MAAM,EAAE,CAarF;AAED,kEAAkE;AAClE,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAIzE"}

package/dist/utils/semantic-query-syntax.js

@@ -0,0 +1,25 @@
+import { SEMANTIC_FILTER_OPERATORS } from '../constants.js';
+const FILTER_OPERATORS = new Set(SEMANTIC_FILTER_OPERATORS);
+/** Reject SQL structure outside the semantic contract before reaching a builder. */
+export function semanticQuerySyntaxErrors(query) {
+    const errors = [];
+    for (const filter of query.filters ?? []) {
+        if (!FILTER_OPERATORS.has(filter.operator)) {
+            errors.push(`Unsupported semantic filter operator "${String(filter.operator)}".`);
+        }
+    }
+    for (const order of query.orderBy ?? []) {
+        if (order.direction !== 'asc' && order.direction !== 'desc') {
+            errors.push('Invalid order direction: expected "asc" or "desc".');
+        }
+    }
+    return errors;
+}
+/** Never interpolate a caller-provided direction into raw SQL. */
+export function semanticOrderDirection(direction) {
+    if (direction === 'asc')
+        return 'ASC';
+    if (direction === 'desc')
+        return 'DESC';
+    throw new Error('Invalid order direction: expected "asc" or "desc".');
+}

package/dist/utils/shift-measure-grains.d.ts

@@ -0,0 +1,5 @@
+import type { MeasureTimeInterval, TimeGrain } from '../types.js';
+/** Calendar shifts preserve dates; they do not convert months into fixed durations. */
+export declare function calendarShiftAtFineGrain(interval: MeasureTimeInterval, grain: TimeGrain): boolean;
+export declare function supportsShiftGrain(interval: MeasureTimeInterval, grain: TimeGrain): boolean;
+//# sourceMappingURL=shift-measure-grains.d.ts.map

package/dist/utils/shift-measure-grains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift-measure-grains.d.ts","sourceRoot":"","sources":["../../src/utils/shift-measure-grains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGlE,uFAAuF;AACvF,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAGjG;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAG3F"}

package/dist/utils/shift-measure-grains.js

@@ -0,0 +1,10 @@
+import { intervalBuckets } from './time-axis-intervals.js';
+/** Calendar shifts preserve dates; they do not convert months into fixed durations. */
+export function calendarShiftAtFineGrain(interval, grain) {
+    return ['month', 'quarter', 'year'].includes(interval.unit)
+        && ['minute', 'hour', 'day', 'week'].includes(grain);
+}
+export function supportsShiftGrain(interval, grain) {
+    return calendarShiftAtFineGrain(interval, grain)
+        || intervalBuckets(interval.amount, interval.unit, grain) !== undefined;
+}

package/dist/utils/shift-measure-sql.d.ts

@@ -1,4 +1,4 @@
-import type { ShiftMeasureDefinition, TimeGrain } from '../types.js';
+import type { ShiftMeasureDefinition } from '../types.js';
 import type { TimeMeasureAxis } from './time-measure-axis.js';
 /** Preserve the selected portion of a bucket and both authored endpoint operators. */
 export declare function shiftRangeSql(shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, period?: string): {
@@ -9,10 +9,13 @@ export declare function shiftRangeSql(shift: ShiftMeasureDefinition, axis: TimeM
 };
 export declare function shiftRangePredicateSql(time: string, range: ReturnType<typeof shiftRangeSql>): string;
 /** Check the shifted scan independently of whether it contains source rows. */
-export declare function shiftCalendarGuardSql(shift: ShiftMeasureDefinition, grain: TimeGrain, axisGuard: string): string;
+export declare function shiftCalendarGuardSql(shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, axisGuard: string): string;
+/** Validate each output bucket after the series exists, including empty source populations. */
+export declare function shiftWallTimeSeriesGuardSql(shift: ShiftMeasureDefinition, grain: TimeMeasureAxis['grain']): string;
 /** Map output buckets to their earlier half-open ranges, retaining calendar arithmetic. */
 export declare function shiftBucketCtes(shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, index: number): {
     ctes: string[];
     rowsSql: string;
+    sourceTimesSql: string;
 };
 //# sourceMappingURL=shift-measure-sql.d.ts.map

package/dist/utils/shift-measure-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shift-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-measure-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAQlG;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,GAAG,MAAM,CAGpG;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOhH;AAED,2FAA2F;AAC3F,wBAAgB,eAAe,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAkBxI"}
+{"version":3,"file":"shift-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-measure-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAI1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAI9D,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAclG;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,GAAG,MAAM,CAGpG;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOrH;AAED,+FAA+F;AAC/F,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,MAAM,CAMlH;AAED,2FAA2F;AAC3F,wBAAgB,eAAe,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAsBhK"}

package/dist/utils/shift-measure-sql.js

@@ -1,14 +1,22 @@
 import { GRAIN_FUNCTIONS } from '../constants.js';
 import { addTimeSql, subtractTimeSql } from './time-arithmetic-sql.js';
 import { calendarBucketGuardSql } from './time-axis-calendar-guard.js';
+import { calendarShiftAtFineGrain } from './shift-measure-grains.js';
+import { shiftWallTimeGuardSql } from './shift-wall-time-sql.js';
 /** Preserve the selected portion of a bucket and both authored endpoint operators. */
 export function shiftRangeSql(shift, axis, period) {
-    const end = period ? addTimeSql(period, 1, axis.grain) : undefined;
+    const first = period ?? '_hq_first';
+    const last = period ?? '_hq_last';
+    const end = addTimeSql(last, 1, axis.grain);
+    const upper = subtractTimeSql(`least(${end}, _hq_upper)`, shift.interval.amount, shift.interval.unit);
+    // Clamp the bucket anchor, then retain its width. Independently clamping both
+    // dates would turn March 30–31 into February 28–28, dropping an entire day.
+    const shiftedEnd = addTimeSql(subtractTimeSql(last, shift.interval.amount, shift.interval.unit), 1, axis.grain);
     return {
-        lower: subtractTimeSql(period ? `greatest(${period}, _hq_lower)` : '_hq_lower', shift.interval.amount, shift.interval.unit),
-        upper: subtractTimeSql(end ? `least(${end}, _hq_upper)` : '_hq_upper', shift.interval.amount, shift.interval.unit),
+        lower: subtractTimeSql(`greatest(${first}, _hq_lower)`, shift.interval.amount, shift.interval.unit),
+        upper: calendarShiftAtFineGrain(shift.interval, axis.grain) ? `if(_hq_upper >= ${end}, ${shiftedEnd}, ${upper})` : upper,
         lowerInclusive: period ? `(${period} > _hq_lower OR ${Number(axis.lowerInclusive)})` : String(Number(axis.lowerInclusive)),
-        upperInclusive: end ? `(_hq_upper < ${end} AND ${Number(axis.upperInclusive)})` : String(Number(axis.upperInclusive)),
+        upperInclusive: `(_hq_upper < ${end} AND ${Number(axis.upperInclusive)})`,
     };
 }
 export function shiftRangePredicateSql(time, range) {
@@ -16,14 +24,19 @@ export function shiftRangePredicateSql(time, range) {
         + ` AND (${time} < ${range.upper} OR (${range.upperInclusive} AND ${time} = ${range.upper}))`;
 }
 /** Check the shifted scan independently of whether it contains source rows. */
-export function shiftCalendarGuardSql(shift, grain, axisGuard) {
-    const lower = subtractTimeSql('_hq_first', shift.interval.amount, shift.interval.unit);
-    const upper = subtractTimeSql(addTimeSql('_hq_last', 1, grain), shift.interval.amount, shift.interval.unit);
+export function shiftCalendarGuardSql(shift, axis, axisGuard) {
+    const { grain } = axis;
+    const { lower, upper } = shiftRangeSql(shift, axis);
     const first = `${GRAIN_FUNCTIONS[grain]}(${lower})`;
     const last = `${GRAIN_FUNCTIONS[grain]}(${upper})`;
     const count = `dateDiff('${grain}', ${first}, ${last}) + ${axisGuard}`;
     return calendarBucketGuardSql(first, count, grain);
 }
+/** Validate each output bucket after the series exists, including empty source populations. */
+export function shiftWallTimeSeriesGuardSql(shift, grain) {
+    const end = addTimeSql('_hq_period', 1, grain);
+    return shiftWallTimeGuardSql(shift.interval, grain, '_hq_series CROSS JOIN _hq_bounds', '_hq_period', 'greatest(_hq_period, _hq_lower)', `least(${end}, _hq_upper)`, end);
+}
 /** Map output buckets to their earlier half-open ranges, retaining calendar arithmetic. */
 export function shiftBucketCtes(shift, axis, index) {
     const { grain } = axis;
@@ -33,7 +46,11 @@ export function shiftBucketCtes(shift, axis, index) {
     const bucket = `${GRAIN_FUNCTIONS[grain]}(_hq_shift_lower)`;
     const upperBucket = `${GRAIN_FUNCTIONS[grain]}(_hq_shift_upper)`;
     const count = `greatest(0, dateDiff('${grain}', ${bucket}, ${upperBucket}) + if(_hq_shift_upper > ${upperBucket} OR _hq_shift_upper_inclusive, 1, 0))`;
+    const join = ` AS r INNER JOIN ${keys} AS b ON ${GRAIN_FUNCTIONS[grain]}(r._hq_time) = b._hq_source_period WHERE ${shiftRangePredicateSql('r._hq_time', { lower: 'b._hq_shift_lower', upper: 'b._hq_shift_upper', lowerInclusive: 'b._hq_shift_lower_inclusive', upperInclusive: 'b._hq_shift_upper_inclusive' })}`;
     return {
+        // Membership preserves duplicate source rows while excluding dates and
+        // partial ranges that no output bucket maps to, including clamped overlaps.
+        sourceTimesSql: `SELECT r._hq_time FROM _hq_source${join}`,
         ctes: [
             `${ranges} AS (SELECT _hq_period, ${range.lower} AS _hq_shift_lower, ${range.upper} AS _hq_shift_upper, ${range.lowerInclusive} AS _hq_shift_lower_inclusive, ${range.upperInclusive} AS _hq_shift_upper_inclusive FROM _hq_series CROSS JOIN _hq_bounds)`,
             // A DST transition can map a one-hour output bucket to zero or two
@@ -41,6 +58,6 @@ export function shiftBucketCtes(shift, axis, index) {
             // The equality join avoids a source-rows × output-series Cartesian product.
             `${keys} AS (SELECT *, ${addTimeSql(bucket, `arrayJoin(range(toUInt64(${count})))`, grain)} AS _hq_source_period FROM ${ranges})`,
         ],
-        rowsSql: `SELECT r.*, b._hq_period FROM _hq_scanned AS r INNER JOIN ${keys} AS b ON ${GRAIN_FUNCTIONS[grain]}(r._hq_time) = b._hq_source_period WHERE ${shiftRangePredicateSql('r._hq_time', { lower: 'b._hq_shift_lower', upper: 'b._hq_shift_upper', lowerInclusive: 'b._hq_shift_lower_inclusive', upperInclusive: 'b._hq_shift_upper_inclusive' })}`,
+        rowsSql: `SELECT r.*, b._hq_period FROM _hq_scanned${join}`,
     };
 }

package/dist/utils/shift-measure-validation.js

@@ -1,6 +1,6 @@
 import { isSafeSQLIdentifier } from '../sql-utils.js';
 import { isSupportedTimeGrain } from '../constants.js';
-import { getBaseMeasure, isShiftMeasure } from './dataset-measures.js';
+import { isShiftMeasure } from './dataset-measures.js';
 export function validateShiftMeasures(datasetName, timeKey, measures) {
     for (const [name, definition] of Object.entries(measures)) {
         if (!isShiftMeasure(definition))
@@ -10,8 +10,8 @@ export function validateShiftMeasures(datasetName, timeKey, measures) {
             throw new Error(`${prefix} name is not a safe identifier.`);
         if (!timeKey)
             throw new Error(`${prefix} requires a timeKey.`);
-        if (!getBaseMeasure(measures, definition.measure))
-            throw new Error(`${prefix} must wrap a base measure; "${String(definition.measure)}" is not one.`);
+        if (!Object.hasOwn(measures, definition.measure))
+            throw new Error(`${prefix} references missing measure "${String(definition.measure)}".`);
         const interval = definition.interval;
         if (!interval || !Number.isSafeInteger(interval.amount) || interval.amount <= 0 || !isSupportedTimeGrain(interval.unit)) {
             throw new Error(`${prefix} interval needs a positive safe integer and supported unit.`);

package/dist/utils/shift-wall-time-sql.d.ts

@@ -0,0 +1,4 @@
+import type { MeasureTimeInterval, TimeGrain } from '../types.js';
+/** Reject DST normalization that moves a shifted sub-day bucket to another local time. */
+export declare function shiftWallTimeGuardSql(interval: MeasureTimeInterval, grain: TimeGrain, source: string, period: string, lower: string, upper: string, end: string): string;
+//# sourceMappingURL=shift-wall-time-sql.d.ts.map

package/dist/utils/shift-wall-time-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift-wall-time-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-wall-time-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIlE,0FAA0F;AAC1F,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,MAAM,CAYR"}

package/dist/utils/shift-wall-time-sql.js

@@ -0,0 +1,17 @@
+import { subtractTimeSql } from './time-arithmetic-sql.js';
+import { calendarShiftAtFineGrain } from './shift-measure-grains.js';
+/** Reject DST normalization that moves a shifted sub-day bucket to another local time. */
+export function shiftWallTimeGuardSql(interval, grain, source, period, lower, upper, end) {
+    if (!calendarShiftAtFineGrain(interval, grain) || (grain !== 'minute' && grain !== 'hour'))
+        return '0';
+    const changesWallTime = (value) => {
+        const shifted = subtractTimeSql(value, interval.amount, interval.unit);
+        return ['Hour', 'Minute', 'Second']
+            .map(part => `to${part}(${value}) != to${part}(${shifted})`)
+            .join(' OR ');
+    };
+    const changed = `(${changesWallTime(period)}) OR (${changesWallTime(lower)})`
+        + ` OR (${upper} != ${end} AND (${changesWallTime(upper)}))`;
+    return `(SELECT throwIf(countIf(${changed}) > 0, `
+        + `'Calendar shift lands on a nonexistent local time; use a UTC query timezone.') FROM ${source})`;
+}

package/dist/utils/snapshot-execution-context.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionContext } from '../types.js';
+/** Bind cache identity and deferred execution to the same request-owned scope. */
+export declare function snapshotExecutionContext(context?: ExecutionContext): ExecutionContext | undefined;
+//# sourceMappingURL=snapshot-execution-context.d.ts.map

package/dist/utils/snapshot-execution-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-execution-context.d.ts","sourceRoot":"","sources":["../../src/utils/snapshot-execution-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,kFAAkF;AAClF,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,SAAS,CAajG"}

package/dist/utils/snapshot-execution-context.js

@@ -0,0 +1,16 @@
+/** Bind cache identity and deferred execution to the same request-owned scope. */
+export function snapshotExecutionContext(context) {
+    if (context === undefined)
+        return undefined;
+    return {
+        ...context,
+        ...(context.runtime === undefined ? {} : {
+            runtime: {
+                ...context.runtime,
+                // Copy tenant objects and ID lists; retain adapter and AbortSignal identity.
+                tenant: structuredClone(context.runtime.tenant),
+            },
+        }),
+        ...(context.cache && { cache: { ...context.cache } }),
+    };
+}

package/dist/utils/time-measure-axis-sql.d.ts

@@ -6,6 +6,7 @@ export interface TimeMeasureSqlAxis {
     timeAxisSql: string;
     guard: string;
     rangeGuard: string;
+    postSeriesGuard: string;
 }
 /** Build bounded output buckets using the query timezone. */
 export declare function buildTimeMeasureAxisSql(source: TimeMeasureSqlSource, axis: TimeMeasureAxis, shifts?: readonly ShiftMeasureDefinition[]): TimeMeasureSqlAxis;

package/dist/utils/time-measure-axis-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-measure-axis-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAG1D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAMD,6DAA6D;AAC7D,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,SAAS,sBAAsB,EAAO,GAC7C,kBAAkB,CAwCpB"}
+{"version":3,"file":"time-measure-axis-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAG1D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB;AAMD,6DAA6D;AAC7D,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,SAAS,sBAAsB,EAAO,GAC7C,kBAAkB,CAyCpB"}

package/dist/utils/time-measure-axis-sql.js

@@ -1,7 +1,7 @@
 import { GRAIN_FUNCTIONS } from '../constants.js';
 import { addTimeSql as add, subtractTimeSql as subtract } from './time-arithmetic-sql.js';
 import { calendarBucketGuardSql } from './time-axis-calendar-guard.js';
-import { shiftCalendarGuardSql } from './shift-measure-sql.js';
+import { shiftCalendarGuardSql, shiftWallTimeSeriesGuardSql } from './shift-measure-sql.js';
 function literal(value) {
     return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "''")}'`;
 }
@@ -23,8 +23,9 @@ export function buildTimeMeasureAxisSql(source, axis, shifts = []) {
     const physicalGuard = axis.grain === 'minute' || axis.grain === 'hour'
         ? `throwIf(position(${physicalTimeType}, 'Date') > 0 AND position(${physicalTimeType}, 'DateTime') = 0, 'Sub-day time measures require a time-of-day column; Date and Date32 are not supported.')`
         : '0';
-    const shiftGuards = shifts.map(shift => shiftCalendarGuardSql(shift, axis.grain, `${limitGuard} + ${rangeGuard}`));
+    const shiftGuards = shifts.map(shift => shiftCalendarGuardSql(shift, axis, `${limitGuard} + ${rangeGuard}`));
     const guard = [limitGuard, physicalGuard, calendarGuard, ...shiftGuards].join(' + ');
+    const postSeriesGuard = shifts.map(shift => shiftWallTimeSeriesGuardSql(shift, axis.grain)).join(' + ') || '0';
     // A zero-row scalar retains the converted timestamp type and query timezone.
     // Reading any(time) here would scan the entire population just for its type.
     const timezone = 'timezoneOf(assumeNotNull((SELECT _hq_time FROM _hq_source LIMIT 0)))';
@@ -42,6 +43,6 @@ export function buildTimeMeasureAxisSql(source, axis, shifts = []) {
     ];
     // Always check the singleton axis before aggregating. ClickHouse can skip
     // a series guard when a dimensional CROSS JOIN has an empty population.
-    const timeAxisSql = `WITH ${[...source.ctes, ctes[0]].join(',\n')} SELECT ${guard} + ${rangeGuard} AS _hq_validated FROM _hq_bounds`;
-    return { ctes, timeAxisSql, guard, rangeGuard };
+    const timeAxisSql = `WITH ${[...source.ctes, ...ctes].join(',\n')} SELECT ${guard} + ${rangeGuard} + ${postSeriesGuard} AS _hq_validated FROM _hq_bounds`;
+    return { ctes, timeAxisSql, guard, rangeGuard, postSeriesGuard };
 }

package/dist/utils/time-measure-axis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-measure-axis.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQ7F,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE3E,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,GAClB;IAAE,IAAI,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAmC9C"}
+{"version":3,"file":"time-measure-axis.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAS7F,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE3E,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,GAClB;IAAE,IAAI,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAmC9C"}

package/dist/utils/time-measure-axis.js

@@ -2,7 +2,8 @@ import { isSupportedTimeGrain } from '../constants.js';
 import { selectedTimeMeasures } from './time-query-measures.js';
 import { isShiftMeasure } from './dataset-measures.js';
 import { resolveTimeAxisRange, isDefinitelyEmptyTimeRange } from './time-axis-bounds.js';
-import { intervalBuckets, windowGrainErrors, estimateTimeAxisBuckets, exceedsEstimatedTimeAxisLimit } from './time-axis-intervals.js';
+import { windowGrainErrors, estimateTimeAxisBuckets, exceedsEstimatedTimeAxisLimit } from './time-axis-intervals.js';
+import { supportsShiftGrain } from './shift-measure-grains.js';
 export { intervalBuckets, utcBucketStart } from './time-axis-intervals.js';
 /** Validate time-measure grains, resolve bounds, then estimate the output series. */
 export function analyzeTimeMeasureAxis(dataset, query) {
@@ -16,7 +17,7 @@ export function analyzeTimeMeasureAxis(dataset, query) {
     const grain = query.by;
     for (const [name, window] of timeMeasures) {
         if (isShiftMeasure(window)) {
-            if (intervalBuckets(window.interval.amount, window.interval.unit, grain) === undefined)
+            if (!supportsShiftGrain(window.interval, grain))
                 errors.push(`Shift measure "${name}" must span whole "${grain}" buckets.`);
             continue;
         }

package/dist/utils/time-measure-context-sql.d.ts

@@ -0,0 +1,6 @@
+import type { MeasureEvaluationContext } from './measure-evaluation-graph.js';
+import type { TimeMeasureAxis } from './time-measure-axis.js';
+/** Keep output coordinates separate from each shifted evaluation interval. */
+export declare function timeMeasureContextCtes(contexts: readonly MeasureEvaluationContext[], axis: TimeMeasureAxis): string[];
+export declare function timeMeasureContextGuard(context: MeasureEvaluationContext, axis: TimeMeasureAxis): string;
+//# sourceMappingURL=time-measure-context-sql.d.ts.map

package/dist/utils/time-measure-context-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-measure-context-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-context-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAM9D,8EAA8E;AAC9E,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAUrH;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAOxG"}

package/dist/utils/time-measure-context-sql.js

@@ -0,0 +1,21 @@
+import { addTimeSql as add, subtractTimeSql as subtract } from './time-arithmetic-sql.js';
+import { calendarShiftAtFineGrain } from './shift-measure-grains.js';
+import { calendarBucketGuardSql } from './time-axis-calendar-guard.js';
+import { shiftWallTimeGuardSql } from './shift-wall-time-sql.js';
+/** Keep output coordinates separate from each shifted evaluation interval. */
+export function timeMeasureContextCtes(contexts, axis) {
+    const end = add('_hq_period', 1, axis.grain);
+    const root = `_hq_context0 AS (SELECT _hq_period, _hq_period AS _hq_eval_period, ${end} AS _hq_eval_end, greatest(_hq_period, _hq_lower) AS _hq_eval_lower, least(${end}, _hq_upper) AS _hq_eval_upper, (_hq_period > _hq_lower OR ${Number(axis.lowerInclusive)}) AS _hq_lower_inclusive, (_hq_upper < ${end} AND ${Number(axis.upperInclusive)}) AS _hq_upper_inclusive FROM _hq_series CROSS JOIN _hq_bounds)`;
+    return [root, ...contexts.slice(1).map(context => {
+            const interval = context.interval;
+            const shift = (value) => subtract(`p.${value}`, interval.amount, interval.unit);
+            const period = shift('_hq_eval_period');
+            const shiftedEnd = calendarShiftAtFineGrain(interval, axis.grain) ? add(period, 1, axis.grain) : shift('_hq_eval_end');
+            return `_hq_context${context.id} AS (SELECT p._hq_period, ${period} AS _hq_eval_period, ${shiftedEnd} AS _hq_eval_end, ${shift('_hq_eval_lower')} AS _hq_eval_lower, if(p._hq_eval_upper = p._hq_eval_end, ${shiftedEnd}, ${shift('_hq_eval_upper')}) AS _hq_eval_upper, p._hq_lower_inclusive, p._hq_upper_inclusive FROM _hq_context${context.parent} AS p)`;
+        })];
+}
+export function timeMeasureContextGuard(context, axis) {
+    const guard = calendarBucketGuardSql('_hq_eval_period', '1', axis.grain);
+    const wallTimeGuard = context.interval === undefined ? '0' : shiftWallTimeGuardSql(context.interval, axis.grain, `_hq_context${context.parent} AS p`, 'p._hq_eval_period', 'p._hq_eval_lower', 'p._hq_eval_upper', 'p._hq_eval_end');
+    return `(SELECT coalesce(max(${guard}), 0) FROM _hq_context${context.id}) + ${wallTimeGuard}`;
+}

package/dist/utils/time-measure-dataset-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-measure-dataset-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-dataset-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAYxE,+EAA+E;AAC/E,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,GACpC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAuD7D"}
+{"version":3,"file":"time-measure-dataset-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-dataset-sql.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAYxE,+EAA+E;AAC/E,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,GACpC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAmE7D"}

package/dist/utils/time-measure-dataset-sql.js

@@ -1,9 +1,12 @@
+import { queryMeasureDefinitions } from './relationship-measures.js';
+import { buildCompositeTimeMeasureSql } from './composite-time-measure-sql.js';
+import { measureDependencyNames } from './measure-dependencies.js';
 import { getBaseMeasure, getDerivedMeasure, isShiftMeasure, isWindowMeasure } from './dataset-measures.js';
 import { selectedTimeMeasures } from './time-query-measures.js';
 import { analyzeTimeMeasureAxis } from './time-measure-axis.js';
 import { validateDatasetQueryInput } from './dataset-query-validation.js';
 import { addTimeSql as add } from './time-arithmetic-sql.js';
-import { shiftBucketCtes, shiftRangeSql, shiftRangePredicateSql } from './shift-measure-sql.js';
+import { shiftBucketCtes } from './shift-measure-sql.js';
 import { buildTimeMeasureSourceSql } from './time-measure-source-sql.js';
 import { buildTimeMeasureAxisSql } from './time-measure-axis-sql.js';
 import { buildTimeMeasureValuesSql, windowMeasureRowsSql, windowScanStartSql } from './time-measure-values-sql.js';
@@ -16,6 +19,16 @@ export function buildTimeMeasureDatasetSql(ds, query, options) {
     const { axis } = analyzeTimeMeasureAxis(ds, query);
     if (!axis || !ds.timeKey)
         throw new Error('Window measures require a bounded time axis.');
+    const dependencies = measureDependencyNames(queryMeasureDefinitions(ds, query.measures ?? []), query.measures ?? []);
+    const composite = dependencies.some(name => {
+        const definition = ds.measures[name];
+        if (isShiftMeasure(definition))
+            return !getBaseMeasure(ds.measures, definition.measure);
+        const derived = getDerivedMeasure(ds.measures, name);
+        return derived && Object.values(derived.uses).some(input => getDerivedMeasure(ds.measures, input));
+    });
+    if (composite)
+        return buildCompositeTimeMeasureSql(ds, query, options, axis);
     const timeMeasures = selectedTimeMeasures(ds, query);
     const windows = [...timeMeasures.values()].filter(isWindowMeasure);
     const shifts = [...timeMeasures.values()].filter(isShiftMeasure);
@@ -28,10 +41,16 @@ export function buildTimeMeasureDatasetSql(ds, query, options) {
     const baseNames = new Set([...needed].map(name => timeMeasures.get(name)?.measure ?? name));
     const source = buildTimeMeasureSourceSql(ds, query, baseNames, axis.filters, options);
     const timeAxis = buildTimeMeasureAxisSql(source, axis, shifts);
+    const shiftedInputs = new Map();
+    [...needed].forEach((name, index) => {
+        const measure = timeMeasures.get(name);
+        if (isShiftMeasure(measure))
+            shiftedInputs.set(name, shiftBucketCtes(measure, axis, index));
+    });
     // Scan only requested populations: intervening rows must not introduce dimensions.
     const end = add('_hq_last', 1, axis.grain);
     const populations = [];
-    if ([...needed].some(name => getBaseMeasure(ds.measures, name))) {
+    if ([...needed].some(name => name.includes('.') || getBaseMeasure(ds.measures, name))) {
         populations.push(`(_hq_time >= _hq_first AND _hq_time < ${end})`);
     }
     if (windows.length) {
@@ -41,23 +60,22 @@ export function buildTimeMeasureDatasetSql(ds, query, options) {
             ? '' : ` AND _hq_time >= least(${starts.join(', ')})`;
         populations.push(`(_hq_time < ${end}${lower})`);
     }
-    for (const shift of shifts) {
-        populations.push(`(${shiftRangePredicateSql('_hq_time', shiftRangeSql(shift, axis))})`);
-    }
+    for (const shifted of shiftedInputs.values())
+        populations.push(`(_hq_time IN (${shifted.sourceTimesSql}))`);
     const scanCte = `_hq_scanned AS (SELECT * FROM _hq_source CROSS JOIN _hq_bounds WHERE ${populations.join(' OR ')})`;
-    const inputs = [...needed].map((name, index) => {
+    const inputs = [...needed].map(name => {
         const timeMeasure = timeMeasures.get(name);
         const window = isWindowMeasure(timeMeasure) ? timeMeasure : undefined;
         const base = source.bases.find(base => base.name === (timeMeasure?.measure ?? name));
         if (!base)
             throw new Error(`Missing base input for measure "${name}".`);
         if (isShiftMeasure(timeMeasure)) {
-            const shifted = shiftBucketCtes(timeMeasure, axis, index);
-            return { name, base, rowsSql: shifted.rowsSql, rowCtes: shifted.ctes, restrictToAxis: false };
+            const shifted = shiftedInputs.get(name);
+            return { name, base, rowsSql: shifted.rowsSql, restrictToAxis: false };
         }
         return { name, base, window, rowsSql: windowMeasureRowsSql(window, axis) };
     });
     const values = buildTimeMeasureValuesSql(source.dimensions, inputs, axis);
-    const sql = buildTimeMeasureResultSql(ds, query, options, source.dimensions, [...source.ctes, ...timeAxis.ctes, scanCte, ...values], `${timeAxis.guard} + ${timeAxis.rangeGuard}`);
+    const sql = buildTimeMeasureResultSql(ds, query, options, source.dimensions, [...source.ctes, ...timeAxis.ctes, ...[...shiftedInputs.values()].flatMap(input => input.ctes), scanCte, ...values], `${timeAxis.guard} + ${timeAxis.rangeGuard} + ${timeAxis.postSeriesGuard}`);
     return { sql, parameters: source.parameters, timeAxisSql: timeAxis.timeAxisSql };
 }

package/dist/utils/time-measure-leaf-sql.d.ts

@@ -0,0 +1,14 @@
+import type { WindowMeasureDefinition } from '../types.js';
+import type { TimeMeasureAxis } from './time-measure-axis.js';
+import type { TimeMeasureSqlBase, TimeMeasureSqlDimension } from './time-measure-source-sql.js';
+/** Keyed source membership retains distinct/average semantics and row multiplicity. */
+export declare function timeMeasureLeafSql(id: number, context: number, base: TimeMeasureSqlBase, window: WindowMeasureDefinition | undefined, axis: TimeMeasureAxis, dims: readonly TimeMeasureSqlDimension[]): {
+    ctes: string[];
+    population: string;
+    aggregate: string;
+    context: number;
+    cumulative: boolean;
+    guard: string;
+    count: boolean;
+};
+//# sourceMappingURL=time-measure-leaf-sql.d.ts.map

package/dist/utils/time-measure-leaf-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-measure-leaf-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-leaf-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAMhG,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,uBAAuB,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,uBAAuB,EAAE;;;;;;;;EA6CrM"}