@pythia-software/query-table-core 0.9.6 → 0.9.8

package/dist/index.js

@@ -23,10 +23,10 @@ function parseCellDisplay(raw, context = "cell display") {
     throw Error(`${context}: ${reason}`);
   };
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fail("expected an object");
-  const record2 = raw;
-  if (typeof record2.kind !== "string" || !Object.prototype.hasOwnProperty.call(options, record2.kind)) return fail("unsupported kind");
-  const allowed = options[record2.kind];
-  for (const [key, value] of Object.entries(record2)) {
+  const record3 = raw;
+  if (typeof record3.kind !== "string" || !Object.prototype.hasOwnProperty.call(options, record3.kind)) return fail("unsupported kind");
+  const allowed = options[record3.kind];
+  for (const [key, value] of Object.entries(record3)) {
     if (key === "kind") continue;
     const rule = Object.prototype.hasOwnProperty.call(allowed, key) ? allowed[key] : void 0;
     if (!rule) return fail(`unsupported option ${key}`);
@@ -40,13 +40,16 @@ function parseCellDisplay(raw, context = "cell display") {
     if (key === "pattern" && value.length > 160) return fail("pattern must be at most 160 characters");
   }
   return {
-    ...record2,
-    ...record2.labels ? { labels: { ...record2.labels } } : {},
-    ...record2.tones ? { tones: { ...record2.tones } } : {}
+    ...record3,
+    ...record3.labels ? { labels: { ...record3.labels } } : {},
+    ...record3.tones ? { tones: { ...record3.tones } } : {}
   };
 }
 
 // src/properties.ts
+function isPropertyFieldLoaded(field, loadedFields) {
+  return !loadedFields || loadedFields.includes(field.name) || field.source.kind === "derived" && field.source.dependencies !== void 0 && field.source.dependencies.every((name) => loadedFields.includes(name));
+}
 var MAX_PROPERTIES = 200;
 var string = (value, max = 256) => typeof value === "string" && value.length > 0 && value.length <= max;
 var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -444,6 +447,71 @@ function renderItemPageTemplate(template, schema, row, id, query) {
   return fillUrlTemplate(template, ITEM_PAGE_TOKENS, (token) => token === "id" ? id : token === "query" ? query : readFieldValue(schema.fields.find((field) => field.name === token.slice(6)), row));
 }
 
+// src/jsonInspection.ts
+var MAX_JSON_INSPECTIONS = 200;
+var MAX_JSON_PATHS = 5e3;
+var record2 = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+var text = (x, max) => typeof x === "string" && x.length > 0 && x.length <= max;
+function isJsonPath(path) {
+  return text(path, 1e4) && /^\$(?:\[(?:0|[1-9]\d*|"(?:[^"\\\x00-\x1f]|\\(?:["\\/bfnrt]|u[\da-fA-F]{4}))*")\])*$/.test(path);
+}
+function isJsonBucketId(path) {
+  if (!text(path, 10032)) return false;
+  const index = path.lastIndexOf(":bucket:");
+  return index > 0 && isJsonPath(path.slice(0, index)) && /^(?:0|[1-9]\d*)$/.test(path.slice(index + 8)) && Number.isSafeInteger(Number(path.slice(index + 8))) && Number(path.slice(index + 8)) >= 20 && Number(path.slice(index + 8)) % 20 === 0;
+}
+function jsonInspectionScopeKey(scope) {
+  return JSON.stringify([scope.dataset, scope.rowId, scope.field]);
+}
+function parseJsonInspectionState(input) {
+  if (!record2(input) || input.version !== 1 || typeof input.open !== "boolean" || typeof input.raw !== "boolean" || typeof input.search !== "string" || input.search.length > 1e4 || input.searchMode !== "filter" && input.searchMode !== "find" || typeof input.visibleEntryLimit !== "number" || !Number.isInteger(input.visibleEntryLimit) || input.visibleEntryLimit < 1 || input.visibleEntryLimit > 1e4)
+    throw Error("Invalid or unsupported JSON inspection state.");
+  const paths = (value, valid) => {
+    if (!Array.isArray(value) || value.length > MAX_JSON_PATHS || !value.every(valid) || new Set(value).size !== value.length)
+      throw Error("Invalid JSON inspection paths.");
+    return value.slice();
+  };
+  const state = {
+    version: 1,
+    open: input.open,
+    search: input.search,
+    searchMode: input.searchMode,
+    raw: input.raw,
+    collapsedPaths: paths(input.collapsedPaths, isJsonPath),
+    expandedBuckets: paths(input.expandedBuckets, isJsonBucketId),
+    visibleEntryLimit: input.visibleEntryLimit,
+    searchOverrides: []
+  };
+  if (input.selectedMatch !== void 0) {
+    const match = input.selectedMatch;
+    if (!record2(match) || !isJsonPath(match.path) || match.part !== "key" && match.part !== "value" && match.part !== "path" || typeof match.start !== "number" || !Number.isSafeInteger(match.start) || match.start < 0 || match.start > 1048576)
+      throw Error("Invalid JSON match identity.");
+    state.selectedMatch = { path: match.path, part: match.part, start: match.start };
+  }
+  if (!Array.isArray(input.searchOverrides) || input.searchOverrides.length > MAX_JSON_PATHS) throw Error("Invalid JSON search expansion overrides.");
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of input.searchOverrides) {
+    if (!record2(entry) || !(isJsonPath(entry.path) || isJsonBucketId(entry.path)) || typeof entry.expanded !== "boolean" || seen.has(entry.path))
+      throw Error("Invalid JSON search expansion override.");
+    seen.add(entry.path);
+    state.searchOverrides.push({ path: entry.path, expanded: entry.expanded });
+  }
+  return state;
+}
+function parseJsonInspections(input) {
+  if (!Array.isArray(input) || input.length > MAX_JSON_INSPECTIONS) throw Error("Invalid JSON inspection scopes.");
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((entry) => {
+    if (!record2(entry) || !text(entry.dataset, 256) || !text(entry.field, 256) || !(text(entry.rowId, 1e3) || typeof entry.rowId === "number" && Number.isFinite(entry.rowId)))
+      throw Error("Invalid JSON inspection scope.");
+    const scope = { dataset: entry.dataset, rowId: entry.rowId, field: entry.field };
+    const key = jsonInspectionScopeKey(scope);
+    if (seen.has(key)) throw Error("Duplicate JSON inspection scope.");
+    seen.add(key);
+    return { ...scope, state: parseJsonInspectionState(entry.state) };
+  });
+}
+
 // src/metricNormalize.ts
 var METRIC_OPTION_SPECS = {
   top: {
@@ -451,16 +519,29 @@ var METRIC_OPTION_SPECS = {
     expressionY: "string",
     scope: ["allMatching", "shownRows"],
     groupLimit: "integer",
-    minCount: "positiveInteger",
+    minCount: "minCount",
     share: ["total", "group0"]
   },
+  minCount: {
+    min: "positiveInteger",
+    distinct: "string",
+    sum: "string"
+  },
   window: {
     reduce: ["total", "mean"],
     partial: ["omit", "include"]
   },
   dateGrouping: {
     field: "string",
-    interval: ["hour", "day", "week", "month", "year"],
+    interval: [
+      "hour",
+      "day",
+      "week",
+      "month",
+      "year",
+      "hourOfDay",
+      "dayOfWeek"
+    ],
     timeZone: "string",
     includeEmpty: "boolean",
     range: ["query", "observed", "custom"],
@@ -468,6 +549,10 @@ var METRIC_OPTION_SPECS = {
     end: "string",
     partialIntervals: ["include", "exclude"]
   },
+  occurrence: {
+    interval: ["hour", "day"],
+    includeEmpty: "boolean"
+  },
   display: {
     kind: [
       "auto",
@@ -542,12 +627,20 @@ var METRIC_OPTION_SPECS = {
 };
 function normalizeMetricOptions(raw) {
   const out = {}, diagnostics = [];
-  const record2 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+  const record3 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
   const copy = (input, specs) => {
     const result = {};
     for (const [key, spec] of Object.entries(specs)) {
       const v = input[key];
       if (v === void 0) continue;
+      if (spec === "minCount") {
+        const m = record3(v) ? copy(v, METRIC_OPTION_SPECS.minCount) : v;
+        const named = (x) => x === void 0 || typeof x === "string" && !!x && x.length <= 256;
+        if (record3(m) ? m.min !== void 0 && m.distinct === void 0 !== (m.sum === void 0) && named(m.distinct) && named(m.sum) : typeof m === "number" && Number.isSafeInteger(m) && m >= 1 && m <= 1e6)
+          result[key] = m;
+        else diagnostics.push(`Invalid metric ${key}.`);
+        continue;
+      }
       if (spec === "string" ? typeof v === "string" && v.length <= 1e4 : spec === "number" ? typeof v === "number" && Number.isFinite(v) : spec === "boolean" ? typeof v === "boolean" : spec === "integer" || spec === "positiveInteger" ? typeof v === "number" && Number.isSafeInteger(v) && v >= (spec === "positiveInteger" ? 1 : 0) && v <= 1e6 : typeof v === "string" && spec.includes(v))
         result[key] = v;
       else diagnostics.push(`Invalid metric ${key}.`);
@@ -559,7 +652,7 @@ function normalizeMetricOptions(raw) {
     copy(raw, METRIC_OPTION_SPECS.top)
   );
   if (raw.window !== void 0) {
-    if (record2(raw.window)) {
+    if (record3(raw.window)) {
       const w = copy(raw.window, METRIC_OPTION_SPECS.window);
       const periods = raw.window.periods;
       if (periods === "all" || Number.isSafeInteger(periods) && periods >= 0 && periods <= 1e6)
@@ -569,40 +662,48 @@ function normalizeMetricOptions(raw) {
     } else diagnostics.push("Invalid metric window.");
   }
   if (raw.dateGrouping !== void 0) {
-    if (record2(raw.dateGrouping)) {
+    if (record3(raw.dateGrouping)) {
       const d = copy(raw.dateGrouping, METRIC_OPTION_SPECS.dateGrouping);
       if (typeof d.field !== "string" || !d.field || d.field.length > 256 || !d.interval || typeof d.includeEmpty !== "boolean" || !d.range)
         diagnostics.push("Invalid metric date grouping.");
+      const occurrence = raw.dateGrouping.occurrence;
+      if (record3(occurrence)) {
+        const o = copy(occurrence, METRIC_OPTION_SPECS.occurrence);
+        if (!o.interval || typeof o.includeEmpty !== "boolean")
+          diagnostics.push("Invalid metric date grouping occurrence.");
+        d.occurrence = o;
+      } else if (occurrence !== void 0)
+        diagnostics.push("Invalid metric date grouping occurrence.");
       out.dateGrouping = d;
     } else diagnostics.push("Invalid metric date grouping.");
   }
   if (raw.display !== void 0) {
-    if (record2(raw.display)) {
+    if (record3(raw.display)) {
       if (typeof raw.display.kind !== "string")
         diagnostics.push("Invalid metric display kind.");
       const d = copy(raw.display, METRIC_OPTION_SPECS.display);
       for (const k of ["xScale", "yScale"]) {
-        if (record2(raw.display[k]))
+        if (record3(raw.display[k]))
           d[k] = copy(raw.display[k], METRIC_OPTION_SPECS.scale);
         else if (raw.display[k] !== void 0)
           diagnostics.push(`Invalid metric ${k}.`);
       }
       for (const k of ["format", "xFormat", "yFormat"])
-        if (record2(raw.display[k]))
+        if (record3(raw.display[k]))
           d[k] = copy(raw.display[k], METRIC_OPTION_SPECS.format);
-      if (record2(raw.display.list))
+      if (record3(raw.display.list))
         d.list = copy(raw.display.list, METRIC_OPTION_SPECS.list);
-      if (record2(raw.display.pivot))
+      if (record3(raw.display.pivot))
         d.pivot = copy(raw.display.pivot, METRIC_OPTION_SPECS.pivot);
       out.display = { kind: "auto", ...d };
     } else diagnostics.push("Invalid metric display.");
   }
   if (raw.distribution !== void 0) {
-    if (record2(raw.distribution))
+    if (record3(raw.distribution))
       out.distribution = copy(raw.distribution, METRIC_OPTION_SPECS.distribution);
     else diagnostics.push("Invalid metric distribution.");
   }
-  if (record2(raw.layout)) {
+  if (record3(raw.layout)) {
     const l = copy(raw.layout, METRIC_OPTION_SPECS.layout);
     for (const k of ["widthRem", "heightRem", "minWidthRem", "minHeightRem"])
       l[k] = Math.max(1, Math.min(1e3, Number(l[k] ?? 1)));
@@ -614,7 +715,7 @@ function normalizeMetricOptions(raw) {
     diagnostics.push("Invalid metric sort.");
   if (Array.isArray(raw.sort))
     out.sort = raw.sort.slice(0, 20).flatMap((s) => {
-      if (!record2(s) || typeof s.key !== "string" || !/^(value|y|count|samples|group(?:0|[1-9][0-9]?))$/.test(s.key) || !["asc", "desc"].includes(String(s.dir))) {
+      if (!record3(s) || typeof s.key !== "string" || !/^(value|y|count|samples|group(?:0|[1-9][0-9]?))$/.test(s.key) || !["asc", "desc"].includes(String(s.dir))) {
         diagnostics.push("Invalid metric sort.");
         return [];
       }
@@ -634,138 +735,620 @@ function normalizeMetricOptions(raw) {
   return out;
 }
 
-// src/query.ts
-function isOrGroup(term) {
-  return Array.isArray(term.any);
+// src/relativeTime.ts
+var UNIT_MS = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5, w: 6048e5 };
+var MAX_RELATIVE_TIME_MS = 864e13;
+function parseRelativeDuration(value) {
+  const valid = /^[+-](?:[0-9]+(?:ms|s|m|h|d|w))+$/.exec(value);
+  if (!valid || valid[0] !== value) return null;
+  const body = value.slice(1);
+  const components = /([0-9]+)(ms|s|m|h|d|w)/g;
+  let total = 0;
+  for (const match of body.matchAll(components)) {
+    const amount = Number(match[1]);
+    const unit = UNIT_MS[match[2]];
+    if (!Number.isSafeInteger(amount) || amount > Math.floor((MAX_RELATIVE_TIME_MS - total) / unit)) return null;
+    total += amount * unit;
+  }
+  return value[0] === "-" && total !== 0 ? -total : total;
 }
-function predicatesOf(term) {
-  return isOrGroup(term) ? term.any : [term];
+function evaluationTime(options2) {
+  const now = options2.now ?? Date.now();
+  if (!Number.isSafeInteger(now) || Math.abs(now) > MAX_RELATIVE_TIME_MS) throw new Error("Invalid query evaluation time");
+  return now;
 }
-var ITEM_DETAILS_COLUMN = "__qt_item_details__";
-var EMPTY_QUERY = {
-  select: [],
-  where: [],
-  orderBy: [],
-  limit: 100,
-  offset: 0
-};
-var MAX_QUERY_LIMIT = Number.MAX_SAFE_INTEGER;
-var MAX_QUERY_OFFSET = 1e6;
-var MAX_SELECT_COLUMNS = 200;
-var MAX_WHERE_CLAUSES = 100;
-var MAX_ORDER_BY_TERMS = 20;
-var MAX_AGGREGATIONS = 20;
-var MAX_GROUP_BY_FIELDS = 20;
-var MAX_QUERY_TOKEN_LENGTH = 2 * 1024 * 1024;
-var MAX_FIELD_NAME_LENGTH = 256;
-var MAX_FILTER_VALUE_LENGTH = 1e4;
-var MAX_LABEL_LENGTH = 1e3;
-var MIN_COLUMN_WIDTH = 24;
-var MAX_COLUMN_WIDTH = 2e3;
-var FILTER_OPS = /* @__PURE__ */ new Set([
-  "=",
-  "!=",
-  ">",
-  ">=",
-  "<",
-  "<=",
-  "contains",
-  "starts_with",
-  "ends_with",
-  "matches_regex",
-  "not_matches_regex",
-  "length_gt",
-  "length_lt",
-  "length_eq",
-  "includes",
-  "is_null",
-  "is_not_null"
-]);
-var AGG_OPS = /* @__PURE__ */ new Set(["count", "count_distinct", "sum", "avg", "min", "max"]);
-function isRecord(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
+function relativeTimestamp(now, offsetMs) {
+  const result = now + offsetMs;
+  if (!Number.isSafeInteger(result) || Math.abs(result) > MAX_RELATIVE_TIME_MS) throw new Error("Relative time exceeds datetime limits");
+  return result;
 }
-function boundedString(value, maxLength) {
-  return typeof value === "string" && value.length > 0 && value.length <= maxLength ? value : null;
+
+// src/ops.ts
+var NULLITY = ["is_null", "is_not_null"];
+var COMPLEMENT_OP = {
+  "=": "!=",
+  "!=": "=",
+  ">": "<=",
+  "<=": ">",
+  ">=": "<",
+  "<": ">=",
+  is_null: "is_not_null",
+  is_not_null: "is_null",
+  matches_regex: "not_matches_regex",
+  not_matches_regex: "matches_regex"
+};
+function negateClause(clause, allowedOps) {
+  if (clause.value === "0" && !clause.negated) {
+    const zeroComplement = clause.op === "length_gt" ? "length_eq" : clause.op === "length_eq" ? "length_gt" : null;
+    if (zeroComplement && (!allowedOps || allowedOps.includes(zeroComplement))) {
+      return { field: clause.field, op: zeroComplement, value: "0" };
+    }
+  }
+  const complement = COMPLEMENT_OP[clause.op];
+  if (complement && (!allowedOps || allowedOps.includes(complement))) {
+    const next2 = { field: clause.field, op: complement, value: clause.value };
+    return next2;
+  }
+  const next = { field: clause.field, op: clause.op, value: clause.value };
+  if (!clause.negated) next.negated = true;
+  return next;
 }
-function boundedInteger(value, fallback, min, max) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-  return Math.max(min, Math.min(max, Math.round(value)));
+function isNegativePredicate(clause) {
+  return Boolean(clause.negated) || clause.op === "!=" || clause.op === "not_matches_regex" || clause.op === "is_not_null";
 }
-function normalizeWhereClause(item) {
-  if (!isRecord(item)) return null;
-  const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
-  const value = typeof item.value === "string" && item.value.length <= MAX_FILTER_VALUE_LENGTH ? item.value : null;
-  if (!field || typeof item.op !== "string" || !FILTER_OPS.has(item.op) || value == null) {
-    return null;
+var POSITIVE_OP_ORDER = ["=", ">", ">=", "contains", "starts_with", "ends_with", "length_gt", "length_lt", "length_eq", "matches_regex", "includes"];
+function opPairsForField(field) {
+  const ops = opsForField(field);
+  const allow = new Set(ops);
+  const pairs = [];
+  for (const op of POSITIVE_OP_ORDER) {
+    if (!allow.has(op)) continue;
+    const neg = negateClause({ field: "", op, value: "" }, ops);
+    pairs.push({ keep: { op, negated: false }, exclude: { op: neg.op, negated: Boolean(neg.negated) } });
   }
-  const clause = { field, op: item.op, value };
-  if (item.negated === true) clause.negated = true;
-  return clause;
+  if (allow.has("is_null") || allow.has("is_not_null")) {
+    pairs.push({ keep: { op: "is_null", negated: false }, exclude: { op: "is_not_null", negated: false } });
+  }
+  return pairs;
 }
-function cloneWhereTerm(term) {
-  const copy = isOrGroup(term) ? { ...term, any: term.any.map((c) => ({ ...c })) } : { ...term };
-  if (term.setFilter) copy.setFilter = { ...term.setFilter, values: [...term.setFilter.values] };
-  return copy;
+var OPS_BY_TYPE = {
+  text: [
+    "=",
+    "!=",
+    "contains",
+    "starts_with",
+    "ends_with",
+    "matches_regex",
+    "not_matches_regex",
+    "length_gt",
+    "length_lt",
+    "length_eq",
+    ...NULLITY
+  ],
+  enum: ["=", "!=", ...NULLITY],
+  number: ["=", "!=", ">", ">=", "<", "<=", ...NULLITY],
+  datetime: ["=", "!=", ">", ">=", "<", "<=", ...NULLITY],
+  bool: ["=", "!=", ...NULLITY],
+  textarray: ["includes", ...NULLITY]
+};
+var NULLARY_OPS = new Set(NULLITY);
+function opsForField(field) {
+  return field.filter?.ops ?? OPS_BY_TYPE[field.type];
 }
-function normalizeSetFilter(item) {
-  if (!isRecord(item)) return void 0;
-  const id = boundedString(item.id, MAX_FIELD_NAME_LENGTH);
-  if (!id || typeof item.mode !== "string" || !["any", "all", "none", "empty"].includes(item.mode) || !Array.isArray(item.values)) return void 0;
-  if (item.values.length > MAX_WHERE_CLAUSES || !item.values.every((value) => typeof value === "string" && value.length <= MAX_FILTER_VALUE_LENGTH)) return void 0;
-  return { id, mode: item.mode, values: [...item.values] };
+function opAllowedForType(type, op) {
+  return OPS_BY_TYPE[type].includes(op);
 }
-function normalizeWhereTerms(input) {
-  const where = [];
-  let literalBudget = MAX_WHERE_CLAUSES;
-  for (const item of input) {
-    if (literalBudget <= 0) break;
-    const start = where.length;
-    if (isRecord(item) && Array.isArray(item.any)) {
-      const members = [];
-      for (const inner of item.any) {
-        if (literalBudget <= 0) break;
-        const clause = normalizeWhereClause(inner);
-        if (clause) {
-          members.push(clause);
-          literalBudget--;
-        }
-      }
-      if (members.length === 1) where.push(members[0]);
-      else if (members.length > 1) where.push({ any: members });
-    } else {
-      const clause = normalizeWhereClause(item);
-      if (clause) {
-        where.push(clause);
-        literalBudget--;
-      }
+function coerceValue(type, raw, now) {
+  switch (type) {
+    case "number": {
+      const n = Number(raw);
+      if (raw.trim() === "" || Number.isNaN(n)) throw new Error(`not a number: ${JSON.stringify(raw)}`);
+      return n;
     }
-    if (where.length > start && isRecord(item)) {
-      const metadata = normalizeSetFilter(item.setFilter);
-      if (metadata) where[start].setFilter = metadata;
+    case "bool": {
+      const v = raw.toLowerCase();
+      if (v === "true" || v === "1" || v === "t") return true;
+      if (v === "false" || v === "0" || v === "f") return false;
+      throw new Error(`not a bool: ${JSON.stringify(raw)}`);
+    }
+    case "datetime": {
+      if (raw.startsWith("+") || raw.startsWith("-")) {
+        const offset = parseRelativeDuration(raw);
+        if (offset === null) throw new Error(`not a signed duration: ${JSON.stringify(raw)}`);
+        return relativeTimestamp(now ?? Date.now(), offset);
+      }
+      const ms = Date.parse(raw);
+      if (Number.isNaN(ms)) throw new Error(`not a datetime: ${JSON.stringify(raw)}`);
+      return ms;
     }
+    default:
+      return raw;
   }
-  return where;
 }
-function normalizeMetricWhere(value) {
-  if (value === void 0) return { invalid: false };
-  if (!Array.isArray(value)) return { invalid: true };
-  const where = normalizeWhereTerms(value);
-  const supplied = value.reduce((count, term) => count + (isRecord(term) && Array.isArray(term.any) ? term.any.length : 1), 0);
-  const kept = where.reduce((count, term) => count + predicatesOf(term).length, 0);
-  return { ...where.length ? { where } : {}, invalid: supplied !== kept };
+
+// src/metricDates.ts
+import { Temporal } from "temporal-polyfill";
+var METRIC_DATE_INTERVALS = [
+  "hour",
+  "day",
+  "week",
+  "month",
+  "year",
+  "hourOfDay",
+  "dayOfWeek"
+];
+var METRIC_CYCLE_INTERVALS = ["hourOfDay", "dayOfWeek"];
+function isMetricCycle(interval) {
+  return interval === "hourOfDay" || interval === "dayOfWeek";
 }
-function normalizeQueryState(input, fallback = EMPTY_QUERY) {
-  return normalizeQuery(input, fallback, true);
+function metricCycleSlots(interval) {
+  return interval === "hourOfDay" ? Array.from({ length: 24 }, (_, i) => i) : [1, 2, 3, 4, 5, 6, 7];
 }
-function normalizeQuery(input, fallback, links) {
-  const raw = isRecord(input) ? input : {};
-  const select = [];
-  if (Array.isArray(raw.select)) {
-    for (const item of raw.select.slice(0, MAX_SELECT_COLUMNS)) {
-      if (!isRecord(item)) continue;
-      const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
-      if (!field) continue;
+function metricCalendarUnit(interval) {
+  return interval === "hourOfDay" ? "hour" : interval === "dayOfWeek" ? "day" : interval;
+}
+function metricCycleSlot(time, interval, timeZone = "UTC") {
+  if (timeZone === "UTC") {
+    const date = new Date(time);
+    return interval === "hourOfDay" ? date.getUTCHours() : (date.getUTCDay() + 6) % 7 + 1;
+  }
+  const zoned = Temporal.Instant.fromEpochMilliseconds(time).toZonedDateTimeISO(timeZone);
+  return interval === "hourOfDay" ? zoned.hour : zoned.dayOfWeek;
+}
+function metricDateTime(value, timeZone = "UTC") {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2}))?$/.test(
+    value
+  ))
+    throw Error(
+      "Date grouping requires ISO dates or timestamps with a timezone."
+    );
+  const time = Date.parse(value), month = Number(value.slice(5, 7)), day = Number(value.slice(8, 10));
+  const calendar = /* @__PURE__ */ new Date(0);
+  calendar.setUTCFullYear(Number(value.slice(0, 4)), month, 0);
+  if (!Number.isFinite(time) || month < 1 || month > 12 || day < 1 || day > calendar.getUTCDate())
+    throw Error("Invalid date grouping value.");
+  return value.length === 10 && timeZone !== "UTC" ? Temporal.PlainDate.from(value).toZonedDateTime(timeZone).epochMilliseconds : time;
+}
+function metricOffsetTransition(start, end, timeZone) {
+  if (end <= start) return void 0;
+  const offset = (time) => Temporal.Instant.fromEpochMilliseconds(time).toZonedDateTimeISO(timeZone).offsetNanoseconds;
+  const before = offset(start);
+  if (before === offset(end)) return void 0;
+  while (end - start > 1) {
+    const middle = Math.floor((start + end) / 2);
+    if (offset(middle) === before) start = middle;
+    else end = middle;
+  }
+  return end;
+}
+function metricDateFloor(time, cycleOrInterval, timeZone = "UTC") {
+  const interval = metricCalendarUnit(cycleOrInterval);
+  if (timeZone !== "UTC") {
+    const zoned = Temporal.Instant.fromEpochMilliseconds(time).toZonedDateTimeISO(timeZone);
+    if (interval === "hour") {
+      const floor = time - zoned.minute * 6e4 - zoned.second * 1e3 - zoned.millisecond;
+      return metricOffsetTransition(floor, time, timeZone) ?? floor;
+    }
+    let date2 = zoned.toPlainDate();
+    if (interval === "week") date2 = date2.subtract({ days: date2.dayOfWeek - 1 });
+    if (interval === "month" || interval === "year")
+      date2 = date2.with({ day: 1 });
+    if (interval === "year") date2 = date2.with({ month: 1 });
+    return date2.toZonedDateTime(timeZone).epochMilliseconds;
+  }
+  const date = new Date(time);
+  date.setUTCMinutes(0, 0, 0);
+  if (interval !== "hour") date.setUTCHours(0);
+  if (interval === "week")
+    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 6) % 7);
+  if (interval === "month" || interval === "year") date.setUTCDate(1);
+  if (interval === "year") date.setUTCMonth(0);
+  return date.getTime();
+}
+function metricDateNext(time, cycleOrInterval, timeZone = "UTC") {
+  const interval = metricCalendarUnit(cycleOrInterval);
+  if (timeZone !== "UTC") {
+    const zoned = Temporal.Instant.fromEpochMilliseconds(time).toZonedDateTimeISO(timeZone);
+    if (interval === "hour") {
+      const target = zoned.toPlainDateTime().with({
+        minute: 0,
+        second: 0,
+        millisecond: 0,
+        microsecond: 0,
+        nanosecond: 0
+      }).add({ hours: 1 });
+      let next = target.toZonedDateTime(timeZone).epochMilliseconds;
+      if (next <= time)
+        next = target.toZonedDateTime(timeZone, {
+          disambiguation: "later"
+        }).epochMilliseconds;
+      return metricOffsetTransition(time, next, timeZone) ?? next;
+    }
+    let date2 = zoned.toPlainDate();
+    if (interval === "month") date2 = date2.with({ day: 1 }).add({ months: 1 });
+    else if (interval === "year")
+      date2 = date2.with({ month: 1, day: 1 }).add({ years: 1 });
+    else if (interval === "week")
+      date2 = date2.subtract({ days: date2.dayOfWeek - 1 }).add({ weeks: 1 });
+    else date2 = date2.add({ days: 1 });
+    return date2.toZonedDateTime(timeZone).epochMilliseconds;
+  }
+  const date = new Date(time);
+  if (interval === "hour") date.setUTCHours(date.getUTCHours() + 1);
+  else if (interval === "month") date.setUTCMonth(date.getUTCMonth() + 1);
+  else if (interval === "year") date.setUTCFullYear(date.getUTCFullYear() + 1);
+  else date.setUTCDate(date.getUTCDate() + (interval === "week" ? 7 : 1));
+  return date.getTime();
+}
+function metricCustomEndTime(value, timeZone = "UTC") {
+  const time = metricDateTime(value, timeZone);
+  return value.length === 10 ? metricDateNext(time, "day", timeZone) - 1 : time;
+}
+function isGroupingTimeZone(value) {
+  if (typeof value !== "string" || !value || value.length > 80 || /^[+-]/.test(value))
+    return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateDateGrouping(config) {
+  if (typeof config.field !== "string" || !config.field || config.field.length > 256 || !METRIC_DATE_INTERVALS.includes(config.interval) || typeof config.includeEmpty !== "boolean" || !["query", "observed", "custom"].includes(config.range) || config.partialIntervals !== void 0 && !["include", "exclude"].includes(config.partialIntervals))
+    throw Error("Invalid date grouping definition.");
+  if (config.timeZone !== void 0 && !isGroupingTimeZone(config.timeZone))
+    throw Error(
+      "Use a valid IANA grouping timezone, such as America/Denver or UTC."
+    );
+  if (config.occurrence !== void 0) {
+    const o = config.occurrence;
+    if (!o || typeof o !== "object" || Array.isArray(o) || !["hour", "day"].includes(o.interval) || typeof o.includeEmpty !== "boolean")
+      throw Error("Invalid date grouping occurrence.");
+    if (!isMetricCycle(config.interval))
+      throw Error(
+        "Occurrences summarise an hour-of-day or day-of-week slot; calendar intervals are already one occurrence each."
+      );
+    if (config.interval === "hourOfDay" && o.interval !== "hour")
+      throw Error("An hour-of-day slot occurs once per hour: use hourly occurrences.");
+    if (config.partialIntervals === "include")
+      throw Error(
+        "Occurrences are always whole: a partial day or hour would bias the typical value. Leave out partialIntervals."
+      );
+  }
+  if (config.range === "custom" && (isMetricCycle(config.interval) ? config.occurrence?.includeEmpty : config.includeEmpty)) {
+    const start = metricDateTime(config.start ?? "", config.timeZone), end = metricCustomEndTime(config.end ?? "", config.timeZone);
+    if (end < start)
+      throw Error("The end date must be on or after the start date.");
+  }
+}
+function metricDateRange(config, query, observed, now, canonical) {
+  let min = Infinity, max = -Infinity;
+  for (const time of observed) {
+    min = Math.min(min, time);
+    max = Math.max(max, time);
+  }
+  if (config.range === "observed")
+    return observed.length ? [min, max] : void 0;
+  if (config.range === "custom") {
+    const start2 = metricDateFloor(
+      metricDateTime(config.start ?? "", config.timeZone),
+      config.interval,
+      config.timeZone
+    );
+    const end2 = metricDateFloor(
+      metricCustomEndTime(config.end ?? "", config.timeZone),
+      config.interval,
+      config.timeZone
+    );
+    if (observed.length && (start2 > min || end2 < max))
+      throw Error(
+        "Custom date bounds must include all observed buckets. Narrow the query filters to exclude data."
+      );
+    return [start2, end2];
+  }
+  let start = -Infinity, end = Infinity;
+  for (const term of query.where) {
+    if (isWhereGroup(term) || term.negated || canonical(term.field) !== canonical(config.field))
+      continue;
+    if (!["=", ">", ">=", "<", "<="].includes(term.op)) continue;
+    const time = Number(coerceValue("datetime", term.value, now));
+    if (term.op === ">" || term.op === ">=" || term.op === "=")
+      start = Math.max(start, time + (term.op === ">" ? 1 : 0));
+    if (term.op === "<" || term.op === "<=" || term.op === "=")
+      end = Math.min(end, time - (term.op === "<" ? 1 : 0));
+  }
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    const missing = [
+      ...Number.isFinite(start) ? [] : ["a lower bound (>= or >)"],
+      ...Number.isFinite(end) ? [] : ["an upper bound (<= or <)"]
+    ].join(" and ");
+    throw Error(
+      `Include empty dates with range "query" needs a bounded date filter on ${config.field}: add ${missing} as top-level filters (bounds inside OR groups do not count). Otherwise use range "observed" to fill from the first to the last observed date, or range "custom" with start and end.`
+    );
+  }
+  if (end < start) return void 0;
+  return [
+    metricDateFloor(start, config.interval, config.timeZone),
+    metricDateFloor(end, config.interval, config.timeZone)
+  ];
+}
+
+// src/groupKeys.ts
+var GROUP_KEY_INTERVALS = ["hour", "day", "week", "month", "year"];
+function isCalendarGroupKey(key) {
+  return typeof key === "object" && key !== null;
+}
+function groupKeyField(key) {
+  return isCalendarGroupKey(key) ? key.field : key;
+}
+function groupKeyFields(keys) {
+  return keys.map(groupKeyField);
+}
+function calendarGroupKey(keys, field) {
+  return keys.find((key) => isCalendarGroupKey(key) && key.field === field);
+}
+function calendarKeyReader(key) {
+  let start = Infinity, end = -Infinity, iso = "";
+  return (value) => {
+    if (value == null) return null;
+    const input = value instanceof Date ? value.toISOString() : value;
+    if (typeof input !== "string")
+      throw Error(`Calendar group key ${key.field} needs ISO dates or timestamps with a timezone.`);
+    const time = metricDateTime(input, key.timeZone);
+    if (time < start || time >= end) {
+      start = metricDateFloor(time, key.interval, key.timeZone);
+      end = metricDateNext(start, key.interval, key.timeZone);
+      iso = new Date(start).toISOString();
+    }
+    return iso;
+  };
+}
+function datetimeValue(value) {
+  const time = value instanceof Date ? value.getTime() : typeof value === "number" ? value : typeof value === "string" && value !== "" ? Date.parse(value) : NaN;
+  return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+function keyClause(field, value) {
+  if (!field || field.type === "textarray" || !isFilterable(field)) return null;
+  if (value == null) return { field: field.name, op: "is_null", value: "" };
+  if (field.type === "datetime") {
+    const iso = datetimeValue(value);
+    return iso === null ? null : { field: field.name, op: "=", value: iso };
+  }
+  if (typeof value === "number" ? !Number.isFinite(value) : typeof value !== "string" && typeof value !== "boolean")
+    return null;
+  return { field: field.name, op: "=", value: String(value) };
+}
+function calendarKeyClauses(field, key, value) {
+  if (!field || field.type !== "datetime" || !isFilterable(field)) return null;
+  if (value == null) return [{ field: field.name, op: "is_null", value: "" }];
+  const iso = datetimeValue(value);
+  if (iso === null) return null;
+  const start = Date.parse(iso), end = metricDateNext(start, key.interval, key.timeZone);
+  if (!Number.isFinite(end) || end <= start) return null;
+  return [
+    { field: field.name, op: ">=", value: iso },
+    { field: field.name, op: "<", value: new Date(end).toISOString() }
+  ];
+}
+function groupKeyTerms(keys, group, schema) {
+  const terms = [];
+  for (const key of keys) {
+    const name = groupKeyField(key);
+    const field = resolveField(schema, name);
+    if (isCalendarGroupKey(key)) {
+      const range = calendarKeyClauses(field, key, group[name]);
+      if (!range) return null;
+      terms.push(...range);
+      continue;
+    }
+    const term = keyClause(field, group[name]);
+    if (!term) return null;
+    terms.push(term);
+  }
+  return terms;
+}
+
+// src/query.ts
+function isWhereConjunction(branch) {
+  return branch != null && Array.isArray(branch.all);
+}
+function isOrGroup(term) {
+  const any = term.any;
+  return Array.isArray(any) && !any.some((member) => isWhereConjunction(member));
+}
+function isOrOfAndsGroup(term) {
+  const any = term.any;
+  return Array.isArray(any) && any.some(isWhereConjunction);
+}
+function isWhereGroup(term) {
+  return Array.isArray(term.any);
+}
+function predicatesOf(term) {
+  if (!isWhereGroup(term)) return [term];
+  return term.any.flatMap((member) => isWhereConjunction(member) ? member.all : [member]);
+}
+function branchesOf(term) {
+  if (!isWhereGroup(term)) return [[term]];
+  return term.any.map((member) => isWhereConjunction(member) ? member.all : [member]);
+}
+var ITEM_DETAILS_COLUMN = "__qt_item_details__";
+var MAX_HOST_QUERY_PARAMS = 64;
+var MAX_HOST_QUERY_VALUES = 64;
+var MAX_HOST_QUERY_VALUE_LENGTH = 4e3;
+var MAX_HOST_QUERY_STATE_BYTES = 32 * 1024;
+var HOST_QUERY_PARAM_NAME = /^[A-Za-z_][A-Za-z0-9_.-]{0,127}$/;
+function parseHostQueryState(input) {
+  const fail = (why) => {
+    throw Error(`Invalid host query state: ${why}`);
+  };
+  if (!isRecord(input)) return fail("expected an object.");
+  if (Object.keys(input).some((key) => key !== "version" && key !== "params")) fail("unexpected properties.");
+  const version = input.version;
+  if (typeof version !== "number" || !Number.isSafeInteger(version) || version < 1) return fail("unsupported version.");
+  if (!isRecord(input.params)) return fail("params must be an object.");
+  const names = Object.keys(input.params).sort();
+  if (names.length > MAX_HOST_QUERY_PARAMS) fail("too many parameters.");
+  const params = {};
+  for (const name of names) {
+    const values = input.params[name];
+    if (!HOST_QUERY_PARAM_NAME.test(name)) fail("invalid parameter name.");
+    if (!Array.isArray(values) || values.length > MAX_HOST_QUERY_VALUES || values.some((value) => typeof value !== "string" || value.length > MAX_HOST_QUERY_VALUE_LENGTH))
+      fail(`parameter ${name} must be a list of strings.`);
+    params[name] = [...values];
+  }
+  const state = { version, params };
+  if (new TextEncoder().encode(JSON.stringify(state)).length > MAX_HOST_QUERY_STATE_BYTES) fail("payload too large.");
+  return state;
+}
+var EMPTY_QUERY = {
+  select: [],
+  where: [],
+  orderBy: [],
+  limit: 100,
+  offset: 0
+};
+var MAX_QUERY_LIMIT = Number.MAX_SAFE_INTEGER;
+var MAX_QUERY_OFFSET = 1e6;
+var MAX_SELECT_COLUMNS = 200;
+var MAX_WHERE_CLAUSES = 100;
+var MAX_ORDER_BY_TERMS = 20;
+var MAX_AGGREGATIONS = 20;
+var MAX_GROUP_BY_FIELDS = 20;
+var MAX_QUERY_TOKEN_LENGTH = 2 * 1024 * 1024;
+var MAX_FIELD_NAME_LENGTH = 256;
+var MAX_FILTER_VALUE_LENGTH = 1e4;
+var MAX_LABEL_LENGTH = 1e3;
+var MIN_COLUMN_WIDTH = 24;
+var MAX_COLUMN_WIDTH = 2e3;
+var FILTER_OPS = /* @__PURE__ */ new Set([
+  "=",
+  "!=",
+  ">",
+  ">=",
+  "<",
+  "<=",
+  "contains",
+  "starts_with",
+  "ends_with",
+  "matches_regex",
+  "not_matches_regex",
+  "length_gt",
+  "length_lt",
+  "length_eq",
+  "includes",
+  "is_null",
+  "is_not_null"
+]);
+var AGG_OPS = /* @__PURE__ */ new Set(["count", "count_distinct", "sum", "avg", "min", "max"]);
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function boundedString(value, maxLength) {
+  return typeof value === "string" && value.length > 0 && value.length <= maxLength ? value : null;
+}
+function boundedInteger(value, fallback, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
+function normalizeWhereClause(item) {
+  if (!isRecord(item)) return null;
+  const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
+  const value = typeof item.value === "string" && item.value.length <= MAX_FILTER_VALUE_LENGTH ? item.value : null;
+  if (!field || typeof item.op !== "string" || !FILTER_OPS.has(item.op) || value == null) {
+    return null;
+  }
+  const clause = { field, op: item.op, value };
+  if (item.negated === true) clause.negated = true;
+  return clause;
+}
+function cloneWhereTerm(term) {
+  const copy = isWhereGroup(term) ? { ...term, any: term.any.map((c) => isWhereConjunction(c) ? { all: c.all.map((m) => ({ ...m })) } : { ...c }) } : { ...term };
+  if (term.setFilter) copy.setFilter = { ...term.setFilter, values: [...term.setFilter.values] };
+  return copy;
+}
+function normalizeSetFilter(item) {
+  if (!isRecord(item)) return void 0;
+  const id = boundedString(item.id, MAX_FIELD_NAME_LENGTH);
+  if (!id || typeof item.mode !== "string" || !["any", "all", "none", "empty"].includes(item.mode) || !Array.isArray(item.values)) return void 0;
+  if (item.values.length > MAX_WHERE_CLAUSES || !item.values.every((value) => typeof value === "string" && value.length <= MAX_FILTER_VALUE_LENGTH)) return void 0;
+  return { id, mode: item.mode, values: [...item.values] };
+}
+function suppliedPredicateCount(term) {
+  if (!isRecord(term) || !Array.isArray(term.any)) return 1;
+  let count = 0;
+  for (const member of term.any)
+    count += isRecord(member) && Array.isArray(member.all) ? Math.max(1, member.all.length) : 1;
+  return count;
+}
+function normalizeWhereTerms(input) {
+  const where = [];
+  let literalBudget = MAX_WHERE_CLAUSES;
+  for (const item of input) {
+    if (literalBudget <= 0) break;
+    const start = where.length;
+    if (isRecord(item) && Array.isArray(item.any)) {
+      const members = [];
+      for (const inner of item.any) {
+        if (literalBudget <= 0) break;
+        if (isRecord(inner) && Array.isArray(inner.all)) {
+          const all = [];
+          for (const literal of inner.all) {
+            if (literalBudget <= 0) break;
+            const clause2 = normalizeWhereClause(literal);
+            if (clause2) {
+              all.push(clause2);
+              literalBudget--;
+            }
+          }
+          if (all.length === 1) members.push(all[0]);
+          else if (all.length > 1) members.push({ all });
+          continue;
+        }
+        const clause = normalizeWhereClause(inner);
+        if (clause) {
+          members.push(clause);
+          literalBudget--;
+        }
+      }
+      if (members.length === 1) {
+        const only = members[0];
+        if (isWhereConjunction(only)) where.push(...only.all);
+        else where.push(only);
+      } else if (members.length > 1) where.push({ any: members });
+    } else {
+      const clause = normalizeWhereClause(item);
+      if (clause) {
+        where.push(clause);
+        literalBudget--;
+      }
+    }
+    if (where.length > start && isRecord(item)) {
+      const metadata = normalizeSetFilter(item.setFilter);
+      if (metadata) where[start].setFilter = metadata;
+    }
+  }
+  return where;
+}
+function normalizeMetricWhere(value) {
+  if (value === void 0) return { invalid: false };
+  if (!Array.isArray(value)) return { invalid: true };
+  const where = normalizeWhereTerms(value);
+  const supplied = value.reduce((count, term) => count + suppliedPredicateCount(term), 0);
+  const kept = where.reduce((count, term) => count + predicatesOf(term).length, 0);
+  return { ...where.length ? { where } : {}, invalid: supplied !== kept };
+}
+function normalizeQueryState(input, fallback = EMPTY_QUERY) {
+  return normalizeQuery(input, fallback, true);
+}
+function normalizeQuery(input, fallback, links) {
+  const raw = isRecord(input) ? input : {};
+  const select = [];
+  if (Array.isArray(raw.select)) {
+    for (const item of raw.select.slice(0, MAX_SELECT_COLUMNS)) {
+      if (!isRecord(item)) continue;
+      const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
+      if (!field) continue;
       const column = { field };
       if (typeof item.width === "number" && Number.isFinite(item.width)) {
         column.width = boundedInteger(item.width, MIN_COLUMN_WIDTH, MIN_COLUMN_WIDTH, MAX_COLUMN_WIDTH);
@@ -808,6 +1391,13 @@ function normalizeQuery(input, fallback, links) {
     offset: boundedInteger(raw.offset, fallback.offset, 0, MAX_QUERY_OFFSET)
   };
   if (raw.fitToScreen === true) out.fitToScreen = true;
+  if (links && raw.hostState !== void 0) {
+    try {
+      out.hostState = parseHostQueryState(raw.hostState);
+    } catch {
+      out.hostState = { version: 0, params: {} };
+    }
+  }
   if (raw.grouping != null) out.grouping = normalizeGroupingState(raw.grouping, links);
   if (Array.isArray(raw.aggregations)) {
     const aggregations = [];
@@ -865,6 +1455,7 @@ function normalizeQuery(input, fallback, links) {
       }
       if (Object.keys(views).length) details.views = views;
     }
+    if (raw.itemDetails.jsonInspections !== void 0) details.jsonInspections = parseJsonInspections(raw.itemDetails.jsonInspections);
     const active = raw.itemDetails.active;
     if (isRecord(active) && (active.mode === "modal" || active.mode === "expand") && modes.includes(active.mode) && (typeof active.id === "string" && active.id.length > 0 && active.id.length <= 1e3 || typeof active.id === "number" && Number.isFinite(active.id))) {
       details.active = { id: active.id, mode: active.mode };
@@ -879,8 +1470,20 @@ function normalizeGroupingState(value, links) {
   const fail = (message) => {
     diagnostics.push(`Invalid grouping: ${message}`);
   };
-  const keys = Array.isArray(raw.keys) ? raw.keys.slice(0, MAX_GROUP_BY_FIELDS).filter((key) => !!boundedString(key, MAX_FIELD_NAME_LENGTH)) : [];
-  if (!Array.isArray(raw.keys) || !keys.length || keys.length !== raw.keys.length || new Set(keys).size !== keys.length)
+  const keys = [];
+  for (const [index, key] of (Array.isArray(raw.keys) ? raw.keys.slice(0, MAX_GROUP_BY_FIELDS) : []).entries()) {
+    if (boundedString(key, MAX_FIELD_NAME_LENGTH)) {
+      keys.push(key);
+      continue;
+    }
+    if (!isRecord(key)) continue;
+    const field = boundedString(key.field, MAX_FIELD_NAME_LENGTH), zone = key.timeZone;
+    if (field && GROUP_KEY_INTERVALS.includes(key.interval) && (zone === void 0 || typeof zone === "string" && zone.length > 0 && zone.length <= 80 && !/^[+-]/.test(zone)))
+      keys.push({ field, interval: key.interval, ...zone !== void 0 ? { timeZone: zone } : {} });
+    else fail(`key ${index + 1} must be a field name or a calendar key {field, interval, timeZone} with interval hour, day, week, month or year; hour-of-day and day-of-week are metric intervals.`);
+  }
+  const keyNames = groupKeyFields(keys);
+  if (!Array.isArray(raw.keys) || !keys.length || keys.length !== raw.keys.length || new Set(keyNames).size !== keys.length)
     fail(`keys must list 1\u2013${MAX_GROUP_BY_FIELDS} distinct field names.`);
   const summaries = [];
   if (!Array.isArray(raw.summaries) || raw.summaries.length > 64) fail("summaries must be a list of at most 64 columns.");
@@ -897,7 +1500,7 @@ function normalizeGroupingState(value, links) {
     }
     const column = { id: item.id, op: item.op };
     if (summaryIds.has(column.id)) fail(`${name} uses the same id as another summary column.`);
-    else if (keys.includes(column.id)) fail(`${name} uses the same id as group key "${column.id}"; summary ids must differ from source field names.`);
+    else if (keyNames.includes(column.id)) fail(`${name} uses the same id as group key "${column.id}"; summary ids must differ from source field names.`);
     summaryIds.add(column.id);
     if (item.op === "link") {
       const link = normalizeLinkSpec(item.link);
@@ -946,13 +1549,13 @@ function normalizeGroupingState(value, links) {
   }
   if (!isRecord(raw.source)) fail("source must be the record query that is grouped.");
   else if (raw.source.grouping != null) fail("only one grouping stage is supported; the source query cannot itself be grouped.");
-  const { grouping: _nested, ...source } = isRecord(raw.source) ? raw.source : {};
+  const { grouping: _nested, hostState: _host, ...source } = isRecord(raw.source) ? raw.source : {};
   if (Array.isArray(raw.diagnostics))
     for (const message of raw.diagnostics.slice(0, 20))
       diagnostics.push(typeof message === "string" && message ? message.slice(0, MAX_LABEL_LENGTH) : "Invalid grouping definition.");
   const normalizedSource = normalizeQueryState(source);
   if (Array.isArray(source.where)) {
-    const supplied = source.where.reduce((count, term) => count + (isRecord(term) && Array.isArray(term.any) ? term.any.length : 1), 0);
+    const supplied = source.where.reduce((count, term) => count + suppliedPredicateCount(term), 0);
     if (supplied !== normalizedSource.where.reduce((count, term) => count + predicatesOf(term).length, 0)) fail("source filters contain malformed predicates or exceed the predicate budget.");
   }
   return { keys, summaries, representative, source: normalizedSource, ...diagnostics.length ? { diagnostics: [...new Set(diagnostics)] } : {} };
@@ -990,179 +1593,49 @@ function normalizeLinkSpec(value) {
     if (!isRecord(to.params)) return void 0;
     const entries = Object.entries(to.params);
     if (entries.length > MAX_LINK_PARAMS || entries.some(([key, item]) => !boundedString(key, MAX_FIELD_NAME_LENGTH) || typeof item !== "string" || item.length > MAX_FILTER_VALUE_LENGTH))
-      return void 0;
-    destination.params = Object.fromEntries(entries);
-  }
-  return { label, to: destination };
-}
-function keptEveryTerm(supplied, kept) {
-  if (!Array.isArray(supplied)) return false;
-  const count = supplied.reduce((total, term) => total + (isRecord(term) && Array.isArray(term.any) ? Math.max(1, term.any.length) : 1), 0);
-  return count === kept.reduce((total, term) => total + predicatesOf(term).length, 0);
-}
-function normalizeLinkPatch(value) {
-  if (!isRecord(value) || !boundedString(value.id, MAX_FIELD_NAME_LENGTH) || !Array.isArray(value.owns) || !isRecord(value.query)) return void 0;
-  if (value.owns.length > QUERY_FACETS.size || value.owns.some((facet) => typeof facet !== "string" || !QUERY_FACETS.has(facet))) return void 0;
-  const raw = value.query;
-  const normalized = normalizeQuery(raw, EMPTY_QUERY, false);
-  if (normalized.grouping?.diagnostics) return void 0;
-  if (raw.where !== void 0 && !keptEveryTerm(raw.where, normalized.where)) return void 0;
-  if (raw.aggregations !== void 0 && (!Array.isArray(raw.aggregations) || raw.aggregations.length !== (normalized.aggregations?.length ?? 0) || normalized.aggregations?.some((clause) => clause.diagnostics?.length))) return void 0;
-  const query = {};
-  for (const key of PATCH_QUERY_KEYS) {
-    if (raw[key] !== void 0 && normalized[key] !== void 0) query[key] = normalized[key];
-  }
-  return { id: value.id, owns: [...new Set(value.owns)], query };
-}
-function queriesEqual(a, b) {
-  if (a === b) return true;
-  if (a.limit !== b.limit || a.offset !== b.offset) return false;
-  if (a.fitToScreen === true !== (b.fitToScreen === true)) return false;
-  if (!sameArray(a.where, b.where)) return false;
-  if (!sameArray(a.orderBy, b.orderBy)) return false;
-  if (!sameArray(a.select, b.select)) return false;
-  if (!sameArray(a.aggregations ?? [], b.aggregations ?? [])) return false;
-  if (JSON.stringify(a.itemDetails) !== JSON.stringify(b.itemDetails)) return false;
-  if (JSON.stringify(a.grouping) !== JSON.stringify(b.grouping)) return false;
-  return true;
-}
-function sameArray(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (JSON.stringify(a[i]) !== JSON.stringify(b[i])) return false;
-  }
-  return true;
-}
-
-// src/relativeTime.ts
-var UNIT_MS = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5, w: 6048e5 };
-var MAX_RELATIVE_TIME_MS = 864e13;
-function parseRelativeDuration(value) {
-  const valid = /^[+-](?:[0-9]+(?:ms|s|m|h|d|w))+$/.exec(value);
-  if (!valid || valid[0] !== value) return null;
-  const body = value.slice(1);
-  const components = /([0-9]+)(ms|s|m|h|d|w)/g;
-  let total = 0;
-  for (const match of body.matchAll(components)) {
-    const amount = Number(match[1]);
-    const unit = UNIT_MS[match[2]];
-    if (!Number.isSafeInteger(amount) || amount > Math.floor((MAX_RELATIVE_TIME_MS - total) / unit)) return null;
-    total += amount * unit;
-  }
-  return value[0] === "-" && total !== 0 ? -total : total;
-}
-function evaluationTime(options2) {
-  const now = options2.now ?? Date.now();
-  if (!Number.isSafeInteger(now) || Math.abs(now) > MAX_RELATIVE_TIME_MS) throw new Error("Invalid query evaluation time");
-  return now;
-}
-function relativeTimestamp(now, offsetMs) {
-  const result = now + offsetMs;
-  if (!Number.isSafeInteger(result) || Math.abs(result) > MAX_RELATIVE_TIME_MS) throw new Error("Relative time exceeds datetime limits");
-  return result;
-}
-
-// src/ops.ts
-var NULLITY = ["is_null", "is_not_null"];
-var COMPLEMENT_OP = {
-  "=": "!=",
-  "!=": "=",
-  ">": "<=",
-  "<=": ">",
-  ">=": "<",
-  "<": ">=",
-  is_null: "is_not_null",
-  is_not_null: "is_null",
-  matches_regex: "not_matches_regex",
-  not_matches_regex: "matches_regex"
-};
-function negateClause(clause, allowedOps) {
-  if (clause.value === "0" && !clause.negated) {
-    const zeroComplement = clause.op === "length_gt" ? "length_eq" : clause.op === "length_eq" ? "length_gt" : null;
-    if (zeroComplement && (!allowedOps || allowedOps.includes(zeroComplement))) {
-      return { field: clause.field, op: zeroComplement, value: "0" };
-    }
-  }
-  const complement = COMPLEMENT_OP[clause.op];
-  if (complement && (!allowedOps || allowedOps.includes(complement))) {
-    const next2 = { field: clause.field, op: complement, value: clause.value };
-    return next2;
-  }
-  const next = { field: clause.field, op: clause.op, value: clause.value };
-  if (!clause.negated) next.negated = true;
-  return next;
-}
-function isNegativePredicate(clause) {
-  return Boolean(clause.negated) || clause.op === "!=" || clause.op === "not_matches_regex" || clause.op === "is_not_null";
-}
-var POSITIVE_OP_ORDER = ["=", ">", ">=", "contains", "starts_with", "ends_with", "length_gt", "length_lt", "length_eq", "matches_regex", "includes"];
-function opPairsForField(field) {
-  const ops = opsForField(field);
-  const allow = new Set(ops);
-  const pairs = [];
-  for (const op of POSITIVE_OP_ORDER) {
-    if (!allow.has(op)) continue;
-    const neg = negateClause({ field: "", op, value: "" }, ops);
-    pairs.push({ keep: { op, negated: false }, exclude: { op: neg.op, negated: Boolean(neg.negated) } });
-  }
-  if (allow.has("is_null") || allow.has("is_not_null")) {
-    pairs.push({ keep: { op: "is_null", negated: false }, exclude: { op: "is_not_null", negated: false } });
-  }
-  return pairs;
-}
-var OPS_BY_TYPE = {
-  text: [
-    "=",
-    "!=",
-    "contains",
-    "starts_with",
-    "ends_with",
-    "matches_regex",
-    "not_matches_regex",
-    "length_gt",
-    "length_lt",
-    "length_eq",
-    ...NULLITY
-  ],
-  enum: ["=", "!=", ...NULLITY],
-  number: ["=", "!=", ">", ">=", "<", "<=", ...NULLITY],
-  datetime: ["=", "!=", ">", ">=", "<", "<=", ...NULLITY],
-  bool: ["=", "!=", ...NULLITY],
-  textarray: ["includes", ...NULLITY]
-};
-var NULLARY_OPS = new Set(NULLITY);
-function opsForField(field) {
-  return field.filter?.ops ?? OPS_BY_TYPE[field.type];
+      return void 0;
+    destination.params = Object.fromEntries(entries);
+  }
+  return { label, to: destination };
 }
-function opAllowedForType(type, op) {
-  return OPS_BY_TYPE[type].includes(op);
+function keptEveryTerm(supplied, kept) {
+  if (!Array.isArray(supplied)) return false;
+  const count = supplied.reduce((total, term) => total + Math.max(1, suppliedPredicateCount(term)), 0);
+  return count === kept.reduce((total, term) => total + predicatesOf(term).length, 0);
 }
-function coerceValue(type, raw, now) {
-  switch (type) {
-    case "number": {
-      const n = Number(raw);
-      if (raw.trim() === "" || Number.isNaN(n)) throw new Error(`not a number: ${JSON.stringify(raw)}`);
-      return n;
-    }
-    case "bool": {
-      const v = raw.toLowerCase();
-      if (v === "true" || v === "1" || v === "t") return true;
-      if (v === "false" || v === "0" || v === "f") return false;
-      throw new Error(`not a bool: ${JSON.stringify(raw)}`);
-    }
-    case "datetime": {
-      if (raw.startsWith("+") || raw.startsWith("-")) {
-        const offset = parseRelativeDuration(raw);
-        if (offset === null) throw new Error(`not a signed duration: ${JSON.stringify(raw)}`);
-        return relativeTimestamp(now ?? Date.now(), offset);
-      }
-      const ms = Date.parse(raw);
-      if (Number.isNaN(ms)) throw new Error(`not a datetime: ${JSON.stringify(raw)}`);
-      return ms;
-    }
-    default:
-      return raw;
+function normalizeLinkPatch(value) {
+  if (!isRecord(value) || !boundedString(value.id, MAX_FIELD_NAME_LENGTH) || !Array.isArray(value.owns) || !isRecord(value.query)) return void 0;
+  if (value.owns.length > QUERY_FACETS.size || value.owns.some((facet) => typeof facet !== "string" || !QUERY_FACETS.has(facet))) return void 0;
+  const raw = value.query;
+  const normalized = normalizeQuery(raw, EMPTY_QUERY, false);
+  if (normalized.grouping?.diagnostics) return void 0;
+  if (raw.where !== void 0 && !keptEveryTerm(raw.where, normalized.where)) return void 0;
+  if (raw.aggregations !== void 0 && (!Array.isArray(raw.aggregations) || raw.aggregations.length !== (normalized.aggregations?.length ?? 0) || normalized.aggregations?.some((clause) => clause.diagnostics?.length))) return void 0;
+  const query = {};
+  for (const key of PATCH_QUERY_KEYS) {
+    if (raw[key] !== void 0 && normalized[key] !== void 0) query[key] = normalized[key];
+  }
+  return { id: value.id, owns: [...new Set(value.owns)], query };
+}
+function queriesEqual(a, b) {
+  if (a === b) return true;
+  if (a.limit !== b.limit || a.offset !== b.offset) return false;
+  if (a.fitToScreen === true !== (b.fitToScreen === true)) return false;
+  if (!sameArray(a.where, b.where)) return false;
+  if (!sameArray(a.orderBy, b.orderBy)) return false;
+  if (!sameArray(a.select, b.select)) return false;
+  if (!sameArray(a.aggregations ?? [], b.aggregations ?? [])) return false;
+  if (JSON.stringify(a.itemDetails) !== JSON.stringify(b.itemDetails)) return false;
+  if (JSON.stringify(a.grouping) !== JSON.stringify(b.grouping)) return false;
+  if (JSON.stringify(a.hostState) !== JSON.stringify(b.hostState)) return false;
+  return true;
+}
+function sameArray(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (JSON.stringify(a[i]) !== JSON.stringify(b[i])) return false;
   }
+  return true;
 }
 
 // src/agg.ts
@@ -1231,7 +1704,8 @@ function createSetFilter(field, mode, values, id, target = "array") {
 }
 function stripSetFilter(term) {
   const strip = ({ setFilter: _metadata, ...clause }) => clause;
-  return isOrGroup(term) ? { any: term.any.map(strip) } : strip(term);
+  if (!isWhereGroup(term)) return strip(term);
+  return { any: term.any.map((member) => isWhereConjunction(member) ? { all: member.all.map(strip) } : strip(member)) };
 }
 function readSetFilter(where, index) {
   const term = where[index];
@@ -1296,6 +1770,7 @@ function compactQuery(q) {
   if (q.itemDetails) c.d = q.itemDetails;
   if (q.fitToScreen) c.fs = true;
   if (q.grouping) c.b = q.grouping;
+  if (q.hostState) c.h = q.hostState;
   return c;
 }
 var MAX_QUERY_STATE_BYTES = 4 * 1024 * 1024;
@@ -1422,7 +1897,7 @@ function decodeToken(token, strict) {
     const c = versioned ? unpackQuery(raw) : raw;
     if (strict && c.w) {
       if (c.w.some((term) => !term || typeof term !== "object")) throw new QueryDecodeError("invalid", "Invalid query predicates.");
-      const count = c.w.reduce((n, term) => n + predicatesOf(term).length, 0);
+      const count = c.w.reduce((n, term) => n + suppliedPredicateCount(term), 0);
       const normalized = normalizeQueryState({ where: c.w });
       const normalizedCount = normalized.where.reduce((n, term) => n + predicatesOf(term).length, 0);
       if (count > 100 || count !== normalizedCount || c.w.some((term) => predicatesOf(term).some((clause) => !clause || typeof clause !== "object" || clause.negated !== void 0 && typeof clause.negated !== "boolean")))
@@ -1437,8 +1912,16 @@ function decodeToken(token, strict) {
       aggregations: c.g,
       itemDetails: c.d,
       fitToScreen: c.fs,
-      grouping: c.b
+      grouping: c.b,
+      hostState: c.h
     });
+    if (strict && c.h !== void 0) {
+      try {
+        parseHostQueryState(c.h);
+      } catch {
+        throw new QueryDecodeError("invalid", "Invalid host state in query link.");
+      }
+    }
     if (strict && c.g && out.aggregations?.length !== c.g.length) throw new QueryDecodeError("invalid", "Invalid query metrics.");
     return out;
   } catch (error) {
@@ -1505,7 +1988,7 @@ function termIsPushdown(term, byName, resolveField2) {
 }
 function toAggregationQuery(q, schema) {
   if (q.grouping) throw new Error("Metrics over grouped rows require grouped-query execution.");
-  const suppliedPredicateCount = q.where.reduce((n, t) => n + predicatesOf(t).length, 0);
+  const suppliedCount = q.where.reduce((n, t) => n + predicatesOf(t).length, 0);
   q = normalizeQueryState(q);
   if (q.aggregations?.some((a) => a.dateGrouping)) throw new Error("Date grouping currently requires local metric execution.");
   if (q.aggregations?.some((a) => a.diagnostics?.length || a.expression !== void 0 || a.expressionY !== void 0 || a.distribution || a.scope === "shownRows" || a.sort?.length || a.groupLimit || a.where?.length || a.minCount !== void 0)) throw new Error("Metric definition requires the version 2 metric transport.");
@@ -1523,7 +2006,7 @@ function toAggregationQuery(q, schema) {
   );
   const diagnostics = [];
   for (const c of q.aggregations ?? []) if (!aggregations.includes(c)) diagnostics.push({ metricId: c.id, code: "unsupported_metric", message: "Metric requires unavailable backend fields.", from: 0, to: 1 });
-  if (where.length !== q.where.length || suppliedPredicateCount !== q.where.reduce((n, t) => n + predicatesOf(t).length, 0)) diagnostics.push({ code: "residual_filter", message: "All-matching metrics are unavailable with residual client-only filters.", from: 0, to: 1 });
+  if (where.length !== q.where.length || suppliedCount !== q.where.reduce((n, t) => n + predicatesOf(t).length, 0)) diagnostics.push({ code: "residual_filter", message: "All-matching metrics are unavailable with residual client-only filters.", from: 0, to: 1 });
   return { where, aggregations, ...diagnostics.length ? { diagnostics } : {} };
 }
 
@@ -1548,11 +2031,11 @@ function localQuerySnapshotCache(options2 = {}) {
   if (!Number.isInteger(maxEntries) || maxEntries < 1 || !Number.isFinite(maxBytes) || maxBytes < 1) throw Error("Invalid query link cache limits.");
   const storage = () => options2.storage ?? globalThis.localStorage;
   function read() {
-    const text = storage().getItem(storageKey);
-    if (!text) return [];
+    const text2 = storage().getItem(storageKey);
+    if (!text2) return [];
     let raw;
     try {
-      raw = JSON.parse(text);
+      raw = JSON.parse(text2);
     } catch {
       return [];
     }
@@ -1570,12 +2053,12 @@ function localQuerySnapshotCache(options2 = {}) {
       const entry = entries.find((e) => e.key === key && e.snapshot.code === code);
       if (entry) {
         entry.durable = true;
-        let text = JSON.stringify(entries);
-        while (text.length * 2 > maxBytes && entries.length > 1) {
+        let text2 = JSON.stringify(entries);
+        while (text2.length * 2 > maxBytes && entries.length > 1) {
           entries.splice(entries[0] === entry ? 1 : 0, 1);
-          text = JSON.stringify(entries);
+          text2 = JSON.stringify(entries);
         }
-        if (text.length * 2 <= maxBytes) storage().setItem(storageKey, text);
+        if (text2.length * 2 <= maxBytes) storage().setItem(storageKey, text2);
       }
     },
     get(key, code) {
@@ -1589,26 +2072,26 @@ function localQuerySnapshotCache(options2 = {}) {
       const old = entries.find((e) => e.key === key && e.snapshot.code === snapshot.code);
       if (old) {
         if (old.snapshot.token !== snapshot.token) throw Error("A query link code cannot be overwritten.");
-        const text2 = JSON.stringify(entries);
-        if (storage().getItem(storageKey) !== text2) storage().setItem(storageKey, text2);
+        const text3 = JSON.stringify(entries);
+        if (storage().getItem(storageKey) !== text3) storage().setItem(storageKey, text3);
         return;
       }
       entries.push({ key, snapshot: validateQuerySnapshot(snapshot) });
       while (entries.length > maxEntries) entries.shift();
-      let text = JSON.stringify(entries);
-      while (text.length * 2 > maxBytes && entries.length > 1) {
+      let text2 = JSON.stringify(entries);
+      while (text2.length * 2 > maxBytes && entries.length > 1) {
         entries.shift();
-        text = JSON.stringify(entries);
+        text2 = JSON.stringify(entries);
       }
-      if (text.length * 2 > maxBytes) throw Error("This query is too large for the local link cache.");
-      storage().setItem(storageKey, text);
+      if (text2.length * 2 > maxBytes) throw Error("This query is too large for the local link cache.");
+      storage().setItem(storageKey, text2);
     }
   };
 }
 function memoryQuerySnapshotCache() {
-  let text = null;
-  return localQuerySnapshotCache({ storage: { getItem: () => text, setItem: (_key, value) => {
-    text = value;
+  let text2 = null;
+  return localQuerySnapshotCache({ storage: { getItem: () => text2, setItem: (_key, value) => {
+    text2 = value;
   } } });
 }
 var QuerySnapshotHttpError = class extends Error {
@@ -1647,10 +2130,10 @@ async function snapshotHttpError(response) {
           bytes.set(chunk, offset);
           offset += chunk.length;
         }
-        const text = new TextDecoder().decode(bytes);
-        let reason = text;
+        const text2 = new TextDecoder().decode(bytes);
+        let reason = text2;
         if (type === "application/json") {
-          const body = JSON.parse(text);
+          const body = JSON.parse(text2);
           reason = body?.message ?? body?.error?.message ?? body?.error;
           const code2 = body?.code ?? body?.error?.code;
           if (typeof code2 === "string" && /^[A-Za-z0-9_.-]{1,64}$/.test(code2)) serverCode = code2;
@@ -2348,23 +2831,23 @@ function compileFormula(source, fields, resolve, extension) {
     let match;
     if (source[pos] === "[") {
       pos++;
-      let text = "";
+      let text2 = "";
       let closed = false;
       while (pos < source.length) {
         if (source[pos] === "]") {
           if (source[pos + 1] === "]") {
-            text += "]";
+            text2 += "]";
             pos += 2;
           } else {
             pos++;
             closed = true;
             break;
           }
-        } else text += source[pos++];
+        } else text2 += source[pos++];
       }
       if (!closed)
         throw new FormulaError("Unclosed field reference.", from, pos);
-      tokens.push({ kind: "field", text, from, to: pos });
+      tokens.push({ kind: "field", text: text2, from, to: pos });
     } else if (source[pos] === '"') {
       pos++;
       while (pos < source.length && source[pos] !== '"') {
@@ -2384,9 +2867,9 @@ function compileFormula(source, fields, resolve, extension) {
       }
     } else if (source[pos] === "'") {
       const end = source.indexOf("'", pos + 1);
-      const text = end < 0 ? "" : source.slice(pos + 1, end);
+      const text2 = end < 0 ? "" : source.slice(pos + 1, end);
       throw new FormulaError(
-        end < 0 || text.length > 40 || /["\\\n]/.test(text) ? 'Text literals use double quotes ("text"), not single quotes.' : `Text literals use double quotes: write "${text}" instead of '${text}'.`,
+        end < 0 || text2.length > 40 || /["\\\n]/.test(text2) ? 'Text literals use double quotes ("text"), not single quotes.' : `Text literals use double quotes: write "${text2}" instead of '${text2}'.`,
         from,
         end < 0 ? pos + 1 : end + 1
       );
@@ -3036,259 +3519,89 @@ function formulaRuntime(ast, inputs, extension) {
         if (![
           "year",
           "month",
-          "week",
-          "day",
-          "hour",
-          "minute",
-          "second"
-        ].includes(unit))
-          fail("Unsupported date unit.");
-        d.setUTCMilliseconds(0);
-        if (unit !== "second") d.setUTCSeconds(0);
-        if (!["second", "minute"].includes(unit)) d.setUTCMinutes(0);
-        if (["year", "month", "week", "day"].includes(unit)) d.setUTCHours(0);
-        if (unit === "week")
-          d.setUTCDate(d.getUTCDate() - (d.getUTCDay() + 6) % 7);
-        if (unit === "year" || unit === "month") d.setUTCDate(1);
-        if (unit === "year") d.setUTCMonth(0);
-        out = d.toISOString();
-        break;
-      }
-      case "DATE_ADD": {
-        const d = date(c), unit = str(a).toLowerCase(), amount = integer(b, -1e5, 1e5);
-        if (unit === "year" || unit === "month") {
-          const day = d.getUTCDate();
-          d.setUTCDate(1);
-          d.setUTCMonth(d.getUTCMonth() + amount * (unit === "year" ? 12 : 1));
-          const last = new Date(d.getTime());
-          last.setUTCMonth(last.getUTCMonth() + 1, 0);
-          d.setUTCDate(Math.min(day, last.getUTCDate()));
-        } else {
-          const units = {
-            week: 6048e5,
-            day: 864e5,
-            hour: 36e5,
-            minute: 6e4,
-            second: 1e3,
-            millisecond: 1
-          };
-          const ms = units[unit];
-          if (!ms) fail("Unsupported date unit.");
-          d.setTime(d.getTime() + amount * ms);
-        }
-        out = d.toISOString();
-        break;
-      }
-      case "DATE_DIFF": {
-        const units = {
-          week: 6048e5,
-          day: 864e5,
-          hour: 36e5,
-          minute: 6e4,
-          second: 1e3,
-          millisecond: 1
-        };
-        const ms = units[str(a).toLowerCase()];
-        if (!ms) fail("Unsupported elapsed date unit.");
-        out = Math.trunc((date(c).getTime() - date(b).getTime()) / ms);
-        break;
-      }
-      case "FORMAT_DATE": {
-        const d = date(a), pad = (n2) => String(n2).padStart(2, "0"), parts2 = {
-          YYYY: String(d.getUTCFullYear()).padStart(4, "0"),
-          MM: pad(d.getUTCMonth() + 1),
-          DD: pad(d.getUTCDate()),
-          HH: pad(d.getUTCHours()),
-          mm: pad(d.getUTCMinutes()),
-          ss: pad(d.getUTCSeconds())
-        };
-        out = str(b).replace(/YYYY|MM|DD|HH|mm|ss/g, (t) => parts2[t]);
-        break;
-      }
-      default:
-        return fail(`Unknown operation: ${name}`);
-    }
-    return bound(out);
-  }
-  try {
-    const value = run(ast);
-    return inspection ? { value, regex: inspection } : { value };
-  } catch (e) {
-    return {
-      value: null,
-      error: e instanceof Error ? e.message : "Formula evaluation failed."
-    };
-  }
-}
-
-// src/metricDates.ts
-import { Temporal } from "temporal-polyfill";
-var METRIC_DATE_INTERVALS = [
-  "hour",
-  "day",
-  "week",
-  "month",
-  "year"
-];
-function metricDateTime(value, timeZone = "UTC") {
-  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2}))?$/.test(
-    value
-  ))
-    throw Error(
-      "Date grouping requires ISO dates or timestamps with a timezone."
-    );
-  const time = Date.parse(value), month = Number(value.slice(5, 7)), day = Number(value.slice(8, 10));
-  const calendar = /* @__PURE__ */ new Date(0);
-  calendar.setUTCFullYear(Number(value.slice(0, 4)), month, 0);
-  if (!Number.isFinite(time) || month < 1 || month > 12 || day < 1 || day > calendar.getUTCDate())
-    throw Error("Invalid date grouping value.");
-  return value.length === 10 && timeZone !== "UTC" ? Temporal.PlainDate.from(value).toZonedDateTime(timeZone).epochMilliseconds : time;
-}
-function metricOffsetTransition(start, end, timeZone) {
-  if (end <= start) return void 0;
-  const offset = (time) => Temporal.Instant.fromEpochMilliseconds(time).toZonedDateTimeISO(timeZone).offsetNanoseconds;
-  const before = offset(start);
-  if (before === offset(end)) return void 0;
-  while (end - start > 1) {
-    const middle = Math.floor((start + end) / 2);
-    if (offset(middle) === before) start = middle;
-    else end = middle;
-  }
-  return end;
-}
-function metricDateFloor(time, interval, timeZone = "UTC") {
-  if (timeZone !== "UTC") {
-    const zoned = Temporal.Instant.fromEpochMilliseconds(time).toZonedDateTimeISO(timeZone);
-    if (interval === "hour") {
-      const floor = time - zoned.minute * 6e4 - zoned.second * 1e3 - zoned.millisecond;
-      return metricOffsetTransition(floor, time, timeZone) ?? floor;
-    }
-    let date2 = zoned.toPlainDate();
-    if (interval === "week") date2 = date2.subtract({ days: date2.dayOfWeek - 1 });
-    if (interval === "month" || interval === "year")
-      date2 = date2.with({ day: 1 });
-    if (interval === "year") date2 = date2.with({ month: 1 });
-    return date2.toZonedDateTime(timeZone).epochMilliseconds;
-  }
-  const date = new Date(time);
-  date.setUTCMinutes(0, 0, 0);
-  if (interval !== "hour") date.setUTCHours(0);
-  if (interval === "week")
-    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 6) % 7);
-  if (interval === "month" || interval === "year") date.setUTCDate(1);
-  if (interval === "year") date.setUTCMonth(0);
-  return date.getTime();
-}
-function metricDateNext(time, interval, timeZone = "UTC") {
-  if (timeZone !== "UTC") {
-    const zoned = Temporal.Instant.fromEpochMilliseconds(time).toZonedDateTimeISO(timeZone);
-    if (interval === "hour") {
-      const target = zoned.toPlainDateTime().with({
-        minute: 0,
-        second: 0,
-        millisecond: 0,
-        microsecond: 0,
-        nanosecond: 0
-      }).add({ hours: 1 });
-      let next = target.toZonedDateTime(timeZone).epochMilliseconds;
-      if (next <= time)
-        next = target.toZonedDateTime(timeZone, {
-          disambiguation: "later"
-        }).epochMilliseconds;
-      return metricOffsetTransition(time, next, timeZone) ?? next;
-    }
-    let date2 = zoned.toPlainDate();
-    if (interval === "month") date2 = date2.with({ day: 1 }).add({ months: 1 });
-    else if (interval === "year")
-      date2 = date2.with({ month: 1, day: 1 }).add({ years: 1 });
-    else if (interval === "week")
-      date2 = date2.subtract({ days: date2.dayOfWeek - 1 }).add({ weeks: 1 });
-    else date2 = date2.add({ days: 1 });
-    return date2.toZonedDateTime(timeZone).epochMilliseconds;
-  }
-  const date = new Date(time);
-  if (interval === "hour") date.setUTCHours(date.getUTCHours() + 1);
-  else if (interval === "month") date.setUTCMonth(date.getUTCMonth() + 1);
-  else if (interval === "year") date.setUTCFullYear(date.getUTCFullYear() + 1);
-  else date.setUTCDate(date.getUTCDate() + (interval === "week" ? 7 : 1));
-  return date.getTime();
-}
-function metricCustomEndTime(value, timeZone = "UTC") {
-  const time = metricDateTime(value, timeZone);
-  return value.length === 10 ? metricDateNext(time, "day", timeZone) - 1 : time;
-}
-function validateDateGrouping(config) {
-  if (typeof config.field !== "string" || !config.field || config.field.length > 256 || !METRIC_DATE_INTERVALS.includes(config.interval) || typeof config.includeEmpty !== "boolean" || !["query", "observed", "custom"].includes(config.range) || config.partialIntervals !== void 0 && !["include", "exclude"].includes(config.partialIntervals))
-    throw Error("Invalid date grouping definition.");
-  if (config.timeZone !== void 0) {
-    if (typeof config.timeZone !== "string" || !config.timeZone || config.timeZone.length > 80 || /^[+-]/.test(config.timeZone))
-      throw Error(
-        "Use a valid IANA grouping timezone, such as America/Denver or UTC."
-      );
-    try {
-      new Intl.DateTimeFormat("en-US", { timeZone: config.timeZone });
-    } catch {
-      throw Error(
-        "Use a valid IANA grouping timezone, such as America/Denver or UTC."
-      );
+          "week",
+          "day",
+          "hour",
+          "minute",
+          "second"
+        ].includes(unit))
+          fail("Unsupported date unit.");
+        d.setUTCMilliseconds(0);
+        if (unit !== "second") d.setUTCSeconds(0);
+        if (!["second", "minute"].includes(unit)) d.setUTCMinutes(0);
+        if (["year", "month", "week", "day"].includes(unit)) d.setUTCHours(0);
+        if (unit === "week")
+          d.setUTCDate(d.getUTCDate() - (d.getUTCDay() + 6) % 7);
+        if (unit === "year" || unit === "month") d.setUTCDate(1);
+        if (unit === "year") d.setUTCMonth(0);
+        out = d.toISOString();
+        break;
+      }
+      case "DATE_ADD": {
+        const d = date(c), unit = str(a).toLowerCase(), amount = integer(b, -1e5, 1e5);
+        if (unit === "year" || unit === "month") {
+          const day = d.getUTCDate();
+          d.setUTCDate(1);
+          d.setUTCMonth(d.getUTCMonth() + amount * (unit === "year" ? 12 : 1));
+          const last = new Date(d.getTime());
+          last.setUTCMonth(last.getUTCMonth() + 1, 0);
+          d.setUTCDate(Math.min(day, last.getUTCDate()));
+        } else {
+          const units = {
+            week: 6048e5,
+            day: 864e5,
+            hour: 36e5,
+            minute: 6e4,
+            second: 1e3,
+            millisecond: 1
+          };
+          const ms = units[unit];
+          if (!ms) fail("Unsupported date unit.");
+          d.setTime(d.getTime() + amount * ms);
+        }
+        out = d.toISOString();
+        break;
+      }
+      case "DATE_DIFF": {
+        const units = {
+          week: 6048e5,
+          day: 864e5,
+          hour: 36e5,
+          minute: 6e4,
+          second: 1e3,
+          millisecond: 1
+        };
+        const ms = units[str(a).toLowerCase()];
+        if (!ms) fail("Unsupported elapsed date unit.");
+        out = Math.trunc((date(c).getTime() - date(b).getTime()) / ms);
+        break;
+      }
+      case "FORMAT_DATE": {
+        const d = date(a), pad = (n2) => String(n2).padStart(2, "0"), parts2 = {
+          YYYY: String(d.getUTCFullYear()).padStart(4, "0"),
+          MM: pad(d.getUTCMonth() + 1),
+          DD: pad(d.getUTCDate()),
+          HH: pad(d.getUTCHours()),
+          mm: pad(d.getUTCMinutes()),
+          ss: pad(d.getUTCSeconds())
+        };
+        out = str(b).replace(/YYYY|MM|DD|HH|mm|ss/g, (t) => parts2[t]);
+        break;
+      }
+      default:
+        return fail(`Unknown operation: ${name}`);
     }
+    return bound(out);
   }
-  if (config.includeEmpty && config.range === "custom") {
-    const start = metricDateTime(config.start ?? "", config.timeZone), end = metricCustomEndTime(config.end ?? "", config.timeZone);
-    if (end < start)
-      throw Error("The end date must be on or after the start date.");
-  }
-}
-function metricDateRange(config, query, observed, now, canonical) {
-  let min = Infinity, max = -Infinity;
-  for (const time of observed) {
-    min = Math.min(min, time);
-    max = Math.max(max, time);
-  }
-  if (config.range === "observed")
-    return observed.length ? [min, max] : void 0;
-  if (config.range === "custom") {
-    const start2 = metricDateFloor(
-      metricDateTime(config.start ?? "", config.timeZone),
-      config.interval,
-      config.timeZone
-    );
-    const end2 = metricDateFloor(
-      metricCustomEndTime(config.end ?? "", config.timeZone),
-      config.interval,
-      config.timeZone
-    );
-    if (observed.length && (start2 > min || end2 < max))
-      throw Error(
-        "Custom date bounds must include all observed buckets. Narrow the query filters to exclude data."
-      );
-    return [start2, end2];
-  }
-  let start = -Infinity, end = Infinity;
-  for (const term of query.where) {
-    if (isOrGroup(term) || term.negated || canonical(term.field) !== canonical(config.field))
-      continue;
-    if (!["=", ">", ">=", "<", "<="].includes(term.op)) continue;
-    const time = Number(coerceValue("datetime", term.value, now));
-    if (term.op === ">" || term.op === ">=" || term.op === "=")
-      start = Math.max(start, time + (term.op === ">" ? 1 : 0));
-    if (term.op === "<" || term.op === "<=" || term.op === "=")
-      end = Math.min(end, time - (term.op === "<" ? 1 : 0));
-  }
-  if (!Number.isFinite(start) || !Number.isFinite(end)) {
-    const missing = [
-      ...Number.isFinite(start) ? [] : ["a lower bound (>= or >)"],
-      ...Number.isFinite(end) ? [] : ["an upper bound (<= or <)"]
-    ].join(" and ");
-    throw Error(
-      `Include empty dates with range "query" needs a bounded date filter on ${config.field}: add ${missing} as top-level filters (bounds inside OR groups do not count). Otherwise use range "observed" to fill from the first to the last observed date, or range "custom" with start and end.`
-    );
+  try {
+    const value = run(ast);
+    return inspection ? { value, regex: inspection } : { value };
+  } catch (e) {
+    return {
+      value: null,
+      error: e instanceof Error ? e.message : "Formula evaluation failed."
+    };
   }
-  if (end < start) return void 0;
-  return [
-    metricDateFloor(start, config.interval, config.timeZone),
-    metricDateFloor(end, config.interval, config.timeZone)
-  ];
 }
 
 // src/metricPrecision.ts
@@ -3307,11 +3620,110 @@ function checkedMetricResult(result) {
   }
 }
 
+// src/metricDistributions.ts
+function percentile(sorted, p) {
+  if (!Number.isFinite(p) || p < 0 || p > 1)
+    throw Error("Percentile must be between zero and one.");
+  if (sorted.some((v, i) => !Number.isFinite(v) || i > 0 && v < sorted[i - 1]))
+    throw Error("Percentile inputs must be sorted finite numbers.");
+  sorted.forEach(assertMetricNumber);
+  if (!sorted.length) return null;
+  const position = (sorted.length - 1) * p, lower = Math.floor(position), fraction = position - lower;
+  const a = sorted[lower], b = sorted[Math.min(lower + 1, sorted.length - 1)];
+  const raw = (1 - fraction) * a + fraction * b;
+  assertMetricNumber(raw);
+  const value = Math.min(b, Math.max(a, raw));
+  return value;
+}
+function boxSummary(values, whiskers = "minmax") {
+  if (values.some((v) => !Number.isFinite(v)))
+    throw Error("Distribution inputs must be finite numbers.");
+  values.forEach(assertMetricNumber);
+  const sorted = [...values].sort((a, b) => a - b), n = sorted.length;
+  if (!n) return null;
+  const min = sorted[0], max = sorted[n - 1], q1 = percentile(sorted, 0.25), median = percentile(sorted, 0.5), q3 = percentile(sorted, 0.75);
+  const lowFence = q1 - 1.5 * (q3 - q1), highFence = q3 + 1.5 * (q3 - q1);
+  const low = whiskers === "tukey" ? sorted.find((v) => v >= lowFence) : min;
+  const high = whiskers === "tukey" ? [...sorted].reverse().find((v) => v <= highFence) : max;
+  const outside = whiskers === "tukey" ? sorted.filter((v) => v < low || v > high) : [];
+  const outliers = outside.length <= 20 ? outside : [...outside.slice(0, 10), ...outside.slice(-10)];
+  const rawMean = sorted.reduce((sum, value) => sum + value / n, 0);
+  assertMetricNumber(rawMean);
+  const mean = Math.min(max, Math.max(min, rawMean));
+  [min, q1, median, q3, max, mean, low, high].forEach(assertMetricNumber);
+  return {
+    n,
+    min,
+    q1,
+    median,
+    q3,
+    max,
+    mean,
+    low,
+    high,
+    outliers,
+    outlierCount: outside.length,
+    whiskers,
+    method: "exact-linear"
+  };
+}
+function histogramEdges(values, bins) {
+  if (!Number.isInteger(bins) || bins < 2 || bins > 30)
+    throw Error("Choose 2\u201330 histogram bins.");
+  if (values.some((v) => !Number.isFinite(v)))
+    throw Error("Histogram inputs must be finite numbers.");
+  values.forEach(assertMetricNumber);
+  if (!values.length) return [];
+  let min = Infinity, max = -Infinity;
+  for (const value of values) {
+    min = Math.min(min, value);
+    max = Math.max(max, value);
+  }
+  if (min === max) return [min, max];
+  if (!Number.isFinite(max - min))
+    throw Error("Histogram range exceeds finite numeric precision.");
+  const edges = Array.from(
+    { length: bins + 1 },
+    (_, i) => min + (max - min) * (i / bins)
+  );
+  edges[0] = min;
+  edges[bins] = max;
+  edges.forEach(assertMetricNumber);
+  if (edges.some((value, i) => i > 0 && value <= edges[i - 1]))
+    throw Error(
+      "Histogram bins are finer than numeric precision. Reduce the bin count."
+    );
+  return edges;
+}
+function histogramCounts(values, edges) {
+  if (values.some((v) => !Number.isFinite(v)))
+    throw Error("Histogram inputs must be finite numbers.");
+  if (!edges.length) {
+    if (values.length) throw Error("Histogram values require edges.");
+    return [];
+  }
+  if (edges.length < 2 || edges.some(
+    (v, i) => !Number.isFinite(v) || i > 0 && (v < edges[i - 1] || v === edges[i - 1] && edges.length !== 2)
+  ))
+    throw Error("Histogram edges must be ordered finite boundaries.");
+  values.forEach(assertMetricNumber);
+  edges.forEach(assertMetricNumber);
+  const counts = Array(edges.length - 1).fill(0);
+  for (const value of values) {
+    if (value < edges[0] || value > edges[edges.length - 1])
+      throw Error("Value falls outside shared histogram edges.");
+    let bin = 0;
+    while (bin < counts.length - 1 && value >= edges[bin + 1]) bin++;
+    counts[bin] = counts[bin] + 1;
+  }
+  return counts;
+}
+
 // src/metricSeries.ts
 var MAX_METRIC_WINDOW_PERIODS = 1e3;
 var MERGEABLE = ["SUM", "COUNT", "MIN", "MAX", "AVG"];
 function hasMetricSeries(c) {
-  return c.window !== void 0 || c.share !== void 0 || c.dateGrouping?.partialIntervals !== void 0;
+  return c.window !== void 0 || c.share !== void 0 || c.dateGrouping?.partialIntervals !== void 0 || c.dateGrouping?.occurrence !== void 0;
 }
 var soleAggregate = (plan) => plan.ast.kind === "call" && plan.aggregates.includes(plan.ast) ? plan.ast.name : void 0;
 var partBudget = (c, plan) => (c.window && (c.window.reduce ?? "total") === "total" ? plan.aggregates.reduce((n, node) => n + (node.name === "AVG" ? 2 : 1), 0) : 1) * (c.share ? 2 : 1);
@@ -3324,7 +3736,7 @@ function validateMetricSeries(c, plan) {
     );
   const metric = plan, sole = soleAggregate(metric);
   if (window) {
-    if (!c.dateGrouping)
+    if (!c.dateGrouping || isMetricCycle(c.dateGrouping.interval))
       throw new FormulaError(
         "A window needs a calendar interval on the first grouping field."
       );
@@ -3374,12 +3786,12 @@ function validateMetricSeries(c, plan) {
       `A window or share runs one metric per aggregate; this one needs more than ${MAX_AGGREGATIONS}.`
     );
 }
-function wholeIntervalSpan(c, query, schema, now) {
-  const { field, interval, timeZone } = c.dateGrouping;
+function metricDateBounds(c, query, schema, now) {
+  const { field } = c.dateGrouping;
   const canonical = (name) => resolveFieldName(schema, name) ?? name;
   let lower = -Infinity, upper = Infinity;
   for (const term of [...query.where, ...c.where ?? []]) {
-    if (isOrGroup(term) || term.negated || canonical(term.field) !== canonical(field) || !["=", ">", ">=", "<", "<="].includes(term.op))
+    if (isWhereGroup(term) || term.negated || canonical(term.field) !== canonical(field) || !["=", ">", ">=", "<", "<="].includes(term.op))
       continue;
     if (term.value === "") continue;
     let time;
@@ -3394,6 +3806,11 @@ function wholeIntervalSpan(c, query, schema, now) {
     if (term.op === "<" || term.op === "<=" || term.op === "=")
       upper = Math.min(upper, time + (term.op === "<" ? 0 : 1));
   }
+  return { lower, upper };
+}
+function wholeIntervalSpan(c, query, schema, now) {
+  const { interval, timeZone } = c.dateGrouping;
+  const { lower, upper } = metricDateBounds(c, query, schema, now);
   const floor = (time) => metricDateFloor(time, interval, timeZone);
   const end = floor(Math.min(upper, now));
   if (!Number.isFinite(lower)) return { end };
@@ -3431,45 +3848,88 @@ function planMetricSeries(query, schema, options2 = {}) {
   function prepare(c) {
     const issue = validateMetric(c, schema, options2.resolveComputed)[0];
     if (issue) return { kind: "error", clause: c, error: issue.message };
+    function whole(config) {
+      let where2 = c.where ?? [], dateGrouping2 = config;
+      const span = wholeIntervalSpan(
+        { ...c, dateGrouping: config },
+        query,
+        schema,
+        now
+      );
+      if (span.start !== void 0 && span.end <= span.start) {
+        if (!isMetricCycle(config.interval)) return void 0;
+        span.end = span.start;
+      }
+      const field = resolveFieldName(schema, config.field) ?? config.field;
+      const iso = (time) => new Date(time).toISOString();
+      where2 = [
+        ...where2,
+        ...span.start !== void 0 ? [{ field, op: ">=", value: iso(span.start) }] : [],
+        { field, op: "<", value: iso(span.end) }
+      ];
+      if (config.includeEmpty && config.range !== "observed" && !isMetricCycle(config.interval)) {
+        const floor = (time) => metricDateFloor(time, config.interval, config.timeZone);
+        let from = span.start, through = span.end - 1;
+        if (config.range === "custom") {
+          const start = floor(
+            metricDateTime(config.start ?? "", config.timeZone)
+          );
+          from = Math.max(from ?? start, start);
+          through = Math.min(
+            through,
+            metricCustomEndTime(config.end ?? "", config.timeZone)
+          );
+        }
+        if (from !== void 0) {
+          if (through < from) return void 0;
+          dateGrouping2 = {
+            ...config,
+            range: "custom",
+            start: iso(from),
+            end: iso(through)
+          };
+        }
+      }
+      return { where: where2, dateGrouping: dateGrouping2 };
+    }
     let where = c.where ?? [];
     let dateGrouping;
     if (c.dateGrouping) {
-      const { partialIntervals, ...config } = c.dateGrouping;
-      dateGrouping = config;
-      if (partialIntervals === "exclude") {
-        const span = wholeIntervalSpan(c, query, schema, now);
-        if (span.start !== void 0 && span.end <= span.start)
-          return { kind: "empty", clause: c };
-        const field = resolveFieldName(schema, config.field) ?? config.field;
-        const iso = (time) => new Date(time).toISOString();
-        where = [
-          ...where,
-          ...span.start !== void 0 ? [{ field, op: ">=", value: iso(span.start) }] : [],
-          { field, op: "<", value: iso(span.end) }
-        ];
-        if (config.includeEmpty && config.range !== "observed") {
-          const floor = (time) => metricDateFloor(time, config.interval, config.timeZone);
-          let from = span.start, through = span.end - 1;
-          if (config.range === "custom") {
-            const start = floor(
-              metricDateTime(config.start ?? "", config.timeZone)
-            );
-            from = Math.max(from ?? start, start);
-            through = Math.min(
-              through,
-              metricCustomEndTime(config.end ?? "", config.timeZone)
-            );
-          }
-          if (from !== void 0) {
-            if (through < from) return { kind: "empty", clause: c };
-            dateGrouping = {
-              ...config,
-              range: "custom",
-              start: iso(from),
-              end: iso(through)
-            };
-          }
-        }
+      const { partialIntervals, occurrence, ...config } = c.dateGrouping;
+      const narrowed = occurrence ? whole({
+        ...config,
+        interval: occurrence.interval,
+        includeEmpty: occurrence.includeEmpty
+      }) : partialIntervals === "exclude" ? whole(config) : { where, dateGrouping: config };
+      if (!narrowed) return { kind: "empty", clause: c };
+      ({ where, dateGrouping } = narrowed);
+      if (occurrence) {
+        const {
+          dateGrouping: _date,
+          where: _where,
+          scope: _scope,
+          distribution: _distribution,
+          display: _display,
+          sort: _sort,
+          groupLimit: _limit,
+          minCount: _min,
+          label: _label,
+          layout: _layout,
+          ...rest
+        } = c;
+        return {
+          kind: "occurrence",
+          clause: c,
+          parts: [
+            {
+              ...rest,
+              id: id(),
+              ...c.scope ? { scope: c.scope } : {},
+              ...where.length ? { where } : {},
+              dateGrouping
+            }
+          ]
+        };
       }
     }
     const scoped = (groupBy) => ({
@@ -3495,38 +3955,55 @@ function planMetricSeries(query, schema, options2 = {}) {
     );
     const plan = compileMetric(source, schema, options2.resolveComputed);
     const texts = [];
-    const at = (text) => {
-      const index = texts.indexOf(text);
-      return index < 0 ? texts.push(text) - 1 : index;
+    const at = (text2) => {
+      const index = texts.indexOf(text2);
+      return index < 0 ? texts.push(text2) - 1 : index;
     };
     let reductions;
     if (c.window && (c.window.reduce ?? "total") === "total")
       reductions = plan.aggregates.map((node) => {
-        const text = source.slice(node.from, node.to);
-        if (node.name !== "AVG") return { name: node.name, part: at(text) };
-        const input = text.slice(text.indexOf("(") + 1, text.lastIndexOf(")"));
+        const text2 = source.slice(node.from, node.to);
+        if (node.name !== "AVG") return { name: node.name, part: at(text2) };
+        const input = text2.slice(text2.indexOf("(") + 1, text2.lastIndexOf(")"));
         return { name: "AVG", sum: at(`SUM(${input})`), count: at(`COUNT(${input})`) };
       });
     else at(source);
     const parts = (groupBy) => texts.map(
-      (text) => ({
+      (text2) => ({
         id: id(),
         // The whole legacy measure keeps its operation, so v1 servers run it.
-        ...text === source && c.expression === void 0 ? { op: c.op, ...c.field ? { field: c.field } : {} } : { op: "count", expression: text },
+        ...text2 === source && c.expression === void 0 ? { op: c.op, ...c.field ? { field: c.field } : {} } : { op: "count", expression: text2 },
         groupBy,
         ...scoped(groupBy)
       })
     );
+    const all = [
+      ...parts(c.groupBy),
+      ...c.share === "group0" ? parts(c.groupBy.slice(0, 1)) : c.share === "total" ? parts([]) : []
+    ];
+    const measure = metricMinCountMeasure(c);
+    const minPart = measure ? all.length : void 0;
+    if (measure)
+      all.push({
+        id: id(),
+        op: "count",
+        expression: metricExpression({
+          id: "",
+          groupBy: [],
+          op: measure.op,
+          field: resolveFieldName(schema, measure.field) ?? measure.field
+        }),
+        groupBy: c.groupBy,
+        ...scoped(c.groupBy)
+      });
     return {
       kind: "series",
       clause: c,
       plan,
-      parts: [
-        ...parts(c.groupBy),
-        ...c.share === "group0" ? parts(c.groupBy.slice(0, 1)) : c.share === "total" ? parts([]) : []
-      ],
+      parts: all,
       ...reductions ? { reductions } : {},
-      size: texts.length
+      size: texts.length,
+      ...minPart !== void 0 ? { minPart } : {}
     };
   }
   const queries = [];
@@ -3548,14 +4025,16 @@ function planMetricSeries(query, schema, options2 = {}) {
         const c = item.clause;
         if (item.kind === "error")
           return { id: c.id, buckets: [], error: item.error };
-        if (item.kind === "empty")
-          return {
+        if (item.kind === "empty") {
+          const none = {
             id: c.id,
             buckets: [],
             scope: c.scope ?? "allMatching",
             groupCount: 0,
             coverage: "exact"
           };
+          return c.dateGrouping?.occurrence ? combineOccurrences(c, none) : none;
+        }
         const entries = item.parts.map(
           (part) => byId.get(part.id) ?? {
             id: part.id,
@@ -3565,6 +4044,8 @@ function planMetricSeries(query, schema, options2 = {}) {
         );
         if (item.kind === "plain") return { ...entries[0], id: c.id };
         try {
+          if (item.kind === "occurrence")
+            return combineOccurrences(c, entries[0]);
           return combineSeries(item, entries);
         } catch (e) {
           return {
@@ -3617,7 +4098,7 @@ function combineSeries(item, entries) {
         "A window or share needs every group, but the engine returned only some of them."
       );
   }
-  const numerator = entries.slice(0, item.size), denominator = c.share ? entries.slice(item.size) : [];
+  const numerator = entries.slice(0, item.size), denominator = c.share ? entries.slice(item.size, item.minPart) : [], threshold = item.minPart !== void 0 ? entries[item.minPart] : void 0;
   const dateOf = (keys) => keys[0] === null || keys[0] === void 0 ? void 0 : keys[0];
   const times = /* @__PURE__ */ new Map();
   if (window)
@@ -3727,10 +4208,32 @@ function combineSeries(item, entries) {
       ...own.intervals !== void 0 ? { intervals: own.intervals } : {}
     };
   });
+  const thresholdTracks = threshold ? tracks(threshold) : void 0, thresholdBuckets = threshold ? exact(threshold) : void 0;
+  const measureOf = (keys) => {
+    const at = positionOf(keys);
+    let members;
+    if (!window || at === void 0)
+      members = [thresholdBuckets.get(JSON.stringify(keys))];
+    else {
+      const from = Math.max(0, at - periods + 1), track = thresholdTracks.get(JSON.stringify(keys.slice(1)));
+      members = Array.from(
+        { length: at - from + 1 },
+        (_, i) => track?.[from + i]
+      );
+    }
+    const sum = new Accumulator("SUM");
+    for (const bucket of members) sum.add(bucket);
+    return sum.result();
+  };
   let hiddenGroups;
-  if (c.minCount !== void 0) {
+  const min = metricMinCount(c);
+  if (min !== void 0) {
     const kept = buckets.filter(
-      (b) => b.count === 0 || b.count >= c.minCount
+      (b) => metricMinCountKeeps(
+        min,
+        b.count,
+        threshold ? measureOf(b.keys) : void 0
+      )
     );
     hiddenGroups = buckets.length - kept.length;
     buckets = kept;
@@ -3749,31 +4252,87 @@ function combineSeries(item, entries) {
     ...hiddenGroups !== void 0 ? { hiddenGroups } : {}
   };
 }
-
-// src/groupKeys.ts
-function datetimeValue(value) {
-  const time = value instanceof Date ? value.getTime() : typeof value === "number" ? value : typeof value === "string" && value !== "" ? Date.parse(value) : NaN;
-  return Number.isFinite(time) ? new Date(time).toISOString() : null;
-}
-function keyClause(field, value) {
-  if (!field || field.type === "textarray" || !isFilterable(field)) return null;
-  if (value == null) return { field: field.name, op: "is_null", value: "" };
-  if (field.type === "datetime") {
-    const iso = datetimeValue(value);
-    return iso === null ? null : { field: field.name, op: "=", value: iso };
-  }
-  if (typeof value === "number" ? !Number.isFinite(value) : typeof value !== "string" && typeof value !== "boolean")
-    return null;
-  return { field: field.name, op: "=", value: String(value) };
-}
-function groupKeyTerms(keys, group, schema) {
-  const terms = [];
-  for (const key of keys) {
-    const term = keyClause(resolveField(schema, key), group[key]);
-    if (!term) return null;
-    terms.push(term);
+function combineOccurrences(c, entry) {
+  const config = c.dateGrouping, cycle = config.interval;
+  if (!isMetricCycle(cycle)) throw Error("Invalid date grouping occurrence.");
+  if (entry.error) throw Error(entry.error);
+  if (entry.coverage === "partial" || (entry.groupCount ?? entry.buckets.length) > entry.buckets.length)
+    throw Error(
+      "Occurrences need every interval, but the engine returned only some of them."
+    );
+  const slots = /* @__PURE__ */ new Map();
+  const slotOf = (keys) => {
+    const key = JSON.stringify(keys);
+    let slot = slots.get(key);
+    if (!slot) slots.set(key, slot = { keys, count: 0, values: [] });
+    return slot;
+  };
+  for (const bucket of entry.buckets) {
+    if (bucket.keys[0] === null || bucket.keys[0] === void 0) continue;
+    const slot = slotOf([
+      metricCycleSlot(metricDateTime(bucket.keys[0]), cycle, config.timeZone),
+      ...bucket.keys.slice(1)
+    ]);
+    slot.count += bucket.count;
+    if (slot.error) continue;
+    if (bucket.error) slot.error = bucket.error;
+    else if (typeof bucket.value === "number") slot.values.push(bucket.value);
+    else if (bucket.value !== null)
+      slot.error = "Occurrence values must be numeric.";
+  }
+  if (config.includeEmpty) {
+    const tails = /* @__PURE__ */ new Map();
+    for (const slot of slots.values())
+      tails.set(JSON.stringify(slot.keys.slice(1)), slot.keys.slice(1));
+    if (c.groupBy.length === 1 && !tails.size) tails.set("[]", []);
+    for (const number of metricCycleSlots(cycle))
+      for (const tail of tails.values()) slotOf([number, ...tail]);
+  }
+  const box = occurrenceDistribution(c);
+  let buckets = [...slots.values()].map((slot) => {
+    const bucket = {
+      keys: slot.keys,
+      count: slot.count,
+      value: null,
+      occurrences: slot.values.length
+    };
+    if (slot.error) return { ...bucket, error: slot.error };
+    try {
+      if (box) {
+        const summary = boxSummary(slot.values, c.distribution.whiskers);
+        bucket.distribution = { kind: "box", summary };
+        bucket.value = summary?.median ?? null;
+      } else if (slot.values.length) {
+        const mean = slot.values.reduce((sum, value) => sum + value, 0) / slot.values.length;
+        assertMetricNumber(mean);
+        bucket.value = mean;
+      }
+    } catch (e) {
+      return { ...bucket, value: null, error: e.message };
+    }
+    return bucket;
+  });
+  let hiddenGroups;
+  const min = metricMinCount(c);
+  if (min !== void 0) {
+    const kept = buckets.filter(
+      (b) => b.count === 0 || b.count >= min
+    );
+    hiddenGroups = buckets.length - kept.length;
+    buckets = kept;
   }
-  return terms;
+  sortMetricBuckets(buckets, c);
+  const groupCount = buckets.length;
+  if (c.groupLimit) buckets = buckets.slice(0, c.groupLimit);
+  return {
+    id: c.id,
+    buckets,
+    scope: entry.scope ?? c.scope ?? "allMatching",
+    ...entry.processedRows !== void 0 ? { processedRows: entry.processedRows } : {},
+    groupCount,
+    coverage: "exact",
+    ...hiddenGroups !== void 0 ? { hiddenGroups } : {}
+  };
 }
 
 // src/grouping.ts
@@ -3793,29 +4352,37 @@ function withoutGrouping(query) {
   return result;
 }
 function exitGrouping(query) {
-  return query.grouping ? query.grouping.source : query;
+  if (!query.grouping) return query;
+  if (!query.hostState && !query.grouping.source.hostState) return query.grouping.source;
+  const { hostState: _source, ...source } = query.grouping.source;
+  return query.hostState ? { ...source, hostState: query.hostState } : source;
 }
 function withGroupingKeys(query, keys) {
   const before = query.grouping;
   if (!keys.length) return exitGrouping(query);
-  if (!before)
+  const names = groupKeyFields(keys);
+  if (!before) {
+    const { hostState, ...source } = query;
     return {
-      select: keys.map((field) => ({ field })),
+      select: names.map((field) => ({ field })),
       where: [],
       orderBy: [],
       limit: query.limit,
       offset: 0,
-      grouping: { keys, summaries: [], representative: null, source: query }
+      grouping: { keys, summaries: [], representative: null, source },
+      ...hostState ? { hostState } : {}
     };
-  const removed = new Set(before.keys.filter((key) => !keys.includes(key)));
-  const columns = query.select.length ? query.select : before.keys.map((field) => ({ field }));
+  }
+  const previous = groupKeyFields(before.keys);
+  const removed = new Set(previous.filter((key) => !names.includes(key)));
+  const columns = query.select.length ? query.select : previous.map((field) => ({ field }));
   return {
     ...query,
     grouping: { ...before, keys },
     offset: 0,
     aggregations: [],
     select: [
-      ...keys.filter((key) => !before.keys.includes(key)).map((field) => ({ field })),
+      ...names.filter((key) => !previous.includes(key)).map((field) => ({ field })),
       ...columns.filter((c) => !removed.has(c.field))
     ],
     where: query.where.filter(
@@ -3905,14 +4472,15 @@ function createGroupingModel(inputSchema) {
     if (link.to.kind === "template")
       for (const name of templateFields(link.to.template)) names.add(name);
     else if (link.to.keyFilters !== false)
-      for (const key of keys) names.add(key);
+      for (const key of keys) names.add(groupKeyField(key));
     return [...names];
   }
   function linkProblem(column, keys, summaries) {
     const link = column.link;
     if (column.op !== "link") return null;
     if (!link) return "Invalid link definition.";
-    const readable = (name) => keys.includes(name) || summaries.some((other) => other.id === name && other.op !== "link");
+    const names = groupKeyFields(keys);
+    const readable = (name) => names.includes(name) || summaries.some((other) => other.id === name && other.op !== "link");
     if (typeof link.label === "object" && !readable(link.label.column))
       return `Unknown link label column: ${link.label.column}.`;
     if (link.to.kind === "template") {
@@ -3920,7 +4488,7 @@ function createGroupingModel(inputSchema) {
       return urlTemplateProblem(link.to.template, [], readable);
     }
     if (link.to.keyFilters !== false)
-      for (const key of keys) {
+      for (const key of names) {
         const field = sourceField(key);
         if (field?.type === "textarray")
           return `Key filters cannot match the textarray key ${field.label}.`;
@@ -3969,11 +4537,12 @@ function createGroupingModel(inputSchema) {
         aggregate: { measure: false, groupable: false }
       },
       ...keys.flatMap((key) => {
-        const field = sourceField(key);
+        const field = sourceField(groupKeyField(key));
         if (!field) return [];
         return [{
-          name: key,
-          label: field.label,
+          // A calendar key's column holds each interval's start instant.
+          name: field.name,
+          label: isCalendarGroupKey(key) ? `${field.label} (${key.interval})` : field.label,
           type: field.type,
           source: { kind: "backend" },
           ...field.select ? { select: { ...field.select } } : {},
@@ -4054,7 +4623,7 @@ function createGroupingModel(inputSchema) {
       name: `${inputSchema.name}:groups`,
       idField: GROUP_ID_FIELD,
       fields,
-      defaultSelect: keys.filter((key) => sourceField(key)).map((field) => ({ field })),
+      defaultSelect: groupKeyFields(keys).filter((key) => sourceField(key)).map((field) => ({ field })),
       defaultLimit: 25
     };
     return schema;
@@ -4066,13 +4635,8 @@ function createGroupingModel(inputSchema) {
       return value;
     throw new Error("Group keys must be finite scalar values.");
   }
-  function groupId(row, keys, schema) {
-    const tuple = [...keys].sort().map((key) => [
-      key,
-      keyValue(
-        readFieldValue(schema.fields.find((f2) => f2.name === key), row)
-      )
-    ]);
+  function groupId(values) {
+    const tuple = [...values].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => [key, keyValue(value)]);
     if (tuple.some(
       ([key, value]) => String(key).length + String(value).length > 1e4
     ))
@@ -4111,8 +4675,8 @@ function createGroupingModel(inputSchema) {
     }));
     return rows.reduce((best, row) => {
       for (const term of terms) {
-        const value = (record2) => {
-          const raw = term.def ? readFieldValue(term.def, record2) : record2[schema.idField];
+        const value = (record3) => {
+          const raw = term.def ? readFieldValue(term.def, record3) : record3[schema.idField];
           if (raw == null || term.def?.type !== "datetime") return raw;
           const instant = Date.parse(String(raw));
           return Number.isFinite(instant) ? instant : null;
@@ -4141,11 +4705,21 @@ function createGroupingModel(inputSchema) {
       throw new Error("Grouping row budget exceeded.");
     let bytes = rows.length * 16;
     let operations = 0;
+    const readers = keys.map((key) => {
+      const name = groupKeyField(key);
+      const field = schema.fields.find((f2) => f2.name === name);
+      const calendar = isCalendarGroupKey(key) ? calendarKeyReader(key) : null;
+      return [
+        name,
+        (row) => calendar ? calendar(readFieldValue(field, row)) : readFieldValue(field, row)
+      ];
+    });
     const groups = /* @__PURE__ */ new Map();
     for (const row of rows) {
-      const id = groupId(row, keys, schema);
+      const values = readers.map(([, read]) => read(row));
+      const id = groupId(readers.map(([name], i) => [name, values[i]]));
       const bucket = groups.get(id);
-      if (bucket) bucket.push(row);
+      if (bucket) bucket.rows.push(row);
       else {
         if (groups.size >= MAX_RESULT_GROUPS)
           throw new Error(
@@ -4154,7 +4728,7 @@ function createGroupingModel(inputSchema) {
         bytes += id.length * 2 + 256;
         if (bytes > 16e6)
           throw new Error("Grouping retained-memory budget exceeded.");
-        groups.set(id, [row]);
+        groups.set(id, { keys: values, rows: [row] });
       }
     }
     const formulas = new Map(
@@ -4181,15 +4755,13 @@ function createGroupingModel(inputSchema) {
         compiled.plan?.aggregates.map(nodeCost) ?? []
       ])
     );
-    return [...groups].map(([id, members]) => {
+    return [...groups].map(([id, { keys: values, rows: members }]) => {
       const output = Object.assign(/* @__PURE__ */ Object.create(null), {
         [GROUP_ID_FIELD]: id
       });
-      for (const key of keys)
-        output[key] = readFieldValue(
-          schema.fields.find((f2) => f2.name === key),
-          members[0]
-        );
+      readers.forEach(([name], i) => {
+        output[name] = values[i];
+      });
       const chosen = rule && summaries.some((column) => column.op === "row") ? representative(members, rule, schema) : null;
       for (const column of summaries) {
         if (column.op === "link") continue;
@@ -4209,7 +4781,7 @@ function createGroupingModel(inputSchema) {
                   throw new Error("Grouping operation budget exceeded.");
                 const rowPlan = rowPlans[i];
                 if (!rowPlan) return { value: 1 };
-                const values = Object.fromEntries(
+                const values2 = Object.fromEntries(
                   rowPlan.dependencies.map((name) => {
                     const value = readFieldValue(
                       schema.fields.find((f2) => f2.name === name),
@@ -4221,7 +4793,7 @@ function createGroupingModel(inputSchema) {
                     ];
                   })
                 );
-                return formulaRuntime(rowPlan.ast, values);
+                return formulaRuntime(rowPlan.ast, values2);
               })
             )
           );
@@ -4290,10 +4862,33 @@ function createGroupingModel(inputSchema) {
   function validate(definition) {
     if (definition.diagnostics?.length)
       throw new Error(definition.diagnostics.join(" "));
-    if (!definition.keys.length || definition.keys.length > MAX_GROUP_BY_FIELDS || new Set(definition.keys).size !== definition.keys.length || definition.keys.some(
-      (key) => key === GROUP_ID_FIELD || !groupableFields.some((f2) => f2.name === key)
+    const names = definition.keys.map(
+      (key) => typeof key === "string" || isCalendarGroupKey(key) ? groupKeyField(key) : ""
+    );
+    if (!definition.keys.length || definition.keys.length > MAX_GROUP_BY_FIELDS || new Set(names).size !== names.length || names.some(
+      (key) => typeof key !== "string" || key === GROUP_ID_FIELD || !groupableFields.some((f2) => f2.name === key)
     ))
       throw new Error("Choose valid group keys from the source schema.");
+    for (const key of definition.keys) {
+      if (!isCalendarGroupKey(key)) continue;
+      const field = sourceField(key.field);
+      if (isMetricCycle(key.interval))
+        throw new Error(
+          `Group key ${field.label}: hour-of-day and day-of-week are metric intervals (dateGrouping); a group key takes hour, day, week, month or year.`
+        );
+      if (!GROUP_KEY_INTERVALS.includes(key.interval))
+        throw new Error(
+          `Group key ${field.label}: choose an hour, day, week, month or year interval.`
+        );
+      if (field.type !== "datetime")
+        throw new Error(
+          `Group key ${field.label}: a calendar interval needs a datetime field.`
+        );
+      if (key.timeZone !== void 0 && !isGroupingTimeZone(key.timeZone))
+        throw new Error(
+          `Group key ${field.label}: use a valid IANA timezone, such as America/Denver or UTC.`
+        );
+    }
     if (definition.summaries.length > MAX_SUMMARY_COLUMNS)
       throw new Error("Too many aggregate columns.");
     const ids = /* @__PURE__ */ new Set([
@@ -4449,105 +5044,6 @@ function toServerQueryV2(q, schema, execution) {
   };
 }
 
-// src/metricDistributions.ts
-function percentile(sorted, p) {
-  if (!Number.isFinite(p) || p < 0 || p > 1)
-    throw Error("Percentile must be between zero and one.");
-  if (sorted.some((v, i) => !Number.isFinite(v) || i > 0 && v < sorted[i - 1]))
-    throw Error("Percentile inputs must be sorted finite numbers.");
-  sorted.forEach(assertMetricNumber);
-  if (!sorted.length) return null;
-  const position = (sorted.length - 1) * p, lower = Math.floor(position), fraction = position - lower;
-  const a = sorted[lower], b = sorted[Math.min(lower + 1, sorted.length - 1)];
-  const raw = (1 - fraction) * a + fraction * b;
-  assertMetricNumber(raw);
-  const value = Math.min(b, Math.max(a, raw));
-  return value;
-}
-function boxSummary(values, whiskers = "minmax") {
-  if (values.some((v) => !Number.isFinite(v)))
-    throw Error("Distribution inputs must be finite numbers.");
-  values.forEach(assertMetricNumber);
-  const sorted = [...values].sort((a, b) => a - b), n = sorted.length;
-  if (!n) return null;
-  const min = sorted[0], max = sorted[n - 1], q1 = percentile(sorted, 0.25), median = percentile(sorted, 0.5), q3 = percentile(sorted, 0.75);
-  const lowFence = q1 - 1.5 * (q3 - q1), highFence = q3 + 1.5 * (q3 - q1);
-  const low = whiskers === "tukey" ? sorted.find((v) => v >= lowFence) : min;
-  const high = whiskers === "tukey" ? [...sorted].reverse().find((v) => v <= highFence) : max;
-  const outside = whiskers === "tukey" ? sorted.filter((v) => v < low || v > high) : [];
-  const outliers = outside.length <= 20 ? outside : [...outside.slice(0, 10), ...outside.slice(-10)];
-  const rawMean = sorted.reduce((sum, value) => sum + value / n, 0);
-  assertMetricNumber(rawMean);
-  const mean = Math.min(max, Math.max(min, rawMean));
-  [min, q1, median, q3, max, mean, low, high].forEach(assertMetricNumber);
-  return {
-    n,
-    min,
-    q1,
-    median,
-    q3,
-    max,
-    mean,
-    low,
-    high,
-    outliers,
-    outlierCount: outside.length,
-    whiskers,
-    method: "exact-linear"
-  };
-}
-function histogramEdges(values, bins) {
-  if (!Number.isInteger(bins) || bins < 2 || bins > 30)
-    throw Error("Choose 2\u201330 histogram bins.");
-  if (values.some((v) => !Number.isFinite(v)))
-    throw Error("Histogram inputs must be finite numbers.");
-  values.forEach(assertMetricNumber);
-  if (!values.length) return [];
-  let min = Infinity, max = -Infinity;
-  for (const value of values) {
-    min = Math.min(min, value);
-    max = Math.max(max, value);
-  }
-  if (min === max) return [min, max];
-  if (!Number.isFinite(max - min))
-    throw Error("Histogram range exceeds finite numeric precision.");
-  const edges = Array.from(
-    { length: bins + 1 },
-    (_, i) => min + (max - min) * (i / bins)
-  );
-  edges[0] = min;
-  edges[bins] = max;
-  edges.forEach(assertMetricNumber);
-  if (edges.some((value, i) => i > 0 && value <= edges[i - 1]))
-    throw Error(
-      "Histogram bins are finer than numeric precision. Reduce the bin count."
-    );
-  return edges;
-}
-function histogramCounts(values, edges) {
-  if (values.some((v) => !Number.isFinite(v)))
-    throw Error("Histogram inputs must be finite numbers.");
-  if (!edges.length) {
-    if (values.length) throw Error("Histogram values require edges.");
-    return [];
-  }
-  if (edges.length < 2 || edges.some(
-    (v, i) => !Number.isFinite(v) || i > 0 && (v < edges[i - 1] || v === edges[i - 1] && edges.length !== 2)
-  ))
-    throw Error("Histogram edges must be ordered finite boundaries.");
-  values.forEach(assertMetricNumber);
-  edges.forEach(assertMetricNumber);
-  const counts = Array(edges.length - 1).fill(0);
-  for (const value of values) {
-    if (value < edges[0] || value > edges[edges.length - 1])
-      throw Error("Value falls outside shared histogram edges.");
-    let bin = 0;
-    while (bin < counts.length - 1 && value >= edges[bin + 1]) bin++;
-    counts[bin] = counts[bin] + 1;
-  }
-  return counts;
-}
-
 // src/metrics.ts
 var aggregates = /* @__PURE__ */ new Set([
   "COUNT",
@@ -4801,8 +5297,11 @@ function hasRegex(plan) {
 function distributionActive(c) {
   return !!c.distribution && (!c.display || c.display.kind === "box" || c.display.kind === "histogram");
 }
+function occurrenceDistribution(c) {
+  return distributionActive(c) && !!c.dateGrouping?.occurrence;
+}
 function metricPlans(c, schema, resolve) {
-  if (distributionActive(c)) {
+  if (distributionActive(c) && !occurrenceDistribution(c)) {
     const p = compileFormula(
       c.distribution.input,
       resolve ? schema.fields.filter(
@@ -4862,21 +5361,28 @@ function validateMetric(c, schema, resolve) {
         throw new FormulaError(
           "Date grouping must use the first grouping field, with a datetime type."
         );
-      if (distributionActive(c))
+      const { occurrence } = c.dateGrouping;
+      if (occurrence) {
+        if (distributionActive(c) && c.distribution.kind !== "box")
+          throw new FormulaError(
+            "Occurrences summarise as a mean or a box plot, not a histogram."
+          );
+        if (c.display?.kind === "scatter")
+          throw new FormulaError(
+            "Occurrences summarise single-value metrics, not scatters."
+          );
+        if (c.window || c.share !== void 0)
+          throw new FormulaError(
+            "Windows and shares do not apply to occurrences of a slot."
+          );
+      } else if (distributionActive(c))
         throw new FormulaError(
           "Date grouping currently supports scalar metrics, not distributions."
         );
     }
     if (c.groupLimit !== void 0 && (!Number.isInteger(c.groupLimit) || c.groupLimit < 1 || c.groupLimit > 1e4))
       throw new FormulaError("Group limit must be 1\u201310,000.");
-    if (c.minCount !== void 0) {
-      if (!Number.isInteger(c.minCount) || c.minCount < 1 || c.minCount > 1e6)
-        throw new FormulaError("Minimum rows per group must be 1\u20131,000,000.");
-      if (!c.groupBy.length)
-        throw new FormulaError(
-          "Minimum rows per group requires at least one grouping field."
-        );
-    }
+    if (c.minCount !== void 0) validateMinCount(c, schema);
     validateMetricWhere(c.where, schema);
     for (const s of c.sort ?? []) {
       if (s.key === "y" && c.display?.kind !== "scatter")
@@ -4903,6 +5409,81 @@ function validateMetric(c, schema, resolve) {
     ];
   }
 }
+function metricMinCount(c) {
+  const m = c.minCount;
+  return m === void 0 ? void 0 : typeof m === "number" ? m : m?.min;
+}
+function metricMinCountMeasure(c) {
+  const m = c.minCount;
+  if (m === void 0 || m === null || typeof m !== "object") return void 0;
+  return m.distinct !== void 0 ? { op: "count_distinct", field: m.distinct } : { op: "sum", field: m.sum };
+}
+function metricMinCountText(c, label = (field) => field) {
+  const min = metricMinCount(c), measure = metricMinCountMeasure(c);
+  if (min === void 0) return void 0;
+  const n = min.toLocaleString();
+  if (!measure) return `${n} ${min === 1 ? "row" : "rows"}`;
+  return measure.op === "sum" ? `${n} total ${label(measure.field)}` : `${n} distinct ${label(measure.field)} ${min === 1 ? "value" : "values"}`;
+}
+function metricMinCountPlan(c, schema, resolve) {
+  const measure = metricMinCountMeasure(c);
+  return measure ? compileMetric(
+    metricExpression({
+      id: "",
+      groupBy: [],
+      op: measure.op,
+      field: resolveFieldName(schema, measure.field) ?? measure.field
+    }),
+    schema,
+    resolve
+  ) : void 0;
+}
+function metricMinCountKeeps(min, count, measure) {
+  if (count === 0) return true;
+  if (!measure) return count >= min;
+  return measure.error !== void 0 || Number(measure.value ?? 0) >= min;
+}
+function validateMinCount(c, schema) {
+  const m = c.minCount;
+  const measured = m !== null && typeof m === "object";
+  const min = measured ? m.min : m;
+  const label = measured ? "Minimum per group" : "Minimum rows per group";
+  if (typeof min !== "number" || !Number.isInteger(min) || min < 1 || min > 1e6)
+    throw new FormulaError(`${label} must be 1\u20131,000,000.`);
+  if (measured) {
+    const o = m;
+    if (Object.keys(o).some((k) => !["min", "distinct", "sum"].includes(k)) || o.distinct === void 0 === (o.sum === void 0))
+      throw new FormulaError(
+        "A minimum per group needs exactly one of distinct and sum."
+      );
+    const name = o.distinct ?? o.sum;
+    const op = o.distinct !== void 0 ? "count_distinct" : "sum";
+    const resolved = typeof name === "string" ? resolveFieldName(schema, name) ?? name : "";
+    const field = schema.fields.find((f2) => f2.name === resolved);
+    if (op === "sum" && field && field.type !== "number")
+      throw new FormulaError(
+        `A summed minimum requires a numeric field, not ${resolved}.`
+      );
+    if (!field || isComputedField(resolved) || !isMeasurable(field) || !aggOpsForField(field).includes(op))
+      throw new FormulaError(
+        op === "sum" ? `Field ${String(name)} cannot be summed for a minimum per group.` : `Field ${String(name)} cannot count distinct values for a minimum per group.`
+      );
+    if (distributionActive(c))
+      throw new FormulaError(
+        "A distinct or summed minimum currently supports scalar metrics, not distributions."
+      );
+    if (c.window && op === "count_distinct")
+      throw new FormulaError(
+        "A distinct minimum cannot be combined across a window's intervals."
+      );
+    if (c.dateGrouping?.occurrence)
+      throw new FormulaError(
+        "A distinct or summed minimum does not apply to occurrences of a slot; use a minimum of rows."
+      );
+  }
+  if (!c.groupBy.length)
+    throw new FormulaError(`${label} requires at least one grouping field.`);
+}
 function validateMetricWhere(where, schema) {
   if (where === void 0) return;
   if (!Array.isArray(where)) throw new FormulaError("Invalid metric filter.");
@@ -4930,13 +5511,23 @@ function metricPopulationError(clause, support) {
     return "This server does not support metric filters.";
   if (clause.minCount !== void 0 && !support.minCount)
     return "This server does not support a minimum rows per group.";
+  if (metricMinCountMeasure(clause) && !support.minCountMeasures)
+    return "This server does not support a minimum of distinct values or a sum per group.";
   return void 0;
 }
 function metricDependencies(c, schema, resolve) {
   return [
     .../* @__PURE__ */ new Set([
       ...c.groupBy.map((name) => resolveFieldName(schema, name) ?? name),
-      ...metricPlans(c, schema, resolve).flatMap((p) => p.dependencies)
+      ...metricPlans(c, schema, resolve).flatMap((p) => p.dependencies),
+      // An invalid minimum fails validation, not dependency discovery.
+      ...(() => {
+        try {
+          return metricMinCountPlan(c, schema, resolve)?.dependencies;
+        } catch {
+          return void 0;
+        }
+      })() ?? []
     ])
   ].sort();
 }
@@ -4946,7 +5537,7 @@ function metricComputationKey(clauses) {
       id: c.id,
       diagnostics: c.diagnostics,
       unsupportedOp: c.unsupportedOp,
-      expression: distributionActive(c) ? void 0 : metricExpression(c),
+      expression: distributionActive(c) && !occurrenceDistribution(c) ? void 0 : metricExpression(c),
       expressionY: c.display?.kind === "scatter" ? c.expressionY : void 0,
       scope: c.scope ?? "allMatching",
       groupBy: c.groupBy,
@@ -5046,7 +5637,7 @@ function toMetricQuery(q, schema, execution) {
         code: "unexpanded_series",
         from: 0,
         to: 1,
-        message: "Windows, shares and whole intervals are computed from plain metrics; expand the query with planMetricSeries first."
+        message: "Windows, shares, whole intervals and occurrences are computed from plain metrics; expand the query with planMetricSeries first."
       });
   for (const c of q.aggregations ?? [])
     if (c.dateGrouping)
@@ -5395,7 +5986,7 @@ function evaluateMetrics(rows, q, schema, options2 = {}) {
                 config.interval,
                 config.timeZone
               );
-              dateKey = new Date(dateStart).toISOString();
+              dateKey = isMetricCycle(config.interval) ? metricCycleSlot(dateStart, config.interval, config.timeZone) : new Date(dateStart).toISOString();
             }
             keys[0] = dateKey;
           }
@@ -5429,7 +6020,8 @@ function evaluateMetrics(rows, q, schema, options2 = {}) {
               tick();
               reserve(8);
               groupBytes += 8;
-              observed.push(metricDateTime(group.keys[0]));
+              if (!isMetricCycle(config.interval))
+                observed.push(metricDateTime(group.keys[0]));
               const tuple = group.keys.slice(1);
               const key = JSON.stringify(tuple);
               if (!series2.has(key)) {
@@ -5444,7 +6036,24 @@ function evaluateMetrics(rows, q, schema, options2 = {}) {
             groupBytes += 132;
             series2.set("[]", []);
           }
-          const range = metricDateRange(
+          const slots = isMetricCycle(config.interval) ? metricCycleSlots(config.interval) : void 0;
+          for (const slot of slots ?? [])
+            for (const tuple of series2.values()) {
+              tick();
+              const keys = [slot, ...tuple];
+              const key = JSON.stringify(keys);
+              if (key.length > keyLimit)
+                throw Error("Metric grouping key length budget exceeded.");
+              if (!groups.has(key)) {
+                if (groups.size >= (options2.maxGroups ?? 1e4))
+                  throw Error("Metric group budget exceeded.");
+                const bytes = 256 + 16 * keys.length + 4 * key.length;
+                reserve(bytes);
+                groupBytes += bytes;
+                groups.set(key, { keys, rows: [] });
+              }
+            }
+          const range = slots ? void 0 : metricDateRange(
             config,
             q,
             observed,
@@ -5539,12 +6148,16 @@ function evaluateMetrics(rows, q, schema, options2 = {}) {
           );
         };
         const populations = /* @__PURE__ */ new Map();
+        const minPlan = metricMinCountPlan(c, schema, options2.resolveComputed);
+        const measures = /* @__PURE__ */ new Map();
         let buckets = [...groups.values()].map((g) => {
           const bucket = {
             keys: g.keys,
             count: g.rows.length,
             value: null
           };
+          if (minPlan && g.rows.length)
+            measures.set(bucket, reduce(minPlan, g.rows, /* @__PURE__ */ new Set()));
           if (distributionActive(c)) {
             const values = [];
             bucket.nullCount = 0;
@@ -5607,9 +6220,10 @@ function evaluateMetrics(rows, q, schema, options2 = {}) {
           }
         }
         let hiddenGroups;
-        if (c.minCount !== void 0) {
+        const min = metricMinCount(c);
+        if (min !== void 0) {
           const kept = buckets.filter(
-            (b) => b.count === 0 || b.count >= c.minCount
+            (b) => metricMinCountKeeps(min, b.count, minPlan ? measures.get(b) : void 0)
           );
           hiddenGroups = buckets.length - kept.length;
           buckets = kept;
@@ -5710,7 +6324,7 @@ function matchesClause(row, clause, schema, options2 = {}) {
     { ...clause, field },
     evaluationTime(options2)
   );
-  prepareDatetimePredicates([{ kind: "lit", predicate: prepared }], byName);
+  prepareDatetimePredicates([{ branches: [[prepared]] }], byName);
   return matchesWith(byName, row, prepared);
 }
 function applyAggregations(rows, q, schema, options2 = {}) {
@@ -5858,25 +6472,15 @@ function prepareWhereClause(clause, now) {
   };
 }
 function prepareWhereTerm(term, resolveField2, now) {
-  if (isOrGroup(term)) {
-    return {
-      kind: "or",
-      predicates: term.any.map(
-        (c) => prepareWhereClause({ ...c, field: resolveField2(c.field) }, now)
-      )
-    };
-  }
   return {
-    kind: "lit",
-    predicate: prepareWhereClause(
-      { ...term, field: resolveField2(term.field) },
-      now
+    branches: branchesOf(term).map(
+      (branch) => branch.map((c) => prepareWhereClause({ ...c, field: resolveField2(c.field) }, now))
     )
   };
 }
 function prepareDatetimePredicates(terms, fields) {
   for (const term of terms)
-    for (const p of term.kind === "lit" ? [term.predicate] : term.predicates) {
+    for (const p of term.branches.flat()) {
       const field = fields.get(p.clause.field);
       if (field?.type !== "datetime" || p.clause.value === "" || p.clause.op === "is_null" || p.clause.op === "is_not_null")
         continue;
@@ -5884,8 +6488,7 @@ function prepareDatetimePredicates(terms, fields) {
     }
 }
 function matchesTerm(byName, row, term) {
-  if (term.kind === "lit") return matchesWith(byName, row, term.predicate);
-  return term.predicates.some((p) => matchesWith(byName, row, p));
+  return term.branches.some((branch) => branch.every((p) => matchesWith(byName, row, p)));
 }
 function matchesWith(byName, row, prepared) {
   const { clause } = prepared;
@@ -6053,6 +6656,7 @@ function memoryStorageAdapter() {
   const saved = /* @__PURE__ */ new Map();
   const defaults = /* @__PURE__ */ new Map();
   return {
+    storesHostState: true,
     async loadLast(key) {
       const query = last.get(key);
       return query ? normalizeQueryState(query) : null;
@@ -6143,6 +6747,7 @@ function localStorageAdapter() {
     else ls.removeItem(DEFAULT_PREFIX + key);
   };
   return {
+    storesHostState: true,
     async loadLast(key) {
       if (!ls) return null;
       try {
@@ -6325,7 +6930,7 @@ function sourceDependencies(query, schema, resolveComputed) {
   if (query.grouping) {
     const model = createGroupingModel(schema);
     model.validate(query.grouping);
-    for (const key of query.grouping.keys) fields.add(key);
+    for (const key of groupKeyFields(query.grouping.keys)) fields.add(key);
     for (const summary of query.grouping.summaries) {
       if (summary.op === "link") continue;
       if (summary.op === "row") fields.add(summary.field);
@@ -6372,8 +6977,9 @@ function clauseKey(clause) {
   ]);
 }
 function whereTermKey(term) {
-  if (!isOrGroup(term)) return clauseKey(term);
-  return `any:${JSON.stringify(term.any.map(clauseKey).sort())}`;
+  if (!isWhereGroup(term)) return clauseKey(term);
+  const branchKey = (member) => isWhereConjunction(member) ? `all:${JSON.stringify(member.all.map(clauseKey).sort())}` : clauseKey(member);
+  return `any:${JSON.stringify(term.any.map(branchKey).sort())}`;
 }
 function appendWhereTerms(where, terms) {
   const present = new Set(where.map(whereTermKey));
@@ -6391,7 +6997,7 @@ function filterUnits(where) {
   for (const term of where) {
     const last = units[units.length - 1];
     const previous = last?.[last.length - 1];
-    if (last && previous && !isOrGroup(term) && !isOrGroup(previous) && term.op === "!=" && previous.op === "!=" && term.field === previous.field)
+    if (last && previous && !isWhereGroup(term) && !isWhereGroup(previous) && term.op === "!=" && previous.op === "!=" && term.field === previous.field)
       last.push(term);
     else units.push([term]);
   }
@@ -6629,6 +7235,8 @@ function toQueryRequestV3(query, baseSchema, capabilities, execution, options2 =
   let resultSchema = sourceSchema;
   if (q.grouping) {
     if (!capabilities.groupedRows) diagnostics.push("This server does not support grouped rows.");
+    else if (q.grouping.keys.some(isCalendarGroupKey) && !capabilities.calendarGroupKeys)
+      diagnostics.push("This server does not support grouping keys by calendar interval.");
     try {
       const model = createGroupingModel(sourceSchema);
       model.validate(q.grouping);
@@ -6656,6 +7264,8 @@ function toQueryRequestV3(query, baseSchema, capabilities, execution, options2 =
   for (const metric of metrics) {
     diagnostics.push(...validateMetric(metric, resultSchema).map((issue) => issue.message));
     if (metric.dateGrouping && !capabilities.calendarGrouping) diagnostics.push("This server does not support calendar grouping.");
+    else if (isMetricCycle(metric.dateGrouping?.interval) && !capabilities.calendarCycles)
+      diagnostics.push("This server does not support hour-of-day or day-of-week grouping.");
   }
   const revisions = /* @__PURE__ */ Object.create(null);
   for (const [id, revision] of Object.entries(execution?.resolvedRevisions ?? {})) {
@@ -6714,6 +7324,13 @@ function inspectBucketQuery(query, bucket, clause, schema) {
   for (const [index, name] of clause.groupBy.entries()) {
     const field = resolveField(fields, name);
     const key = bucket.keys[index] ?? null;
+    if (clause.dateGrouping && index === 0 && key !== null && isMetricCycle(clause.dateGrouping.interval)) {
+      if (!field || field.type !== "datetime" || !isFilterable(field)) return null;
+      const slot = cycleSlotTerms(query, clause, fields, field.name, key);
+      if (!slot) return null;
+      terms.push(...slot);
+      continue;
+    }
     if (clause.dateGrouping && index === 0 && key !== null) {
       if (!field || field.type !== "datetime" || !isFilterable(field)) return null;
       let start;
@@ -6760,7 +7377,54 @@ function inspectBucketQuery(query, bucket, clause, schema) {
       { field: field.name, op: inclusiveMax ? "<=" : "<", value: String(max) }
     );
   }
-  return { ...query, where: appendWhereTerms(query.where, terms), offset: 0 };
+  const where = appendWhereTerms(query.where, terms);
+  if (isMetricCycle(clause.dateGrouping?.interval) && where.reduce((n, term) => n + predicatesOf(term).length, 0) > MAX_WHERE_CLAUSES) return null;
+  return { ...query, where, offset: 0 };
+}
+function cycleSlotTerms(query, clause, schema, field, key) {
+  const config = clause.dateGrouping, cycle = config.interval;
+  if (!isMetricCycle(cycle) || typeof key !== "number" || !metricCycleSlots(cycle).includes(key)) return null;
+  const now = Date.now();
+  let { lower, upper } = metricDateBounds(clause, query, schema, now);
+  const whole = config.occurrence ? { ...clause, dateGrouping: { ...config, interval: config.occurrence.interval } } : config.partialIntervals === "exclude" ? clause : void 0;
+  if (whole) {
+    const span = wholeIntervalSpan(whole, query, schema, now);
+    lower = span.start ?? -Infinity;
+    upper = span.end;
+  }
+  if (!Number.isFinite(lower) || !Number.isFinite(upper)) return null;
+  const budget = Math.floor(MAX_WHERE_CLAUSES / 2);
+  const ranges = [];
+  const unit = metricCalendarUnit(cycle);
+  for (let start = metricDateFloor(lower, unit, config.timeZone); start < upper; ) {
+    const next = metricDateNext(start, unit, config.timeZone);
+    if (!Number.isFinite(next) || next <= start) return null;
+    if (metricCycleSlot(start, cycle, config.timeZone) === key) {
+      const from = Math.max(start, lower), to = Math.min(next, upper);
+      const last = ranges[ranges.length - 1];
+      if (from < to) {
+        if (last && last[1] === from) last[1] = to;
+        else if (ranges.push([from, to]) > budget) return null;
+      }
+    }
+    start = next;
+  }
+  const iso = (time) => new Date(time).toISOString();
+  if (!ranges.length)
+    return [
+      { field, op: ">=", value: iso(lower) },
+      { field, op: "<", value: iso(lower) }
+    ];
+  const terms = [
+    { field, op: ">=", value: iso(ranges[0][0]) },
+    { field, op: "<", value: iso(ranges[ranges.length - 1][1]) }
+  ];
+  for (let i = 0; i + 1 < ranges.length; i++)
+    terms.push({ any: [
+      { field, op: "<", value: iso(ranges[i][1]) },
+      { field, op: ">=", value: iso(ranges[i + 1][0]) }
+    ] });
+  return terms;
 }
 function groupSourceQuery(query, group, schema) {
   if (!query.grouping) return null;
@@ -6769,6 +7433,119 @@ function groupSourceQuery(query, group, schema) {
   const source = exitGrouping(query);
   return { ...source, where: appendWhereTerms(source.where, terms), offset: 0 };
 }
+
+// src/attention.ts
+function validTarget(target) {
+  return typeof target.dataset === "string" && target.dataset.length > 0 && target.dataset.length <= 256 && (target.rowId === void 0 || typeof target.rowId === "string" && target.rowId.length > 0 && target.rowId.length <= 1e3 || typeof target.rowId === "number" && Number.isFinite(target.rowId)) && (target.field === void 0 || target.rowId !== void 0 && typeof target.field === "string" && target.field.length > 0 && target.field.length <= 256) && (target.path === void 0 || target.field !== void 0 && isJsonPath(target.path));
+}
+function attentionTargetKey(target) {
+  return JSON.stringify([target.dataset, target.rowId ?? null, target.field ?? null, target.path ?? null]);
+}
+var cancelled = () => new Error("Attention navigation cancelled.");
+function abortable(promise, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      cleanup();
+      reject(cancelled());
+    };
+    const cleanup = () => signal.removeEventListener("abort", abort);
+    if (signal.aborted) {
+      reject(cancelled());
+      return;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    promise.then((value) => {
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+}
+function createAttentionRegistry() {
+  const providers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let current;
+  const lookup = (target) => providers.get(attentionTargetKey(target))?.slice(-1)[0];
+  return {
+    cancel() {
+      current?.abort();
+      current = void 0;
+    },
+    register(target, provider) {
+      if (!validTarget(target)) throw Error("Invalid semantic attention target.");
+      const key = attentionTargetKey(target);
+      const entries = providers.get(key) ?? [];
+      providers.set(key, [...entries, provider]);
+      listeners.forEach((listener) => listener());
+      return () => {
+        const remaining = providers.get(key)?.filter((entry) => entry !== provider) ?? [];
+        if (remaining.length) providers.set(key, remaining);
+        else providers.delete(key);
+      };
+    },
+    whenRegistered(target, signal, except) {
+      return new Promise((resolve, reject) => {
+        const cleanup = () => {
+          listeners.delete(check);
+          signal.removeEventListener("abort", abort);
+        };
+        const abort = () => {
+          cleanup();
+          reject(cancelled());
+        };
+        const check = () => {
+          const provider = lookup(target);
+          if (provider && provider !== except) {
+            cleanup();
+            resolve(provider);
+          }
+        };
+        if (signal.aborted) {
+          reject(cancelled());
+          return;
+        }
+        listeners.add(check);
+        signal.addEventListener("abort", abort, { once: true });
+        check();
+      });
+    },
+    async resolve(target, options2) {
+      current?.abort();
+      const controller = new AbortController();
+      current = controller;
+      const signal = controller.signal;
+      const abort = () => controller.abort();
+      options2?.signal?.addEventListener("abort", abort, { once: true });
+      if (options2?.signal?.aborted) controller.abort();
+      const result = (status) => ({ status, target });
+      try {
+        if (signal.aborted) return result("cancelled");
+        if (!validTarget(target)) return result("unavailable");
+        const candidates = [
+          target,
+          { dataset: target.dataset, ...target.rowId !== void 0 ? { rowId: target.rowId } : {}, ...target.field !== void 0 ? { field: target.field } : {} },
+          { dataset: target.dataset, ...target.rowId !== void 0 ? { rowId: target.rowId } : {} },
+          { dataset: target.dataset }
+        ];
+        const provider = candidates.map(lookup).find(Boolean);
+        if (!provider) return result("unavailable");
+        if (provider.ready) await abortable(provider.ready(signal), signal);
+        if (provider.materialize && !await abortable(Promise.resolve(provider.materialize(target, signal)), signal)) return result("unavailable");
+        if (signal.aborted) return result("cancelled");
+        const revealed = await abortable(Promise.resolve(provider.reveal(target, signal)), signal);
+        return result(signal.aborted ? "cancelled" : revealed ? "revealed" : "unavailable");
+      } catch (error) {
+        if (signal.aborted) return result("cancelled");
+        throw error;
+      } finally {
+        options2?.signal?.removeEventListener("abort", abort);
+        if (current === controller) current = void 0;
+      }
+    }
+  };
+}
 export {
   AGG_OPS_BY_TYPE,
   AGG_OPS_NEEDING_FIELD,
@@ -6777,10 +7554,17 @@ export {
   FORMULA_FUNCTIONS,
   FormulaError,
   GROUP_ID_FIELD,
+  GROUP_KEY_INTERVALS,
   GROUP_LINK_RENDER,
   ITEM_DETAILS_COLUMN,
   MAX_AGGREGATIONS,
   MAX_GROUP_BY_FIELDS,
+  MAX_HOST_QUERY_PARAMS,
+  MAX_HOST_QUERY_STATE_BYTES,
+  MAX_HOST_QUERY_VALUES,
+  MAX_HOST_QUERY_VALUE_LENGTH,
+  MAX_JSON_INSPECTIONS,
+  MAX_JSON_PATHS,
   MAX_METRIC_WINDOW_PERIODS,
   MAX_ORDER_BY_TERMS,
   MAX_PROPERTIES,
@@ -6794,6 +7578,7 @@ export {
   MAX_SELECT_COLUMNS,
   MAX_SUMMARY_COLUMNS,
   MAX_WHERE_CLAUSES,
+  METRIC_CYCLE_INTERVALS,
   METRIC_DATE_INTERVALS,
   METRIC_FUNCTIONS,
   NULLARY_OPS,
@@ -6807,12 +7592,16 @@ export {
   applyAggregations,
   applyPatch,
   applyQuery,
+  attentionTargetKey,
   boxSummary,
+  branchesOf,
+  calendarGroupKey,
   coerceValue,
   compareMetricValues,
   compileFormula,
   compileMetric,
   computedFieldName,
+  createAttentionRegistry,
   createGroupingModel,
   createPropertyView,
   createQueryLinkService,
@@ -6826,6 +7615,9 @@ export {
   exitGrouping,
   filterValues,
   formulaRuntime,
+  groupKeyField,
+  groupKeyFields,
+  groupKeyTerms,
   groupLinkQuery,
   groupPreview,
   groupSourceQuery,
@@ -6837,19 +7629,29 @@ export {
   httpQuerySnapshotStore,
   indexFields,
   inspectBucketQuery,
+  isCalendarGroupKey,
   isComputedCellError,
   isComputedField,
   isFilterable,
   isGroupLinkField,
   isGroupLinkValue,
   isGroupable,
+  isGroupingTimeZone,
+  isJsonBucketId,
+  isJsonPath,
   isMeasurable,
+  isMetricCycle,
   isNegativePredicate,
   isOrGroup,
+  isOrOfAndsGroup,
+  isPropertyFieldLoaded,
   isPushdownFilter,
   isSelectable,
   isSortable,
+  isWhereConjunction,
+  isWhereGroup,
   itemPageFields,
+  jsonInspectionScopeKey,
   jsonPropertyViewStorage,
   loadSchema,
   localPropertyViewStorage,
@@ -6863,14 +7665,23 @@ export {
   memoryQuerySnapshotCache,
   memoryStorageAdapter,
   metricAggregatePlans,
+  metricCalendarUnit,
   metricComputationKey,
   metricCustomEndTime,
+  metricCycleSlot,
+  metricCycleSlots,
+  metricDateBounds,
   metricDateFloor,
   metricDateNext,
   metricDateRange,
   metricDateTime,
   metricDependencies,
   metricExpression,
+  metricMinCount,
+  metricMinCountKeeps,
+  metricMinCountMeasure,
+  metricMinCountPlan,
+  metricMinCountText,
   metricPlans,
   metricPopulationError,
   negateClause,
@@ -6878,9 +7689,13 @@ export {
   normalizePropertyView,
   normalizeQueryState,
   objectReferenceKey,
+  occurrenceDistribution,
   opAllowedForType,
   opPairsForField,
   opsForField,
+  parseHostQueryState,
+  parseJsonInspectionState,
+  parseJsonInspections,
   parseRelativeDuration,
   percentile,
   planMetricSeries,