@hypequery/datasets 0.23.1 → 0.25.0

package/dist/utils/row-scope.d.ts

@@ -0,0 +1,23 @@
+import type { AnyDatasetInstance, ExecutionContext, MetricFilter } from '../types.js';
+import type { QueryBuilderLike } from '../query-builder-protocol.js';
+import { type TenantPredicate } from './tenant-runtime.js';
+/** A trusted predicate on one of a dataset's own physical columns. */
+export type RowScopePredicate = TenantPredicate & {
+    readonly column: string;
+};
+/**
+ * The trusted predicates restricting which source rows of `ds` any query may
+ * read (RFC 0020). They apply to the queried dataset and to every joined
+ * relationship target alike. `tenantKey` with a runtime tenant lowers to one
+ * predicate; the trusted cross-tenant scope (`scope: 'all'`) lowers to none.
+ */
+export declare function datasetRowScope(ds: Pick<AnyDatasetInstance, 'tenantKey'>, context?: ExecutionContext): RowScopePredicate[];
+/**
+ * The call's RFC 0019 enforced constraints, from trusted context only. They
+ * apply to the queried dataset, in its filter vocabulary, never to joined
+ * targets.
+ */
+export declare function runtimeConstraints(context?: ExecutionContext): readonly MetricFilter[];
+/** ANDs each row-scope predicate onto `qb`, with columns qualified by `qualify`. */
+export declare function applyRowScope(qb: QueryBuilderLike, scope: readonly RowScopePredicate[], qualify?: (column: string) => string): QueryBuilderLike;
+//# sourceMappingURL=row-scope.d.ts.map

package/dist/utils/row-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-scope.d.ts","sourceRoot":"","sources":["../../src/utils/row-scope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtF,sEAAsE;AACtE,MAAM,MAAM,iBAAiB,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9E;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,EACzC,OAAO,CAAC,EAAE,gBAAgB,GACzB,iBAAiB,EAAE,CAGrB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,YAAY,EAAE,CAEtF;AAED,oFAAoF;AACpF,wBAAgB,aAAa,CAC3B,EAAE,EAAE,gBAAgB,EACpB,KAAK,EAAE,SAAS,iBAAiB,EAAE,EACnC,OAAO,GAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAyB,GACrD,gBAAgB,CAKlB"}

package/dist/utils/row-scope.js

@@ -0,0 +1,26 @@
+import { getRuntimeTenantPredicate } from './tenant-runtime.js';
+/**
+ * The trusted predicates restricting which source rows of `ds` any query may
+ * read (RFC 0020). They apply to the queried dataset and to every joined
+ * relationship target alike. `tenantKey` with a runtime tenant lowers to one
+ * predicate; the trusted cross-tenant scope (`scope: 'all'`) lowers to none.
+ */
+export function datasetRowScope(ds, context) {
+    const tenant = getRuntimeTenantPredicate(context);
+    return tenant && ds.tenantKey ? [{ column: ds.tenantKey, ...tenant }] : [];
+}
+/**
+ * The call's RFC 0019 enforced constraints, from trusted context only. They
+ * apply to the queried dataset, in its filter vocabulary, never to joined
+ * targets.
+ */
+export function runtimeConstraints(context) {
+    return context?.runtime?.constraints ?? [];
+}
+/** ANDs each row-scope predicate onto `qb`, with columns qualified by `qualify`. */
+export function applyRowScope(qb, scope, qualify = column => column) {
+    for (const predicate of scope) {
+        qb = qb.where(qualify(predicate.column), predicate.operator, predicate.value);
+    }
+    return qb;
+}

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

