@hypequery/datasets 0.23.1 → 0.24.0

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

@@ -1,50 +1,49 @@
-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 { shiftRangePredicateSql } from './shift-measure-sql.js';
-import { isCountAggregation, windowAggregateSql } from './window-aggregation-sql.js';
+import { isCountAggregation } from './count-aggregations.js';
 /** Keyed source membership retains distinct/average semantics and row multiplicity. */
-export function timeMeasureLeafSql(id, context, base, window, axis, dims) {
+export function timeMeasureLeafSql(dialect, id, context, base, window, axis, dims) {
     const keys = dims.map(dim => dim.alias);
     const ranges = `_hq_ranges${id}`;
     const rows = `_hq_rows${id}`;
     const aggregate = `_hq_leaf${id}`;
     const value = `_hq_value${id}`;
     const group = `_hq_period${keys.length ? `, ${keys.join(', ')}` : ''}`;
-    const expression = windowAggregateSql(base.definition, base.value, base.arg);
+    const expression = dialect.windowAggregate(base.definition, base.value, base.arg);
     if (window?.cumulative) {
         const population = `_hq_history${id}`;
         const partial = `_hq_partial${id}`;
         const operation = base.definition.aggregation === 'count' ? 'sum' : base.definition.aggregation;
-        const partition = keys.length ? `tuple(${keys.join(', ')})` : 'tuple(0)';
+        const partition = dialect.packRow(keys.length ? keys : ['0']);
         const historyGroup = `_hq_time${keys.length ? `, ${keys.join(', ')}` : ''}`;
         return {
             ctes: [
                 `${population} AS (SELECT * FROM _hq_source WHERE _hq_time < (SELECT max(_hq_eval_end) FROM _hq_context${context}))`,
-                `${partial} AS (SELECT ${historyGroup}, ${partition} AS _hq_partition, toNullable(${expression}) AS _hq_partial FROM ${population} GROUP BY ${historyGroup})`,
-                `${aggregate} AS (SELECT _hq_time, _hq_partition, ${operation}OrNull(_hq_partial) OVER (PARTITION BY _hq_partition ORDER BY _hq_time ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS ${value} FROM ${partial})`,
+                `${partial} AS (SELECT ${historyGroup}, ${partition} AS _hq_partition, ${dialect.toNullable(expression)} AS _hq_partial FROM ${population} GROUP BY ${historyGroup})`,
+                `${aggregate} AS (SELECT _hq_time, _hq_partition, ${dialect.reaggregate(operation, '_hq_partial')} OVER (PARTITION BY _hq_partition ORDER BY _hq_time ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS ${value} FROM ${partial})`,
             ],
             population, aggregate, context, cumulative: true, guard: '0',
             count: isCountAggregation(base.definition),
         };
     }
-    const lower = window?.trailing ? subtract('_hq_eval_end', window.trailing.amount, window.trailing.unit)
-        : window?.toDate ? `${GRAIN_FUNCTIONS[window.toDate]}(_hq_eval_period)` : '_hq_eval_lower';
+    const lower = window?.trailing ? dialect.subtractTime('_hq_eval_end', window.trailing.amount, window.trailing.unit)
+        : window?.toDate ? dialect.truncateTime('_hq_eval_period', window.toDate) : '_hq_eval_lower';
     const upper = window ? '_hq_eval_end' : '_hq_eval_upper';
     const lowerInclusive = window ? '1' : '_hq_lower_inclusive';
     const upperInclusive = window ? '0' : '_hq_upper_inclusive';
-    const first = `${GRAIN_FUNCTIONS[axis.grain]}(_hq_scan_lower)`;
-    const last = `${GRAIN_FUNCTIONS[axis.grain]}(_hq_scan_upper)`;
-    const count = `greatest(0, dateDiff('${axis.grain}', ${first}, ${last}) + if(_hq_scan_upper > ${last} OR _hq_scan_upper_inclusive, 1, 0))`;
-    const fanout = window ? `throwIf(${count} > 1000, 'A window row contributes to more than 1000 buckets.')` : '0';
-    const guard = `${fanout} + ${calendarBucketGuardSql(first, `${count} + ${fanout}`, axis.grain)}`;
+    const first = dialect.truncateTime('_hq_scan_lower', axis.grain);
+    const last = dialect.truncateTime('_hq_scan_upper', axis.grain);
+    const partialUpper = dialect.ifElse(`_hq_scan_upper > ${last} OR _hq_scan_upper_inclusive`, '1', '0');
+    const count = dialect.greatest('0', `${dialect.timeDiff(axis.grain, first, last)} + ${partialUpper}`);
+    const fanout = window ? dialect.guard(`${count} > 1000`, 'A window row contributes to more than 1000 buckets.') : '0';
+    const guard = `${fanout} + ${calendarBucketGuardSql(dialect, first, `${count} + ${fanout}`, axis.grain)}`;
     const predicate = shiftRangePredicateSql('r._hq_time', { lower: 'b._hq_scan_lower', upper: 'b._hq_scan_upper', lowerInclusive: 'b._hq_scan_lower_inclusive', upperInclusive: 'b._hq_scan_upper_inclusive' });
     return {
         ctes: [
             `${ranges} AS (SELECT _hq_period, ${lower} AS _hq_scan_lower, ${upper} AS _hq_scan_upper, ${lowerInclusive} AS _hq_scan_lower_inclusive, ${upperInclusive} AS _hq_scan_upper_inclusive FROM _hq_context${context})`,
-            `_hq_keys${id} AS (SELECT *, ${add(first, `arrayJoin(range(toUInt64(${count} + ${guard})))`, axis.grain)} AS _hq_source_period FROM ${ranges})`,
-            `${rows} AS (SELECT r.*, b._hq_period FROM _hq_source AS r INNER JOIN _hq_keys${id} AS b ON ${GRAIN_FUNCTIONS[axis.grain]}(r._hq_time) = b._hq_source_period WHERE ${predicate})`,
-            `${aggregate} AS (SELECT ${group}, toNullable(${expression}) AS ${value} FROM ${rows} GROUP BY ${group})`,
+            `_hq_keys${id} AS (SELECT *, ${dialect.addTime(first, dialect.seriesIndex(`${count} + ${guard}`), axis.grain)} AS _hq_source_period FROM ${ranges})`,
+            `${rows} AS (SELECT r.*, b._hq_period FROM _hq_source AS r INNER JOIN _hq_keys${id} AS b ON ${dialect.truncateTime('r._hq_time', axis.grain)} = b._hq_source_period WHERE ${predicate})`,
+            `${aggregate} AS (SELECT ${group}, ${dialect.toNullable(expression)} AS ${value} FROM ${rows} GROUP BY ${group})`,
         ],
         population: rows, aggregate, context, cumulative: false,
         guard: `(SELECT coalesce(max(${guard}), 0) FROM ${ranges})`, count: isCountAggregation(base.definition),

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

@@ -1 +1 @@
-{"version":3,"file":"time-measure-result-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-result-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAIxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E,sFAAsF;AACtF,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,eAAe,EAAE,MAAM,EACvB,iBAAiB,UAAQ,GACxB,MAAM,CAuBR"}
+{"version":3,"file":"time-measure-result-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-result-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAIxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E,sFAAsF;AACtF,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,eAAe,EAAE,MAAM,EACvB,iBAAiB,UAAQ,GACxB,MAAM,CAwBR"}

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

@@ -1,31 +1,30 @@
 import { semanticOrderDirection } from './semantic-query-syntax.js';
-import { quoteSQLIdentifier } from '../sql-utils.js';
+import { resolveDatasetSqlDialect } from './dataset-sql-dialect.js';
 import { getDerivedMeasure } from './dataset-measures.js';
 import { derivedProjection } from './derived-measure-sql.js';
 /** Evaluate formulas after aggregation, then apply output ordering and pagination. */
 export function buildTimeMeasureResultSql(ds, query, options, dims, ctes, validationGuard, formulasEvaluated = false) {
+    const dialect = resolveDatasetSqlDialect(options.builderFactory);
+    const quote = dialect.quoteIdentifier;
     const selected = query.measures ?? [];
     const projections = [
-        quoteSQLIdentifier('period'),
-        ...dims.map(dimension => quoteSQLIdentifier(dimension.name)),
+        quote('period'),
+        ...dims.map(dimension => quote(dimension.name)),
         ...selected.map(name => {
             const derived = getDerivedMeasure(ds.measures, name);
-            return derived && !formulasEvaluated ? derivedProjection(name, derived) : quoteSQLIdentifier(name);
+            return derived && !formulasEvaluated ? derivedProjection(dialect, name, derived) : quote(name);
         }),
     ];
     // Keep toSQL independently guarded too. This branch produces no valid
     // result rows, and forces axis validation even when _hq_values is empty.
     const outputNames = ['period', ...dims.map(dimension => dimension.name), ...selected];
-    const nullProjections = outputNames.map(name => `NULL AS ${quoteSQLIdentifier(name)}`).join(', ');
+    const nullProjections = outputNames.map(name => `NULL AS ${quote(name)}`).join(', ');
     const resultCte = `_hq_result AS (SELECT ${projections.join(', ')} FROM _hq_values`
         + ` UNION ALL SELECT ${nullProjections} FROM _hq_bounds WHERE ${validationGuard} = 1)`;
-    let sql = `WITH ${[...ctes, resultCte].join(',\n')} SELECT ${outputNames.map(quoteSQLIdentifier).join(', ')} FROM _hq_result`;
+    let sql = `WITH ${[...ctes, resultCte].join(',\n')} SELECT ${outputNames.map(name => quote(name)).join(', ')} FROM _hq_result`;
     const order = query.orderBy?.length ? query.orderBy : [{ field: 'period', direction: 'asc' }];
-    sql += ` ORDER BY ${order.map(item => `${quoteSQLIdentifier(item.field)} ${semanticOrderDirection(item.direction)}`).join(', ')}`;
+    sql += ` ORDER BY ${order.map(item => dialect.orderTerm(quote(item.field), semanticOrderDirection(item.direction))).join(', ')}`;
     const limit = options.executionLimit ?? query.limit;
-    if (limit !== undefined)
-        sql += ` LIMIT ${limit}`;
-    if (query.offset !== undefined)
-        sql += ` OFFSET ${query.offset}`;
+    sql += dialect.paginate(limit, query.offset);
     return sql;
 }

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

@@ -1,5 +1,6 @@
 import type { AnyDatasetInstance, DatasetQuery, MeasureDefinition, MetricFilter } from '../types.js';
 import type { DatasetQueryExecutionOptions } from '../dataset-query.js';
+import type { StatementParameters } from './statement-parameters.js';
 export interface TimeMeasureSqlDimension {
     name: string;
     alias: string;
@@ -12,11 +13,10 @@ export interface TimeMeasureSqlBase {
 }
 export interface TimeMeasureSqlSource {
     ctes: string[];
-    parameters: unknown[];
     dimensions: TimeMeasureSqlDimension[];
     bases: TimeMeasureSqlBase[];
     rowAlias: string;
 }
 /** Isolate authored expressions, joins, tenancy and filters from internal SQL aliases. */
-export declare function buildTimeMeasureSourceSql(ds: AnyDatasetInstance, query: DatasetQuery, baseNames: Iterable<string>, filters: readonly MetricFilter[], options: DatasetQueryExecutionOptions): TimeMeasureSqlSource;
+export declare function buildTimeMeasureSourceSql(ds: AnyDatasetInstance, query: DatasetQuery, baseNames: Iterable<string>, filters: readonly MetricFilter[], options: DatasetQueryExecutionOptions, statement: StatementParameters): TimeMeasureSqlSource;
 //# sourceMappingURL=time-measure-source-sql.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"time-measure-source-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-source-sql.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACrG,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAUxE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,iBAAiB,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,UAAU,EAAE,uBAAuB,EAAE,CAAC;IACtC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,0FAA0F;AAC1F,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC3B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,4BAA4B,GACpC,oBAAoB,CA6DtB"}
+{"version":3,"file":"time-measure-source-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-source-sql.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACrG,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AASxE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,iBAAiB,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,uBAAuB,EAAE,CAAC;IACtC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,0FAA0F;AAC1F,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC3B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,4BAA4B,EACrC,SAAS,EAAE,mBAAmB,GAC7B,oBAAoB,CAqEtB"}

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

@@ -1,6 +1,7 @@
+import { datasetSourceBuilder } from './dataset-source.js';
 import { resolveRelationshipMeasure } from './relationship-measures.js';
 import { relationshipMeasureExpressions } from './relationship-measure-sql.js';
-import { queryTimeSql } from './query-timezone.js';
+import { queryTimeFilter, queryTimeSql } from './query-timezone.js';
 import { resolveDimensionExpression, resolveFilterField, resolveTenantFilterColumn } from '../query-planner.js';
 import { applyRelationshipJoins, buildRelationshipBuilderContext, qualifyBaseColumn } from './relationship-builder-plan.js';
 import { getRuntimeTenantPredicate } from './tenant-runtime.js';
@@ -10,12 +11,13 @@ import { measureToAggregationSpec } from './dataset-normalization.js';
 import { applyFilteredAggregationExpression } from './filtered-aggregation-sql.js';
 import { assertNoRawSqlUnderJoins } from './sql-under-joins.js';
 /** Isolate authored expressions, joins, tenancy and filters from internal SQL aliases. */
-export function buildTimeMeasureSourceSql(ds, query, baseNames, filters, options) {
+export function buildTimeMeasureSourceSql(ds, query, baseNames, filters, options, statement) {
+    const { dialect } = statement;
     const bases = [];
-    const joinCtx = buildRelationshipBuilderContext(ds, query, options.context);
+    const joinCtx = buildRelationshipBuilderContext(ds, query, options.context, dialect);
     // Keep source expressions in their own SELECT scope: internal aliases cannot
     // capture authored SQL identifiers, even if a physical column shares a name.
-    let raw = applyRelationshipJoins(options.builderFactory.table(ds.source), joinCtx);
+    let raw = applyRelationshipJoins(datasetSourceBuilder(options.builderFactory, ds), joinCtx);
     const dims = (query.dimensions ?? []).map((name, i) => ({ name, alias: `_hq_d${i}` }));
     const sourceParts = [resolveDimensionExpression(ds, ds.timeKey, joinCtx)];
     for (const dimension of dims)
@@ -31,9 +33,9 @@ export function buildTimeMeasureSourceSql(ds, query, baseNames, filters, options
         const value = `_hq_v${bases.length}`;
         const arg = `_hq_a${bases.length}`;
         bases.push({ name, definition, value, arg });
-        const expressions = related ? relationshipMeasureExpressions(ds, name, joinCtx) : undefined;
+        const expressions = related ? relationshipMeasureExpressions(ds, name, joinCtx, dialect) : undefined;
         const expression = expressions?.field ?? spec.sql ?? resolveDimensionExpression(ds, spec.field, joinCtx);
-        sourceParts.push(expressions ? expression : applyFilteredAggregationExpression(ds, spec, expression, joinCtx));
+        sourceParts.push(expressions ? expression : applyFilteredAggregationExpression(ds, spec, expression, joinCtx, dialect));
         sourceParts.push(expressions?.arg ?? (spec.argField ? resolveDimensionExpression(ds, spec.argField, joinCtx) : 'NULL'));
     }
     // A positional tuple isolates internal names from the source table's names.
@@ -47,31 +49,38 @@ export function buildTimeMeasureSourceSql(ds, query, baseNames, filters, options
     let rowAlias = '_hq_row';
     while (sourceIdentifiers.some(text => text.includes(rowAlias)))
         rowAlias += '_';
-    raw = raw.select([`tuple(${sourceParts.join(', ')}) AS ${rowAlias}`]);
+    raw = raw.select([`${dialect.packRow(sourceParts)} AS ${rowAlias}`]);
     const tenant = getRuntimeTenantPredicate(options.context);
     const tenantColumn = resolveTenantFilterColumn(ds, options.context);
     if (tenant && tenantColumn)
         raw = raw.where(qualifyBaseColumn(joinCtx, tenantColumn), tenant.operator, tenant.value);
+    // The time axis already consumed every time-key bound, so these are the
+    // remaining caller filters.
     for (const filter of filters) {
-        raw = raw.where(resolveFilterField(ds, filter.field, joinCtx), filter.operator, filter.value);
+        const predicates = queryTimeFilter(dialect, ds, filter, resolveFilterField(ds, filter.field, joinCtx), query.timezone);
+        for (const predicate of predicates) {
+            raw = raw.where(predicate.expression, predicate.operator, predicate.value);
+        }
     }
     for (const filter of segmentFilters(ds, query.segments)) {
-        raw = raw.where(resolveDimensionExpression(ds, filter.field, joinCtx), filter.operator, filter.value);
+        const predicates = queryTimeFilter(dialect, ds, filter, resolveDimensionExpression(ds, filter.field, joinCtx), query.timezone, { field: 'dimension' });
+        for (const predicate of predicates) {
+            raw = raw.where(predicate.expression, predicate.operator, predicate.value);
+        }
     }
-    const { sql: rawSql, parameters } = raw.toSQLWithParams();
-    const sourceColumns = [`${queryTimeSql(`assumeNotNull(tupleElement(${rowAlias}, 1))`, query.timezone)} AS _hq_time`];
-    dims.forEach((dimension, i) => sourceColumns.push(`tupleElement(${rowAlias}, ${i + 2}) AS ${dimension.alias}`));
+    const rawSql = statement.embedBuilder(raw);
+    const sourceColumns = [`${queryTimeSql(dialect, dialect.assumeNotNull(dialect.rowElement(rowAlias, 1)), query.timezone)} AS _hq_time`];
+    dims.forEach((dimension, i) => sourceColumns.push(`${dialect.rowElement(rowAlias, i + 2)} AS ${dimension.alias}`));
     bases.forEach((base, i) => {
         const valuePosition = dims.length + 2 + i * 2;
-        sourceColumns.push(`tupleElement(${rowAlias}, ${valuePosition}) AS ${base.value}`);
-        sourceColumns.push(`tupleElement(${rowAlias}, ${valuePosition + 1}) AS ${base.arg}`);
+        sourceColumns.push(`${dialect.rowElement(rowAlias, valuePosition)} AS ${base.value}`);
+        sourceColumns.push(`${dialect.rowElement(rowAlias, valuePosition + 1)} AS ${base.arg}`);
     });
     return {
         ctes: [
             `_hq_raw AS (${rawSql})`,
-            `_hq_source AS (SELECT ${sourceColumns.join(', ')} FROM _hq_raw WHERE isNotNull(tupleElement(${rowAlias}, 1)))`,
+            `_hq_source AS (SELECT ${sourceColumns.join(', ')} FROM _hq_raw WHERE ${dialect.isNotNull(dialect.rowElement(rowAlias, 1))})`,
         ],
-        parameters,
         dimensions: dims,
         bases,
         rowAlias,

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

@@ -1,3 +1,4 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 import type { TimeGrain, WindowMeasureDefinition } from '../types.js';
 import type { TimeMeasureAxis } from './time-measure-axis.js';
 import type { TimeMeasureSqlBase, TimeMeasureSqlDimension } from './time-measure-source-sql.js';
@@ -12,9 +13,9 @@ export interface TimeMeasureSqlInput {
     /** Shift populations already map exclusively to the requested output series. */
     restrictToAxis?: boolean;
 }
-export declare function windowScanStartSql(window: WindowMeasureDefinition, grain: TimeGrain): string;
+export declare function windowScanStartSql(dialect: DatasetSqlDialectRules, window: WindowMeasureDefinition, grain: TimeGrain): string;
 /** Base measures respect partial endpoints; windows use entire contributing buckets. */
-export declare function windowMeasureRowsSql(window: WindowMeasureDefinition | undefined, axis: TimeMeasureAxis): string;
+export declare function windowMeasureRowsSql(dialect: DatasetSqlDialectRules, window: WindowMeasureDefinition | undefined, axis: TimeMeasureAxis): string;
 /** Fill dimension combinations, aggregate populations, and join measure values onto the series. */
-export declare function buildTimeMeasureValuesSql(dims: readonly TimeMeasureSqlDimension[], inputs: readonly TimeMeasureSqlInput[], axis: TimeMeasureAxis): string[];
+export declare function buildTimeMeasureValuesSql(dialect: DatasetSqlDialectRules, dims: readonly TimeMeasureSqlDimension[], inputs: readonly TimeMeasureSqlInput[], axis: TimeMeasureAxis): string[];
 //# sourceMappingURL=time-measure-values-sql.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"time-measure-values-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-values-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAGtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAKhG,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,CAAC;IACzB,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gFAAgF;IAChF,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAwBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAI5F;AAED,wFAAwF;AACxF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,uBAAuB,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAG/G;AAED,mGAAmG;AACnG,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,MAAM,EAAE,SAAS,mBAAmB,EAAE,EACtC,IAAI,EAAE,eAAe,GACpB,MAAM,EAAE,CA0CV"}
+{"version":3,"file":"time-measure-values-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-values-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAIhG,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,CAAC;IACzB,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gFAAgF;IAChF,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAwBD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAI7H;AAED,wFAAwF;AACxF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,uBAAuB,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAGhJ;AAED,mGAAmG;AACnG,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,MAAM,EAAE,SAAS,mBAAmB,EAAE,EACtC,IAAI,EAAE,eAAe,GACpB,MAAM,EAAE,CA0CV"}

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

@@ -1,54 +1,51 @@
-import { GRAIN_FUNCTIONS } from '../constants.js';
-import { quoteSQLIdentifier } from '../sql-utils.js';
-import { addTimeSql as add, subtractTimeSql as subtract } from './time-arithmetic-sql.js';
-import { isCountAggregation, windowAggregateSql } from './window-aggregation-sql.js';
+import { isCountAggregation } from './count-aggregations.js';
 import { calendarBucketGuardSql } from './time-axis-calendar-guard.js';
 /** One row is emitted into each bounded window it contributes to. */
-function contributionSql(window, grain) {
-    const bucket = `${GRAIN_FUNCTIONS[grain]}(_hq_time)`;
+function contributionSql(dialect, window, grain) {
+    const bucket = dialect.truncateTime('_hq_time', grain);
     if (!window)
         return bucket;
     if (window.cumulative)
-        return `greatest(${bucket}, _hq_first)`;
+        return dialect.greatest(bucket, '_hq_first');
     let count;
     if (window.trailing) {
-        const end = add(bucket, window.trailing.amount, window.trailing.unit);
-        count = `dateDiff('${grain}', ${bucket}, ${end})`;
+        const end = dialect.addTime(bucket, window.trailing.amount, window.trailing.unit);
+        count = dialect.timeDiff(grain, bucket, end);
     }
     else if (window.toDate) {
-        const calendarStart = `${GRAIN_FUNCTIONS[window.toDate]}(_hq_time)`;
-        const end = add(calendarStart, 1, window.toDate);
-        count = `dateDiff('${grain}', ${bucket}, ${end})`;
+        const calendarStart = dialect.truncateTime('_hq_time', window.toDate);
+        const end = dialect.addTime(calendarStart, 1, window.toDate);
+        count = dialect.timeDiff(grain, bucket, end);
     }
     else {
         throw new Error('Window measure has no supported mode.');
     }
-    const fanoutGuard = `throwIf(${count} > 1000, 'A window row contributes to more than 1000 buckets.')`;
-    const calendarGuard = calendarBucketGuardSql(bucket, `${count} + ${fanoutGuard}`, grain);
-    const bucketIndices = `arrayJoin(range(toUInt64(${count} + ${fanoutGuard} + ${calendarGuard})))`;
-    return add(bucket, bucketIndices, grain);
+    const fanoutGuard = dialect.guard(`${count} > 1000`, 'A window row contributes to more than 1000 buckets.');
+    const calendarGuard = calendarBucketGuardSql(dialect, bucket, `${count} + ${fanoutGuard}`, grain);
+    const bucketIndices = dialect.seriesIndex(`${count} + ${fanoutGuard} + ${calendarGuard}`);
+    return dialect.addTime(bucket, bucketIndices, grain);
 }
-export function windowScanStartSql(window, grain) {
+export function windowScanStartSql(dialect, window, grain) {
     if (window.trailing)
-        return subtract(add('_hq_first', 1, grain), window.trailing.amount, window.trailing.unit);
+        return dialect.subtractTime(dialect.addTime('_hq_first', 1, grain), window.trailing.amount, window.trailing.unit);
     if (window.toDate)
-        return `${GRAIN_FUNCTIONS[window.toDate]}(_hq_first)`;
+        return dialect.truncateTime('_hq_first', window.toDate);
     throw new Error('Cumulative windows have unbounded history.');
 }
 /** Base measures respect partial endpoints; windows use entire contributing buckets. */
-export function windowMeasureRowsSql(window, axis) {
+export function windowMeasureRowsSql(dialect, window, axis) {
     const range = window ? '' : ` WHERE _hq_time ${axis.lowerInclusive ? '>=' : '>'} _hq_lower AND _hq_time ${axis.upperInclusive ? '<=' : '<'} _hq_upper`;
-    return `SELECT *, ${contributionSql(window, axis.grain)} AS _hq_period FROM _hq_scanned${range}`;
+    return `SELECT *, ${contributionSql(dialect, window, axis.grain)} AS _hq_period FROM _hq_scanned${range}`;
 }
 /** Fill dimension combinations, aggregate populations, and join measure values onto the series. */
-export function buildTimeMeasureValuesSql(dims, inputs, axis) {
+export function buildTimeMeasureValuesSql(dialect, dims, inputs, axis) {
     const ctes = [];
     const keys = dims.map(dimension => dimension.alias);
     const combinations = keys.length
         ? ` CROSS JOIN (SELECT DISTINCT ${keys.join(', ')} FROM _hq_scanned) AS _hq_combinations`
         : '';
     ctes.push(`_hq_skeleton AS (SELECT * FROM _hq_series${combinations})`);
-    const projections = ['s._hq_period AS period', ...dims.map(dimension => `s.${dimension.alias} AS ${quoteSQLIdentifier(dimension.name)}`)];
+    const projections = ['s._hq_period AS period', ...dims.map(dimension => `s.${dimension.alias} AS ${dialect.quoteIdentifier(dimension.name)}`)];
     const joins = [];
     let index = 0;
     for (const input of inputs) {
@@ -58,28 +55,28 @@ export function buildTimeMeasureValuesSql(dims, inputs, axis) {
         const aggregate = `_hq_agg${index}`;
         ctes.push(...rowCtes, `${fan} AS (${rowsSql})`);
         // toNullable makes unmatched LEFT JOIN values NULL regardless of join_use_nulls.
-        const expression = windowAggregateSql(base.definition, base.value, base.arg);
+        const expression = dialect.windowAggregate(base.definition, base.value, base.arg);
         const groupColumns = `_hq_period${keys.length ? `, ${keys.join(', ')}` : ''}`;
         const outputRange = restrictToAxis ? ' WHERE _hq_period BETWEEN _hq_first AND _hq_last' : '';
         const trailingRange = window?.trailing
-            ? ` AND _hq_time >= ${subtract(add('_hq_period', 1, axis.grain), window.trailing.amount, window.trailing.unit)}`
+            ? ` AND _hq_time >= ${dialect.subtractTime(dialect.addTime('_hq_period', 1, axis.grain), window.trailing.amount, window.trailing.unit)}`
             : '';
-        const aggregationSql = `SELECT ${groupColumns}, toNullable(${expression}) AS ${output}`
+        const aggregationSql = `SELECT ${groupColumns}, ${dialect.toNullable(expression)} AS ${output}`
             + ` FROM ${fan}${outputRange}${trailingRange} GROUP BY ${groupColumns}`;
         ctes.push(`${aggregate} AS (${aggregationSql})`);
         const alias = `m${index}`;
-        const condition = [`s._hq_period = ${alias}._hq_period`, ...keys.map(key => `isNotDistinctFrom(s.${key}, ${alias}.${key})`)];
+        const condition = [`s._hq_period = ${alias}._hq_period`, ...keys.map(key => dialect.isNotDistinctFrom(`s.${key}`, `${alias}.${key}`))];
         joins.push(`LEFT JOIN ${aggregate} AS ${alias} ON ${condition.join(' AND ')}`);
         let value = `${alias}.${output}`;
         if (window?.cumulative) {
             const operation = base.definition.aggregation === 'count' ? 'sum' : base.definition.aggregation;
             const partition = keys.length ? `PARTITION BY ${keys.map(key => `s.${key}`).join(', ')} ` : '';
             const frame = `${partition}ORDER BY s._hq_period ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`;
-            value = `${operation}OrNull(${value}) OVER (${frame})`;
+            value = `${dialect.reaggregate(operation, value)} OVER (${frame})`;
         }
         if (isCountAggregation(base.definition))
             value = `coalesce(${value}, 0)`;
-        projections.push(`${value} AS ${quoteSQLIdentifier(name)}`);
+        projections.push(`${value} AS ${dialect.quoteIdentifier(name)}`);
         index++;
     }
     ctes.push(`_hq_values AS (SELECT ${projections.join(', ')} FROM _hq_skeleton AS s ${joins.join(' ')})`);

package/dist/utils/timestamp-instants.d.ts

@@ -0,0 +1,17 @@
+import { type ParsedTimeBound } from './time-axis-bounds.js';
+/**
+ * Parse an RFC 3339 instant: ISO 8601 text carrying `Z` or a numeric offset,
+ * the form `Date.prototype.toISOString` produces. Offset-free text is a local
+ * reading rather than an instant and yields undefined, as does anything that
+ * is not a timestamp.
+ */
+export declare function parseTimestampInstant(value: unknown): ParsedTimeBound | undefined;
+/**
+ * The wall clock an instant shows in `timezone`, spelled
+ * `YYYY-MM-DD hh:mm:ss[.fraction]`: the form ClickHouse reads as local time in
+ * the zone of the DateTime64 it is compared against. Offsets are whole
+ * minutes, so the authored sub-second digits survive unchanged; a zero
+ * fraction is dropped.
+ */
+export declare function instantWallClock(instant: ParsedTimeBound, timezone: string): string;
+//# sourceMappingURL=timestamp-instants.d.ts.map

package/dist/utils/timestamp-instants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp-instants.d.ts","sourceRoot":"","sources":["../../src/utils/timestamp-instants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7E;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,SAAS,CAGjF;AAUD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CASnF"}

package/dist/utils/timestamp-instants.js

@@ -0,0 +1,34 @@
+import { parseTimeBound } from './time-axis-bounds.js';
+/**
+ * Parse an RFC 3339 instant: ISO 8601 text carrying `Z` or a numeric offset,
+ * the form `Date.prototype.toISOString` produces. Offset-free text is a local
+ * reading rather than an instant and yields undefined, as does anything that
+ * is not a timestamp.
+ */
+export function parseTimestampInstant(value) {
+    const instant = parseTimeBound(value);
+    return instant?.hasOffset ? instant : undefined;
+}
+const NANOSECONDS_PER_SECOND = 1000000000n;
+const CLOCK_PARTS = {
+    hourCycle: 'h23',
+    year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit',
+};
+/**
+ * The wall clock an instant shows in `timezone`, spelled
+ * `YYYY-MM-DD hh:mm:ss[.fraction]`: the form ClickHouse reads as local time in
+ * the zone of the DateTime64 it is compared against. Offsets are whole
+ * minutes, so the authored sub-second digits survive unchanged; a zero
+ * fraction is dropped.
+ */
+export function instantWallClock(instant, timezone) {
+    const parts = new Intl.DateTimeFormat('en-US', { ...CLOCK_PARTS, timeZone: timezone })
+        .formatToParts(new Date(instant.milliseconds));
+    const part = (type) => parts.find(entry => entry.type === type)?.value ?? '';
+    const date = `${part('year').padStart(4, '0')}-${part('month')}-${part('day')}`;
+    const clock = `${part('hour')}:${part('minute')}:${part('second')}`;
+    const remainder = ((instant.nanoseconds % NANOSECONDS_PER_SECOND) + NANOSECONDS_PER_SECOND) % NANOSECONDS_PER_SECOND;
+    const fraction = remainder === 0n ? '' : `.${remainder.toString().padStart(9, '0').replace(/0+$/, '')}`;
+    return `${date} ${clock}${fraction}`;
+}

package/dist/utils/timestamp-text.d.ts

@@ -0,0 +1,12 @@
+/**
+ * True for the timestamp text a filter may bind: a real calendar date, or a
+ * date and time with seconds, optionally with a fraction and `Z`/offset.
+ *
+ * ClickHouse reads an invalid `DateTime64` parameter as some other instant
+ * instead of refusing it (`2026-13-45` becomes 1900-01-01, `2026-02-30`
+ * rolls into March, digits are read as Unix seconds), and refuses a time
+ * without seconds, so anything else is rejected before planning. This is
+ * the same rule as the Python planner's.
+ */
+export declare function isTimestampText(value: unknown): value is string;
+//# sourceMappingURL=timestamp-text.d.ts.map

package/dist/utils/timestamp-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp-text.d.ts","sourceRoot":"","sources":["../../src/utils/timestamp-text.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAK/D"}

package/dist/utils/timestamp-text.js

@@ -0,0 +1,18 @@
+import { parseTimeBound } from './time-axis-bounds.js';
+/**
+ * True for the timestamp text a filter may bind: a real calendar date, or a
+ * date and time with seconds, optionally with a fraction and `Z`/offset.
+ *
+ * ClickHouse reads an invalid `DateTime64` parameter as some other instant
+ * instead of refusing it (`2026-13-45` becomes 1900-01-01, `2026-02-30`
+ * rolls into March, digits are read as Unix seconds), and refuses a time
+ * without seconds, so anything else is rejected before planning. This is
+ * the same rule as the Python planner's.
+ */
+export function isTimestampText(value) {
+    const parsed = parseTimeBound(value);
+    if (!parsed)
+        return false;
+    const time = parsed.text.slice(10);
+    return time === '' || /^[T ]\d{2}:\d{2}:\d{2}/.test(time);
+}

package/dist/utils/zod-json-schema.d.ts

@@ -0,0 +1,8 @@
+import { type AnyZodSchema } from './zod-schema-version.js';
+/**
+ * Draft-07 JSON Schema for a Zod 3 or Zod 4 schema, describing what a caller
+ * may send. `zod-to-json-schema` only reads Zod 3 (it returns an empty schema
+ * for Zod 4), and Zod 4 ships its own generator.
+ */
+export declare function zodToDraft7JsonSchema(schema: AnyZodSchema): Record<string, unknown>;
+//# sourceMappingURL=zod-json-schema.d.ts.map

package/dist/utils/zod-json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-json-schema.d.ts","sourceRoot":"","sources":["../../src/utils/zod-json-schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASnF"}

package/dist/utils/zod-json-schema.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { isZod4Schema } from './zod-schema-version.js';
+/**
+ * Draft-07 JSON Schema for a Zod 3 or Zod 4 schema, describing what a caller
+ * may send. `zod-to-json-schema` only reads Zod 3 (it returns an empty schema
+ * for Zod 4), and Zod 4 ships its own generator.
+ */
+export function zodToDraft7JsonSchema(schema) {
+    if (isZod4Schema(schema)) {
+        return z.toJSONSchema(schema, {
+            target: 'draft-7',
+            io: 'input',
+            unrepresentable: 'any',
+        });
+    }
+    return zodToJsonSchema(schema, { target: 'jsonSchema7', $refStrategy: 'none' });
+}

package/dist/utils/zod-schema-version.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Any Zod schema, from either major version or another installed copy of Zod.
+ *
+ * Structural on purpose: a caller's schema built with their own `zod@3` is not
+ * assignable to this package's `zod@4` types, but both carry their definition
+ * on `_def` (v3) or `_zod` (v4).
+ */
+export type AnyZodSchema = {
+    readonly _def: unknown;
+} | {
+    readonly _zod: unknown;
+};
+/** Zod 4 (classic or mini) keeps its internals on `_zod`; Zod 3 has none. */
+export declare function isZod4Schema(schema: unknown): schema is {
+    readonly _zod: {
+        readonly def: Record<string, any>;
+    };
+};
+//# sourceMappingURL=zod-schema-version.d.ts.map

package/dist/utils/zod-schema-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-schema-version.d.ts","sourceRoot":"","sources":["../../src/utils/zod-schema-version.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAEnF,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI;IAAE,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAA;CAAE,CAIhH"}

package/dist/utils/zod-schema-version.js

@@ -0,0 +1,6 @@
+/** Zod 4 (classic or mini) keeps its internals on `_zod`; Zod 3 has none. */
+export function isZod4Schema(schema) {
+    return typeof schema === 'object'
+        && schema !== null
+        && typeof schema._zod === 'object';
+}

package/dist/utils/zod-v3-protocol-schema.d.ts

@@ -0,0 +1,10 @@
+import { type ProtocolSchemaDraft } from './protocol-schema-conversion.js';
+/** A Zod 3 schema, read through its `_def`. Callers may hold any 3.x copy of Zod. */
+type ZodV3Schema = {
+    readonly _def: Record<string, any>;
+    readonly description?: string;
+};
+/** Converts the portable subset of a Zod 3 schema into an RFC 0004 draft. */
+export declare function convertZodV3Schema(schema: ZodV3Schema, path: string): ProtocolSchemaDraft;
+export {};
+//# sourceMappingURL=zod-v3-protocol-schema.d.ts.map

package/dist/utils/zod-v3-protocol-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-v3-protocol-schema.d.ts","sourceRoot":"","sources":["../../src/utils/zod-v3-protocol-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,qFAAqF;AACrF,KAAK,WAAW,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AA8DzF,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAyGzF"}