@@ -0,0 +1,23 @@
+import type { AnyDatasetInstance, ExecutionContext } from '../types.js';
+import type { QueryBuilderFactoryLike, QueryBuilderLike } from '../query-builder-protocol.js';
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
+import { type RelationshipBuilderContext } from './relationship-builder-plan.js';
+export interface ScopedDatasetSourceOptions {
+    builderFactory: Pick<QueryBuilderFactoryLike, 'table'>;
+    ds: AnyDatasetInstance;
+    context?: ExecutionContext;
+    joinCtx: RelationshipBuilderContext | undefined;
+    dialect: DatasetSqlDialectRules;
+    timezone: string | undefined;
+}
+/**
+ * The dataset's source as a builder with every trusted row restriction
+ * applied (RFC 0020): `FINAL`, relationship joins scoped by each target's own
+ * row scope, the dataset's row scope, and the call's enforced constraints.
+ *
+ * Every builder-path query shape reads its source through here, so none can
+ * read rows the context does not allow. Callers add their own selections,
+ * filters and aggregations on top; every predicate here is ANDed with them.
+ */
+export declare function scopedDatasetSource(options: ScopedDatasetSourceOptions): QueryBuilderLike;
+//# sourceMappingURL=scoped-dataset-source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-dataset-source.d.ts","sourceRoot":"","sources":["../../src/utils/scoped-dataset-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAC9F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAIxE,OAAO,EAGL,KAAK,0BAA0B,EAChC,MAAM,gCAAgC,CAAC;AAIxC,MAAM,WAAW,0BAA0B;IACzC,cAAc,EAAE,IAAI,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAC;IACvD,EAAE,EAAE,kBAAkB,CAAC;IACvB,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAChD,OAAO,EAAE,sBAAsB,CAAC;IAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,gBAAgB,CAiBzF"}

package/dist/utils/scoped-dataset-source.js

@@ -0,0 +1,34 @@
+import { resolveFilterField } from '../query-planner.js';
+import { FINAL_SAFETY_SETTINGS, datasetSourceBuilder, queryReadsFinal } from './dataset-source.js';
+import { queryTimeFilter } from './query-timezone.js';
+import { applyRelationshipJoins, qualifyBaseColumn, } from './relationship-builder-plan.js';
+import { assertEnforcedConstraints } from './enforced-constraints.js';
+import { applyRowScope, datasetRowScope, runtimeConstraints } from './row-scope.js';
+/**
+ * The dataset's source as a builder with every trusted row restriction
+ * applied (RFC 0020): `FINAL`, relationship joins scoped by each target's own
+ * row scope, the dataset's row scope, and the call's enforced constraints.
+ *
+ * Every builder-path query shape reads its source through here, so none can
+ * read rows the context does not allow. Callers add their own selections,
+ * filters and aggregations on top; every predicate here is ANDed with them.
+ */
+export function scopedDatasetSource(options) {
+    const { ds, context, joinCtx, dialect, timezone } = options;
+    // Validators report this too; checked here so no path can skip it.
+    assertEnforcedConstraints(ds, context);
+    let qb = applyRelationshipJoins(datasetSourceBuilder(options.builderFactory, ds), joinCtx);
+    // A resolved join target is read with FINAL even when this dataset isn't.
+    if (queryReadsFinal(ds, joinCtx) && qb.settings)
+        qb = qb.settings(FINAL_SAFETY_SETTINGS);
+    qb = applyRowScope(qb, datasetRowScope(ds, context), column => qualifyBaseColumn(joinCtx, column));
+    // Constraints are filters in the dataset's vocabulary, applied exactly as a
+    // caller filter on the same field would be.
+    for (const constraint of runtimeConstraints(context)) {
+        const expression = resolveFilterField(ds, constraint.field, joinCtx);
+        for (const predicate of queryTimeFilter(dialect, ds, constraint, expression, timezone)) {
+            qb = qb.where(predicate.expression, predicate.operator, predicate.value);
+        }
+    }
+    return qb;
+}

package/dist/utils/semantic-tool.d.ts

@@ -1,5 +1,5 @@
-import type { ZodTypeAny } from 'zod';
+import type { ZodType } from 'zod';
 export declare function semanticToolNamePart(name: string): string;
-export declare function parseCanonicalToolInput(schema: ZodTypeAny, input: Record<string, unknown>, label: string): Record<string, unknown>;
+export declare function parseCanonicalToolInput(schema: ZodType, input: Record<string, unknown>, label: string): Record<string, unknown>;
 export declare function redactSemanticToolSql(result: unknown, includeSql: boolean): unknown;
 //# sourceMappingURL=semantic-tool.d.ts.map

package/dist/utils/semantic-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semantic-tool.d.ts","sourceRoot":"","sources":["../../src/utils/semantic-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEtC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAenF"}
+{"version":3,"file":"semantic-tool.d.ts","sourceRoot":"","sources":["../../src/utils/semantic-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAenF"}

package/dist/utils/semantic-tool.js

@@ -6,7 +6,7 @@ export function parseCanonicalToolInput(schema, input, label) {
     const result = schema.safeParse(input);
     if (!result.success) {
         const issues = result.error.issues.map((issue) => {
-            const path = issue.path.length > 0 ? issue.path.join('.') : 'input';
+            const path = issue.path.length > 0 ? issue.path.map(String).join('.') : 'input';
             return `${path}: ${issue.message}`;
         }).join('; ');
         throw new Error(`Invalid ${label}: ${issues}`);

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

@@ -1,7 +1,8 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.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): {
+export declare function shiftRangeSql(dialect: DatasetSqlDialectRules, shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, period?: string): {
     lower: string;
     upper: string;
     lowerInclusive: string;
@@ -9,11 +10,11 @@ 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, axis: TimeMeasureAxis, axisGuard: string): string;
+export declare function shiftCalendarGuardSql(dialect: DatasetSqlDialectRules, 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;
+export declare function shiftWallTimeSeriesGuardSql(dialect: DatasetSqlDialectRules, 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): {
+export declare function shiftBucketCtes(dialect: DatasetSqlDialectRules, shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, index: number): {
     ctes: string[];
     rowsSql: string;
     sourceTimesSql: string;

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,MAAM,aAAa,CAAC;AAI1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAK9D,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAoBlG;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"}
+{"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,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAK9D,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAoBnI;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,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOtJ;AAED,+FAA+F;AAC/F,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,MAAM,CAMnJ;AAED,2FAA2F;AAC3F,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,EAAE,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,CAuBjM"}

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

@@ -1,27 +1,25 @@
-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';
 import { anchoredCalendarShiftSql } from './calendar-shift-sql.js';
 /** Preserve the selected portion of a bucket and both authored endpoint operators. */
-export function shiftRangeSql(shift, axis, period) {
+export function shiftRangeSql(dialect, shift, axis, period) {
     const first = period ?? '_hq_first';
     const last = period ?? '_hq_last';
-    const end = addTimeSql(last, 1, axis.grain);
+    const end = dialect.addTime(last, 1, axis.grain);
     const calendar = calendarShiftAtFineGrain(shift.interval, axis.grain);
     // 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.
     // A partial bucket keeps the matching slice of that shifted range, so both
     // bounds are placed relative to the anchor rather than shifted on their own.
     const shiftBound = (point, anchor) => calendar
-        ? anchoredCalendarShiftSql(point, anchor, shift.interval)
-        : subtractTimeSql(point, shift.interval.amount, shift.interval.unit);
-    const upper = shiftBound(`least(${end}, _hq_upper)`, last);
-    const shiftedEnd = addTimeSql(subtractTimeSql(last, shift.interval.amount, shift.interval.unit), 1, axis.grain);
+        ? anchoredCalendarShiftSql(dialect, point, anchor, shift.interval)
+        : dialect.subtractTime(point, shift.interval.amount, shift.interval.unit);
+    const upper = shiftBound(dialect.least(end, '_hq_upper'), last);
+    const shiftedEnd = dialect.addTime(dialect.subtractTime(last, shift.interval.amount, shift.interval.unit), 1, axis.grain);
     return {
-        lower: shiftBound(`greatest(${first}, _hq_lower)`, first),
-        upper: calendar ? `if(_hq_upper >= ${end}, ${shiftedEnd}, ${upper})` : upper,
+        lower: shiftBound(dialect.greatest(first, '_hq_lower'), first),
+        upper: calendar ? dialect.ifElse(`_hq_upper >= ${end}`, shiftedEnd, upper) : upper,
         lowerInclusive: period ? `(${period} > _hq_lower OR ${Number(axis.lowerInclusive)})` : String(Number(axis.lowerInclusive)),
         upperInclusive: `(_hq_upper < ${end} AND ${Number(axis.upperInclusive)})`,
     };
@@ -31,29 +29,30 @@ 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, axis, axisGuard) {
+export function shiftCalendarGuardSql(dialect, 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);
+    const { lower, upper } = shiftRangeSql(dialect, shift, axis);
+    const first = dialect.truncateTime(lower, grain);
+    const last = dialect.truncateTime(upper, grain);
+    const count = `${dialect.timeDiff(grain, first, last)} + ${axisGuard}`;
+    return calendarBucketGuardSql(dialect, 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);
+export function shiftWallTimeSeriesGuardSql(dialect, shift, grain) {
+    const end = dialect.addTime('_hq_period', 1, grain);
+    return shiftWallTimeGuardSql(dialect, shift.interval, grain, '_hq_series CROSS JOIN _hq_bounds', '_hq_period', dialect.greatest('_hq_period', '_hq_lower'), dialect.least(end, '_hq_upper'), end);
 }
 /** Map output buckets to their earlier half-open ranges, retaining calendar arithmetic. */
-export function shiftBucketCtes(shift, axis, index) {
+export function shiftBucketCtes(dialect, shift, axis, index) {
     const { grain } = axis;
     const ranges = `_hq_shift_ranges${index}`;
     const keys = `_hq_shift_keys${index}`;
-    const range = shiftRangeSql(shift, axis, '_hq_period');
-    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' })}`;
+    const range = shiftRangeSql(dialect, shift, axis, '_hq_period');
+    const bucket = dialect.truncateTime('_hq_shift_lower', grain);
+    const upperBucket = dialect.truncateTime('_hq_shift_upper', grain);
+    const partialUpper = dialect.ifElse(`_hq_shift_upper > ${upperBucket} OR _hq_shift_upper_inclusive`, '1', '0');
+    const count = dialect.greatest('0', `${dialect.timeDiff(grain, bucket, upperBucket)} + ${partialUpper}`);
+    const join = ` AS r INNER JOIN ${keys} AS b ON ${dialect.truncateTime('r._hq_time', grain)} = 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.
@@ -63,7 +62,7 @@ export function shiftBucketCtes(shift, axis, index) {
             // A DST transition can map a one-hour output bucket to zero or two
             // source hours. Enumerate source bucket keys and keep exact endpoints.
             // 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})`,
+            `${keys} AS (SELECT *, ${dialect.addTime(bucket, dialect.seriesIndex(count), grain)} AS _hq_source_period FROM ${ranges})`,
         ],
         rowsSql: `SELECT r.*, b._hq_period FROM _hq_scanned${join}`,
     };

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

@@ -1,4 +1,5 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 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;
+export declare function shiftWallTimeGuardSql(dialect: DatasetSqlDialectRules, 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

@@ -1 +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"}
+{"version":3,"file":"shift-wall-time-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-wall-time-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAC7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKlE,0FAA0F;AAC1F,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,EAC/B,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,CAaR"}

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

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

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

@@ -1 +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"}
+{"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,CAgBjG"}

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

@@ -9,6 +9,9 @@ export function snapshotExecutionContext(context) {
                 ...context.runtime,
                 // Copy tenant objects and ID lists; retain adapter and AbortSignal identity.
                 tenant: structuredClone(context.runtime.tenant),
+                ...(context.runtime.constraints === undefined
+                    ? {}
+                    : { constraints: structuredClone(context.runtime.constraints) }),
             },
         }),
         ...(context.cache && { cache: { ...context.cache } }),

package/dist/utils/statement-parameters.d.ts

@@ -0,0 +1,58 @@
+import type { DatasetSqlDialectRules, DatasetSqlParameterType } from '../dataset-sql-dialect.js';
+/** A compiled builder statement: SQL with positional `?` markers and their values. */
+export interface BuilderStatement {
+    readonly sql: string;
+    readonly parameters: readonly unknown[];
+}
+/** A query builder, as far as embedding its compiled statement is concerned. */
+export interface EmbeddableBuilder {
+    toSQLWithParams(): BuilderStatement;
+    toSQLWithPlaceholders?(placeholder: (value: unknown) => string): string;
+}
+/** An executable statement, rendered for its dialect. */
+export interface RenderedStatement {
+    sql: string;
+    parameters: unknown[];
+}
+/**
+ * Planner output that still carries markers. Not executable: only
+ * {@link renderStatement} turns it into SQL, so markers cannot reach callers.
+ */
+export interface PlannedStatement {
+    readonly text: string;
+    readonly parameters: StatementParameters;
+}
+/**
+ * Owns every value bound into one statement family (a statement and its
+ * preflight statements). Values are bound behind opaque markers; the dialect
+ * spells placeholders once, at render time, in the order the markers appear
+ * in the final text. See specs/datasets/0001-statement-parameters.md.
+ */
+export declare class StatementParameters {
+    readonly dialect: DatasetSqlDialectRules;
+    private readonly nonce;
+    private readonly values;
+    private readonly pieces;
+    constructor(dialect: DatasetSqlDialectRules);
+    /** Bind one value; place the returned marker where the value belongs. */
+    bind(value: unknown, type?: DatasetSqlParameterType): string;
+    /** Embed a builder statement whose SQL carries its own positional `?` markers. */
+    embed(piece: BuilderStatement): string;
+    /**
+     * Embed a query builder's statement.
+     *
+     * On positional `?` dialects the builder's own statement is embedded as one
+     * block, exactly as before: `toSQLWithPlaceholders` is not called, so a
+     * duck-typed builder that answers any method name keeps working. Dialects
+     * that number placeholders need each value bound here, so they require the
+     * builder to render through `toSQLWithPlaceholders`. A caller that already
+     * compiled the builder positionally can pass that statement to reuse it.
+     */
+    embedBuilder(builder: EmbeddableBuilder, compiled?: BuilderStatement): string;
+    /** Replace every marker in text order. Fails closed on foreign or malformed markers. */
+    render(text: string): RenderedStatement;
+    private marker;
+}
+/** Render planner output for execution. The only exit from a {@link PlannedStatement}. */
+export declare function renderStatement(statement: PlannedStatement): RenderedStatement;
+//# sourceMappingURL=statement-parameters.d.ts.map

package/dist/utils/statement-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-parameters.d.ts","sourceRoot":"","sources":["../../src/utils/statement-parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAE3H,sFAAsF;AACtF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,CAAC;CACzC;AAED,gFAAgF;AAChF,MAAM,WAAW,iBAAiB;IAChC,eAAe,IAAI,gBAAgB,CAAC;IACpC,qBAAqB,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,GAAG,MAAM,CAAC;CACzE;AAED,yDAAyD;AACzD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CAC1C;AAaD;;;;;GAKG;AACH,qBAAa,mBAAmB;IAKlB,QAAQ,CAAC,OAAO,EAAE,sBAAsB;IAJpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;gBAE5B,OAAO,EAAE,sBAAsB;IAEpD,yEAAyE;IACzE,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,uBAAuB,GAAG,MAAM;IAK5D,kFAAkF;IAClF,KAAK,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM;IActC;;;;;;;;;OASG;IACH,YAAY,CAAC,OAAO,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAa7E,wFAAwF;IACxF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB;IA2BvC,OAAO,CAAC,MAAM;CAGf;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAAC,SAAS,EAAE,gBAAgB,GAAG,iBAAiB,CAE9E"}

package/dist/utils/statement-parameters.js

@@ -0,0 +1,101 @@
+// Private-use code points never appear in generated SQL, and the nonce makes
+// a marker unforgeable by any text that reaches a statement.
+const OPEN = '\uE000';
+const CLOSE = '\uE001';
+const MARKER = /\uE000([0-9a-f]+):([vb]):(\d+)\uE001/g;
+function createNonce() {
+    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(8));
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Owns every value bound into one statement family (a statement and its
+ * preflight statements). Values are bound behind opaque markers; the dialect
+ * spells placeholders once, at render time, in the order the markers appear
+ * in the final text. See specs/datasets/0001-statement-parameters.md.
+ */
+export class StatementParameters {
+    dialect;
+    nonce = createNonce();
+    values = [];
+    pieces = [];
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    /** Bind one value; place the returned marker where the value belongs. */
+    bind(value, type) {
+        this.values.push(type === undefined ? { value } : { value, type });
+        return this.marker('v', this.values.length - 1);
+    }
+    /** Embed a builder statement whose SQL carries its own positional `?` markers. */
+    embed(piece) {
+        if (!this.dialect.embedsPositionalPieces) {
+            throw new Error(`The "${this.dialect.name}" datasets dialect cannot embed positional query builder SQL; `
+                + 'the query builder must render placeholders for the datasets planner.');
+        }
+        if (piece.sql.includes(OPEN) || piece.sql.includes(CLOSE)) {
+            throw new Error('Query builder SQL cannot contain datasets statement markers.');
+        }
+        this.pieces.push({ sql: piece.sql, parameters: [...piece.parameters] });
+        return this.marker('b', this.pieces.length - 1);
+    }
+    /**
+     * Embed a query builder's statement.
+     *
+     * On positional `?` dialects the builder's own statement is embedded as one
+     * block, exactly as before: `toSQLWithPlaceholders` is not called, so a
+     * duck-typed builder that answers any method name keeps working. Dialects
+     * that number placeholders need each value bound here, so they require the
+     * builder to render through `toSQLWithPlaceholders`. A caller that already
+     * compiled the builder positionally can pass that statement to reuse it.
+     */
+    embedBuilder(builder, compiled) {
+        if (this.dialect.embedsPositionalPieces)
+            return this.embed(compiled ?? builder.toSQLWithParams());
+        if (typeof builder.toSQLWithPlaceholders !== 'function') {
+            throw new Error(`The "${this.dialect.name}" datasets dialect numbers placeholders; `
+                + 'the query builder must implement toSQLWithPlaceholders.');
+        }
+        const sql = builder.toSQLWithPlaceholders(value => this.bind(value));
+        if (typeof sql !== 'string')
+            throw new Error('Query builder toSQLWithPlaceholders must return SQL text.');
+        return sql;
+    }
+    /** Replace every marker in text order. Fails closed on foreign or malformed markers. */
+    render(text) {
+        const parameters = [];
+        const reused = new Map();
+        const sql = text.replace(MARKER, (_match, nonce, kind, position) => {
+            if (nonce !== this.nonce)
+                throw new Error('Statement contains a marker from another compilation.');
+            const index = Number(position);
+            if (kind === 'b') {
+                const piece = this.pieces[index];
+                if (!piece)
+                    throw new Error('Statement contains an unknown builder marker.');
+                parameters.push(...piece.parameters);
+                return piece.sql;
+            }
+            const bound = this.values[index];
+            if (!bound)
+                throw new Error('Statement contains an unknown parameter marker.');
+            const existing = this.dialect.reusesPlaceholders ? reused.get(index) : undefined;
+            if (existing !== undefined)
+                return existing;
+            const placeholder = this.dialect.placeholder(parameters.length, bound);
+            parameters.push(bound.value);
+            reused.set(index, placeholder);
+            return placeholder;
+        });
+        if (sql.includes(OPEN) || sql.includes(CLOSE)) {
+            throw new Error('Statement contains a malformed parameter marker.');
+        }
+        return { sql, parameters };
+    }
+    marker(kind, index) {
+        return `${OPEN}${this.nonce}:${kind}:${index}${CLOSE}`;
+    }
+}
+/** Render planner output for execution. The only exit from a {@link PlannedStatement}. */
+export function renderStatement(statement) {
+    return statement.parameters.render(statement.text);
+}

package/dist/utils/time-axis-calendar-guard.d.ts

@@ -1,3 +1,4 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 import type { TimeGrain } from '../types.js';
 /**
  * Calendar arithmetic can clamp a nonexistent date onto the previous bucket
@@ -5,5 +6,5 @@ import type { TimeGrain } from '../types.js';
  * repeating them would duplicate aggregates and cumulative contributions.
  * `count` must already include the series/fanout guards, bounding enumeration.
  */
-export declare function calendarBucketGuardSql(start: string, count: string, grain: TimeGrain): string;
+export declare function calendarBucketGuardSql(dialect: DatasetSqlDialectRules, start: string, count: string, grain: TimeGrain): string;
 //# sourceMappingURL=time-axis-calendar-guard.d.ts.map

package/dist/utils/time-axis-calendar-guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-axis-calendar-guard.d.ts","sourceRoot":"","sources":["../../src/utils/time-axis-calendar-guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAQ7F"}
+{"version":3,"file":"time-axis-calendar-guard.d.ts","sourceRoot":"","sources":["../../src/utils/time-axis-calendar-guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAU9H"}

package/dist/utils/time-axis-calendar-guard.js

@@ -1,17 +1,15 @@
-import { addTimeSql } from './time-arithmetic-sql.js';
 /**
  * Calendar arithmetic can clamp a nonexistent date onto the previous bucket
  * (for example Pacific/Apia, 2011-12-30). Reject non-increasing bucket starts:
  * repeating them would duplicate aggregates and cumulative contributions.
  * `count` must already include the series/fanout guards, bounding enumeration.
  */
-export function calendarBucketGuardSql(start, count, grain) {
+export function calendarBucketGuardSql(dialect, start, count, grain) {
     if (grain === 'minute' || grain === 'hour')
         return '0';
-    const current = addTimeSql(start, '_hq_calendar_index', grain);
-    const next = addTimeSql(start, '_hq_calendar_index + 1', grain);
+    const index = '_hq_calendar_index';
+    const current = dialect.addTime(start, index, grain);
+    const next = dialect.addTime(start, `${index} + 1`, grain);
     // Include the end boundary, which also bounds the source-row scan.
-    const indices = `range(toUInt64(greatest(1, ${count})))`;
-    return `throwIf(arrayExists(_hq_calendar_index -> ${next} <= ${current}, ${indices}), `
-        + "'Time range crosses a skipped local calendar bucket; use a UTC time key for this range.')";
+    return dialect.guard(dialect.anyIndex(index, dialect.greatest('1', count), `${next} <= ${current}`), 'Time range crosses a skipped local calendar bucket; use a UTC time key for this range.');
 }

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

@@ -1,5 +1,6 @@
+import type { StatementParameters } from './statement-parameters.js';
 import type { TimeMeasureAxis } from './time-measure-axis.js';
-import type { TimeMeasureSqlSource } from './time-measure-source-sql.js';
+import { type TimeMeasureSqlSource } from './time-measure-source-sql.js';
 import type { ShiftMeasureDefinition } from '../types.js';
 export interface TimeMeasureSqlAxis {
     ctes: string[];
@@ -9,5 +10,5 @@ export interface TimeMeasureSqlAxis {
     postSeriesGuard: string;
 }
 /** Build bounded output buckets using the query timezone. */
-export declare function buildTimeMeasureAxisSql(source: TimeMeasureSqlSource, axis: TimeMeasureAxis, shifts?: readonly ShiftMeasureDefinition[]): TimeMeasureSqlAxis;
+export declare function buildTimeMeasureAxisSql(statement: StatementParameters, source: TimeMeasureSqlSource, axis: TimeMeasureAxis, shifts?: readonly ShiftMeasureDefinition[]): TimeMeasureSqlAxis;
 //# sourceMappingURL=time-measure-axis-sql.d.ts.map

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;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"}
+{"version":3,"file":"time-measure-axis-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAqB,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAE5F,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;AAED,6DAA6D;AAC7D,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,mBAAmB,EAC9B,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,SAAS,sBAAsB,EAAO,GAC7C,kBAAkB,CA2CpB"}