@pythia-software/query-table-core 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,3 +1,145 @@
+// src/metricNormalize.ts
+function normalizeMetricOptions(raw) {
+  const out = {}, diagnostics = [];
+  const record = (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 === "string" ? typeof v === "string" && v.length <= 1e4 : spec === "number" ? typeof v === "number" && Number.isFinite(v) : spec === "boolean" ? typeof v === "boolean" : spec === "integer" ? typeof v === "number" && Number.isSafeInteger(v) && v >= 0 && v <= 1e6 : typeof v === "string" && spec.includes(v))
+        result[key] = v;
+      else diagnostics.push(`Invalid metric ${key}.`);
+    }
+    return result;
+  };
+  Object.assign(
+    out,
+    copy(raw, {
+      expression: "string",
+      expressionY: "string",
+      scope: ["allMatching", "shownRows"],
+      groupLimit: "integer"
+    })
+  );
+  if (raw.display !== void 0) {
+    if (record(raw.display)) {
+      if (typeof raw.display.kind !== "string")
+        diagnostics.push("Invalid metric display kind.");
+      const d = copy(raw.display, {
+        kind: [
+          "auto",
+          "value",
+          "table",
+          "list",
+          "bar-horizontal",
+          "bar-vertical",
+          "line",
+          "pie",
+          "donut",
+          "scatter",
+          "box",
+          "histogram"
+        ],
+        valueLabel: "string",
+        xLabel: "string",
+        yLabel: "string",
+        legendPosition: ["left", "right", "top", "bottom", "none"],
+        boxMean: "boolean"
+      });
+      for (const k of ["xScale", "yScale"]) {
+        if (record(raw.display[k]))
+          d[k] = copy(raw.display[k], {
+            mode: ["linear", "log"],
+            min: "number",
+            max: "number"
+          });
+        else if (raw.display[k] !== void 0)
+          diagnostics.push(`Invalid metric ${k}.`);
+      }
+      for (const k of ["format", "xFormat", "yFormat"])
+        if (record(raw.display[k]))
+          d[k] = copy(raw.display[k], {
+            kind: ["number", "percent", "duration", "date", "time", "datetime"],
+            decimals: "integer",
+            sourceUnit: [
+              "milliseconds",
+              "seconds",
+              "minutes",
+              "hours",
+              "days",
+              "iso",
+              "epochSeconds",
+              "epochMilliseconds",
+              "secondsOfDay",
+              "millisecondsOfDay"
+            ],
+            style: ["human", "long", "clock", "custom", "iso"],
+            pattern: "string",
+            timeZone: "string"
+          });
+      if (record(raw.display.list))
+        d.list = copy(raw.display.list, {
+          showBars: "boolean",
+          useGroupColors: "boolean",
+          showValues: "boolean"
+        });
+      if (record(raw.display.pivot))
+        d.pivot = copy(raw.display.pivot, {
+          swap: "boolean",
+          rowDir: ["asc", "desc"],
+          columnDir: ["asc", "desc"]
+        });
+      out.display = { kind: "auto", ...d };
+    } else diagnostics.push("Invalid metric display.");
+  }
+  if (raw.distribution !== void 0) {
+    if (record(raw.distribution))
+      out.distribution = copy(raw.distribution, {
+        kind: ["box", "histogram"],
+        input: "string",
+        whiskers: ["minmax", "tukey"],
+        bins: "integer"
+      });
+    else diagnostics.push("Invalid metric distribution.");
+  }
+  if (record(raw.layout)) {
+    const l = copy(raw.layout, {
+      widthRem: "integer",
+      heightRem: "integer",
+      minWidthRem: "integer",
+      minHeightRem: "integer"
+    });
+    for (const k of ["widthRem", "heightRem", "minWidthRem", "minHeightRem"])
+      l[k] = Math.max(1, Math.min(1e3, Number(l[k] ?? 1)));
+    l.widthRem = Math.max(Number(l.widthRem), Number(l.minWidthRem));
+    l.heightRem = Math.max(Number(l.heightRem), Number(l.minHeightRem));
+    out.layout = l;
+  }
+  if (raw.sort !== void 0 && !Array.isArray(raw.sort))
+    diagnostics.push("Invalid metric sort.");
+  if (Array.isArray(raw.sort))
+    out.sort = raw.sort.slice(0, 20).flatMap((s) => {
+      if (!record(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 [];
+      }
+      return [
+        copy(s, {
+          key: [s.key],
+          dir: ["asc", "desc"],
+          nulls: ["first", "last"]
+        })
+      ];
+    });
+  if (Array.isArray(raw.diagnostics))
+    diagnostics.push(
+      ...raw.diagnostics.filter((s) => typeof s === "string" && s.length <= 1e3).slice(0, 20)
+    );
+  if (diagnostics.length) out.diagnostics = [...new Set(diagnostics)];
+  return out;
+}
+
 // src/computed.ts
 var COMPUTED_PREFIX = "@computed/";
 var computedFieldName = (id) => COMPUTED_PREFIX + id;
@@ -275,7 +417,7 @@ function normalizeQueryState(input, fallback = EMPTY_QUERY) {
     for (const item of raw.orderBy.slice(0, MAX_ORDER_BY_TERMS)) {
       if (!isRecord(item)) continue;
       const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
-      if (!field || isComputedField(field) || item.dir !== "asc" && item.dir !== "desc") continue;
+      if (!field || item.dir !== "asc" && item.dir !== "desc") continue;
       const term = { field, dir: item.dir };
       if (item.nulls === "first" || item.nulls === "last") term.nulls = item.nulls;
       if (isRecord(item.extract) && typeof item.extract.regex === "string" && item.extract.regex.length <= MAX_FILTER_VALUE_LENGTH) {
@@ -300,19 +442,26 @@ function normalizeQueryState(input, fallback = EMPTY_QUERY) {
     for (const item of raw.aggregations.slice(0, MAX_AGGREGATIONS)) {
       if (!isRecord(item)) continue;
       const id = boundedString(item.id, MAX_FIELD_NAME_LENGTH);
-      if (!id || typeof item.op !== "string" || !AGG_OPS.has(item.op) || !Array.isArray(item.groupBy)) continue;
-      const groupBy = item.groupBy.slice(0, MAX_GROUP_BY_FIELDS).map((field2) => boundedString(field2, MAX_FIELD_NAME_LENGTH)).filter((field2) => field2 != null);
-      const aggregation = { id, op: item.op, groupBy };
+      if (!id) continue;
+      const validOp = typeof item.op === "string" && AGG_OPS.has(item.op);
+      const rawGroups = Array.isArray(item.groupBy) ? item.groupBy : [];
+      const groupBy = rawGroups.slice(0, MAX_GROUP_BY_FIELDS).map((field2) => boundedString(field2, MAX_FIELD_NAME_LENGTH)).filter((field2) => field2 != null);
+      const aggregation = { id, op: validOp ? item.op : "count", groupBy };
       const field = boundedString(item.field, MAX_FIELD_NAME_LENGTH);
       const label = boundedString(item.label, MAX_LABEL_LENGTH);
-      if (field && isComputedField(field) || groupBy.some(isComputedField)) continue;
       if (field) aggregation.field = field;
       if (label) aggregation.label = label;
+      Object.assign(aggregation, normalizeMetricOptions(item));
+      if (!Array.isArray(item.groupBy) || rawGroups.length > MAX_GROUP_BY_FIELDS || groupBy.length !== rawGroups.length) aggregation.diagnostics = [...aggregation.diagnostics ?? [], "Invalid metric grouping fields or grouping budget exceeded."];
+      const unsupportedOp = boundedString(item.unsupportedOp ?? (!validOp ? item.op : void 0), MAX_FIELD_NAME_LENGTH);
+      if (unsupportedOp) aggregation.unsupportedOp = unsupportedOp;
+      if (item.field !== void 0 && !field) aggregation.diagnostics = [...aggregation.diagnostics ?? [], "Invalid metric measure field."];
+      if (!validOp && typeof item.expression !== "string") aggregation.diagnostics = [...aggregation.diagnostics ?? [], "Unsupported aggregate operation."];
       aggregations.push(aggregation);
     }
     if (aggregations.length > 0) out.aggregations = aggregations;
   } else if (fallback.aggregations?.length) {
-    out.aggregations = fallback.aggregations.map((aggregation) => ({ ...aggregation, groupBy: [...aggregation.groupBy] }));
+    out.aggregations = normalizeQueryState({ aggregations: fallback.aggregations }).aggregations;
   }
   return out;
 }
@@ -342,7 +491,7 @@ function isPushdownFilter(f2) {
   return isFilterable(f2) && (f2.filter?.pushdown ?? f2.source.kind === "backend");
 }
 function isSortable(f2) {
-  if (f2.source.kind === "derived" && f2.source.computedId) return false;
+  if (f2.source.kind === "derived" && f2.source.computedId) return f2.sort?.enabled === true;
   return f2.sort?.enabled ?? f2.source.kind === "backend";
 }
 function isSelectable(f2) {
@@ -489,6 +638,34 @@ function normalizeAliases(rawAliases, rawAlias) {
   return aliases;
 }
 
+// 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(options) {
+  const now = options.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 = {
@@ -564,7 +741,7 @@ function opsForField(field) {
 function opAllowedForType(type, op) {
   return OPS_BY_TYPE[type].includes(op);
 }
-function coerceValue(type, raw) {
+function coerceValue(type, raw, now) {
   switch (type) {
     case "number": {
       const n = Number(raw);
@@ -578,6 +755,11 @@ function coerceValue(type, raw) {
       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;
@@ -613,11 +795,13 @@ function aggOpAllowedForType(type, op) {
   return AGG_OPS_BY_TYPE[type].includes(op);
 }
 function isMeasurable(field) {
+  if (field.source.kind === "derived" && field.source.computedId) return field.aggregate?.measure === true;
   if (field.source.kind !== "backend") return false;
   if (field.aggregate?.measure != null) return field.aggregate.measure;
   return aggOpsForField(field).length > 0;
 }
 function isGroupable(field) {
+  if (field.source.kind === "derived" && field.source.computedId) return field.aggregate?.groupable === true;
   if (field.source.kind !== "backend") return false;
   if (field.aggregate?.groupable != null) return field.aggregate.groupable;
   return field.type === "enum" || field.type === "text" || field.type === "bool";
@@ -773,7 +957,9 @@ function termIsPushdown(term, byName, resolveField2) {
   });
 }
 function toAggregationQuery(q, schema) {
+  const suppliedPredicateCount = q.where.reduce((n, t) => n + predicatesOf(t).length, 0);
   q = normalizeQueryState(q);
+  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)) throw new Error("Metric definition requires the version 2 metric transport.");
   const byName = indexFields(schema);
   const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
   const where = q.where.filter((term) => termIsPushdown(term, byName, resolveField2)).map(stripSetFilter);
@@ -786,411 +972,10 @@ function toAggregationQuery(q, schema) {
   const aggregations = (q.aggregations ?? []).filter(
     (a) => isBackend(a.field) && a.groupBy.every((g) => isBackend(g))
   );
-  return { where, aggregations };
-}
-
-// src/apply.ts
-function applyQuery(rows, q, schema) {
-  const byName = indexFields(schema);
-  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
-  const whereTerms = q.where.filter((term) => !predicatesOf(term).some((c) => isComputedField(c.field))).map((term) => prepareWhereTerm(term, resolveField2));
-  const orderBy = q.orderBy.filter((term) => !isComputedField(term.field)).map((term) => ({ ...term, field: resolveField2(term.field) }));
-  let out = rows.filter((row) => whereTerms.every((term) => matchesTerm(byName, row, term)));
-  const total = out.length;
-  if (orderBy.length) {
-    const terms = orderBy.map((t) => ({
-      field: byName.get(t.field),
-      dir: t.dir,
-      nullsLast: (t.nulls ?? "last") === "last",
-      extract: compileRegex(t.extract?.regex)
-    })).filter(
-      (t) => t.field != null
-    );
-    out = [...out].sort((a, b) => {
-      for (const t of terms) {
-        const av = extractSortValue(readFieldValue(t.field, a), t.extract);
-        const bv = extractSortValue(readFieldValue(t.field, b), t.extract);
-        const aNull = av == null;
-        const bNull = bv == null;
-        if (aNull || bNull) {
-          if (aNull && bNull) continue;
-          return (aNull ? 1 : -1) * (t.nullsLast ? 1 : -1);
-        }
-        const cmp = compare(av, bv);
-        if (cmp !== 0) return t.dir === "asc" ? cmp : -cmp;
-      }
-      return 0;
-    });
-  }
-  const start = q.offset > 0 ? q.offset : 0;
-  const end = q.limit > 0 ? start + q.limit : out.length;
-  return { rows: out.slice(start, end), total };
-}
-function matchesClause(row, clause, schema) {
-  return matchesWith(indexFields(schema), row, prepareWhereClause(clause));
-}
-function applyAggregations(rows, q, schema) {
-  const byName = indexFields(schema);
-  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
-  const whereTerms = q.where.filter((term) => !predicatesOf(term).some((c) => isComputedField(c.field))).map((term) => prepareWhereTerm(term, resolveField2));
-  const filtered = rows.filter((row) => whereTerms.every((term) => matchesTerm(byName, row, term)));
-  const metrics = (q.aggregations ?? []).filter((a) => !isComputedField(a.field ?? "") && !a.groupBy.some(isComputedField)).map((agg) => ({
-    id: agg.id,
-    buckets: computeBuckets(filtered, agg, byName, resolveField2)
-  }));
-  return { metrics };
-}
-function computeBuckets(rows, agg, byName, resolveField2) {
-  const groupFields = agg.groupBy.map((n) => byName.get(resolveField2(n)));
-  const measure = agg.field ? byName.get(resolveField2(agg.field)) : void 0;
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const keys = groupFields.map((f2) => {
-      if (!f2) return null;
-      const v = readFieldValue(f2, row);
-      return v == null || v === "" ? null : String(v);
-    });
-    const k = JSON.stringify(keys);
-    let g = groups.get(k);
-    if (!g) {
-      g = { keys, rows: [] };
-      groups.set(k, g);
-    }
-    g.rows.push(row);
-  }
-  const buckets = [...groups.values()].map((g) => ({
-    keys: g.keys,
-    count: g.rows.length,
-    value: aggValue(agg.op, measure, g.rows)
-  }));
-  return sortBuckets(buckets);
-}
-function aggValue(op, measure, rows) {
-  if (op === "count") {
-    if (!measure) return rows.length;
-    let n = 0;
-    for (const r of rows) if (readFieldValue(measure, r) != null) n++;
-    return n;
-  }
-  if (!measure) return null;
-  const values = rows.map((r) => readFieldValue(measure, r)).filter((v) => v != null);
-  switch (op) {
-    case "count_distinct":
-      return new Set(values.map((v) => String(v))).size;
-    case "sum":
-    case "avg": {
-      let sum = 0;
-      let n = 0;
-      for (const v of values) {
-        const num = typeof v === "number" ? v : Number(v);
-        if (Number.isFinite(num)) {
-          sum += num;
-          n++;
-        }
-      }
-      if (op === "avg") return n ? sum / n : null;
-      return n ? sum : null;
-    }
-    case "min":
-    case "max": {
-      let best;
-      for (const v of values) {
-        if (best === void 0) {
-          best = v;
-          continue;
-        }
-        const cmp = compare(v, best);
-        if (op === "min" ? cmp < 0 : cmp > 0) best = v;
-      }
-      return best ?? null;
-    }
-    default:
-      return null;
-  }
-}
-function sortBuckets(buckets) {
-  return [...buckets].sort((a, b) => {
-    const av = typeof a.value === "number" ? a.value : a.count;
-    const bv = typeof b.value === "number" ? b.value : b.count;
-    if (av !== bv) return bv - av;
-    return JSON.stringify(a.keys).localeCompare(JSON.stringify(b.keys));
-  });
-}
-function prepareWhereClause(clause) {
-  const usesRegex = clause.op === "matches_regex" || clause.op === "not_matches_regex";
-  return { clause, regex: usesRegex ? compileRegex(clause.value) : void 0 };
-}
-function prepareWhereTerm(term, resolveField2) {
-  if (isOrGroup(term)) {
-    return { kind: "or", predicates: term.any.map((c) => prepareWhereClause({ ...c, field: resolveField2(c.field) })) };
-  }
-  return { kind: "lit", predicate: prepareWhereClause({ ...term, field: resolveField2(term.field) }) };
-}
-function matchesTerm(byName, row, term) {
-  if (term.kind === "lit") return matchesWith(byName, row, term.predicate);
-  return term.predicates.some((p) => matchesWith(byName, row, p));
-}
-function matchesWith(byName, row, prepared) {
-  const { clause } = prepared;
-  const field = byName.get(clause.field);
-  if (!field) return true;
-  const v = readFieldValue(field, row);
-  if (clause.value === "" && clause.op !== "=" && clause.op !== "!=" && clause.op !== "is_null" && clause.op !== "is_not_null") {
-    return true;
-  }
-  if (clause.op === "length_gt" || clause.op === "length_lt" || clause.op === "length_eq") {
-    if (!/^(0|[1-9]\d*)$/.test(clause.value) || !Number.isSafeInteger(Number(clause.value))) return false;
-  }
-  const base = matchesBase(field, v, prepared);
-  if (!clause.negated) return base;
-  const isNull = Array.isArray(v) ? v.length === 0 : v == null || v === "";
-  return !isNull && !base;
-}
-function matchesBase(field, v, prepared) {
-  const { clause, regex } = prepared;
-  if (clause.op === "is_null") return Array.isArray(v) ? v.length === 0 : v == null || v === "";
-  if (clause.op === "is_not_null") return Array.isArray(v) ? v.length > 0 : v != null && v !== "";
-  const arrayText = (value) => field.filter?.arrayCaseSensitive ? String(value) : String(value).toLowerCase();
-  if (clause.op === "includes") {
-    const arr = Array.isArray(v) ? v : [];
-    const needle = arrayText(clause.value);
-    return arr.some((x) => arrayText(x) === needle);
-  }
-  if (clause.op === "matches_regex" || clause.op === "not_matches_regex") {
-    if (v == null || Array.isArray(v)) return false;
-    if (!regex) return false;
-    const matches = regex.test(String(v));
-    return clause.op === "matches_regex" ? matches : !matches;
-  }
-  if (clause.op === "length_gt" || clause.op === "length_lt" || clause.op === "length_eq") {
-    if (typeof v !== "string" || !/^(0|[1-9]\d*)$/.test(clause.value)) return false;
-    const limit = Number(clause.value);
-    if (!Number.isSafeInteger(limit)) return false;
-    const length = Array.from(v).length;
-    return clause.op === "length_gt" ? length > limit : clause.op === "length_lt" ? length < limit : length === limit;
-  }
-  if (Array.isArray(v)) {
-    const needle = arrayText(clause.value);
-    const hay = v.map(arrayText);
-    switch (clause.op) {
-      case "contains":
-        return hay.some((s) => s.includes(needle));
-      case "=":
-        return hay.includes(needle);
-      case "!=":
-        return !hay.includes(needle);
-      default:
-        return true;
-    }
-  }
-  switch (clause.op) {
-    case "=":
-      return String(v ?? "") === String(coerceSafe(field, clause.value));
-    case "!=":
-      return String(v ?? "") !== String(coerceSafe(field, clause.value));
-    case ">":
-      return compare(v, coerceSafe(field, clause.value)) > 0;
-    case ">=":
-      return compare(v, coerceSafe(field, clause.value)) >= 0;
-    case "<":
-      return compare(v, coerceSafe(field, clause.value)) < 0;
-    case "<=":
-      return compare(v, coerceSafe(field, clause.value)) <= 0;
-    case "contains":
-      return String(v ?? "").toLowerCase().includes(clause.value.toLowerCase());
-    case "starts_with":
-      return String(v ?? "").toLowerCase().startsWith(clause.value.toLowerCase());
-    case "ends_with":
-      return String(v ?? "").toLowerCase().endsWith(clause.value.toLowerCase());
-    default:
-      return true;
-  }
-}
-function compileRegex(pattern) {
-  if (pattern === void 0) return void 0;
-  try {
-    return new RegExp(pattern);
-  } catch {
-    return null;
-  }
-}
-function extractSortValue(value, regex) {
-  if (regex === void 0) return value;
-  if (regex === null || value == null) return null;
-  const match = regex.exec(String(value));
-  if (!match) return null;
-  return match.length > 1 ? match[1] ?? null : match[0];
-}
-function coerceSafe(field, raw) {
-  try {
-    return coerceValue(field.type, raw);
-  } catch {
-    return raw;
-  }
-}
-function compare(a, b) {
-  if (a == null && b == null) return 0;
-  if (a == null) return -1;
-  if (b == null) return 1;
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  if (typeof a === "boolean" && typeof b === "boolean") return a === b ? 0 : a ? 1 : -1;
-  return String(a).localeCompare(String(b));
-}
-
-// src/adapters.ts
-var LAST_PREFIX = "query-table:last:";
-var SAVED_PREFIX = "query-table:saved:";
-var DEFAULT_PREFIX = "query-table:default:";
-var MAX_SAVED_QUERIES = 100;
-var MAX_SAVED_NAME_LENGTH = 200;
-function normalizeSavedQuery(value) {
-  if (value == null || typeof value !== "object" || Array.isArray(value)) return null;
-  const raw = value;
-  if (typeof raw.id !== "string" || !raw.id || raw.id.length > 256 || typeof raw.name !== "string" || !raw.name || raw.name.length > MAX_SAVED_NAME_LENGTH || typeof raw.savedAt !== "number" || !Number.isFinite(raw.savedAt) || raw.query == null || typeof raw.query !== "object") {
-    return null;
-  }
-  return { id: raw.id, name: raw.name, savedAt: raw.savedAt, query: normalizeQueryState(raw.query) };
-}
-function normalizeSavedQueries(value) {
-  if (!Array.isArray(value)) return [];
-  return value.slice(0, MAX_SAVED_QUERIES).map(normalizeSavedQuery).filter((item) => item != null);
-}
-function memoryStorageAdapter() {
-  const last = /* @__PURE__ */ new Map();
-  const saved = /* @__PURE__ */ new Map();
-  const defaults = /* @__PURE__ */ new Map();
-  return {
-    async loadLast(key) {
-      const query = last.get(key);
-      return query ? normalizeQueryState(query) : null;
-    },
-    async saveLast(key, query) {
-      last.set(key, normalizeQueryState(query));
-    },
-    async listSaved(key) {
-      return (saved.get(key) ?? []).map((item) => ({ ...item, query: normalizeQueryState(item.query) }));
-    },
-    async loadDefaultSaved(key) {
-      const id = defaults.get(key);
-      return id ? (saved.get(key) ?? []).find((item) => item.id === id) ?? null : null;
-    },
-    async setDefaultSaved(key, id) {
-      if (id == null) {
-        defaults.delete(key);
-        return;
-      }
-      if (!(saved.get(key) ?? []).some((item) => item.id === id)) throw new Error(`Saved query "${id}" does not exist.`);
-      defaults.set(key, id);
-    },
-    async saveNamed(key, name, query, savedAt) {
-      const normalizedName = name.trim();
-      if (!normalizedName || normalizedName.length > MAX_SAVED_NAME_LENGTH) {
-        throw new Error(`Saved query name must be between 1 and ${MAX_SAVED_NAME_LENGTH} characters.`);
-      }
-      const items = saved.get(key) ?? [];
-      if (items.length >= MAX_SAVED_QUERIES) throw new Error(`At most ${MAX_SAVED_QUERIES} saved queries are allowed.`);
-      if (items.some((item2) => item2.name === normalizedName)) throw new Error(`Saved query "${normalizedName}" already exists.`);
-      const item = {
-        id: `${savedAt}-${Math.round((savedAt * 9301 + 49297) % 233280)}`,
-        name: normalizedName,
-        savedAt,
-        query: normalizeQueryState(query)
-      };
-      saved.set(key, [...items, item]);
-      return item;
-    },
-    async deleteSaved(key, id) {
-      saved.set(key, (saved.get(key) ?? []).filter((item) => item.id !== id));
-      if (defaults.get(key) === id) defaults.delete(key);
-    }
-  };
-}
-function localStorageAdapter() {
-  const ls = (() => {
-    try {
-      return typeof localStorage !== "undefined" ? localStorage : null;
-    } catch {
-      return null;
-    }
-  })();
-  const readSaved = (key) => {
-    if (!ls) return [];
-    try {
-      const raw = ls.getItem(SAVED_PREFIX + key);
-      return normalizeSavedQueries(raw ? JSON.parse(raw) : []);
-    } catch {
-      return [];
-    }
-  };
-  const writeSaved = (key, items) => {
-    if (ls) ls.setItem(SAVED_PREFIX + key, JSON.stringify(items));
-  };
-  const readDefaultId = (key) => {
-    if (!ls) return null;
-    return ls.getItem(DEFAULT_PREFIX + key);
-  };
-  const writeDefaultId = (key, id) => {
-    if (!ls) return;
-    if (id) ls.setItem(DEFAULT_PREFIX + key, id);
-    else ls.removeItem(DEFAULT_PREFIX + key);
-  };
-  return {
-    async loadLast(key) {
-      if (!ls) return null;
-      try {
-        const raw = ls.getItem(LAST_PREFIX + key);
-        return raw ? normalizeQueryState(JSON.parse(raw)) : null;
-      } catch {
-        return null;
-      }
-    },
-    async saveLast(key, query) {
-      if (ls) ls.setItem(LAST_PREFIX + key, JSON.stringify(normalizeQueryState(query)));
-    },
-    async listSaved(key) {
-      return readSaved(key).sort((a, b) => b.savedAt - a.savedAt);
-    },
-    async loadDefaultSaved(key) {
-      const id = readDefaultId(key);
-      if (!id) return null;
-      const found = readSaved(key).find((q) => q.id === id);
-      if (!found) writeDefaultId(key, null);
-      return found ?? null;
-    },
-    async setDefaultSaved(key, id) {
-      if (id && !readSaved(key).some((q) => q.id === id)) {
-        throw new Error(`Saved query "${id}" does not exist.`);
-      }
-      writeDefaultId(key, id);
-    },
-    async saveNamed(key, name, query, savedAt) {
-      const normalizedName = name.trim();
-      if (!normalizedName || normalizedName.length > MAX_SAVED_NAME_LENGTH) {
-        throw new Error(`Saved query name must be between 1 and ${MAX_SAVED_NAME_LENGTH} characters.`);
-      }
-      const items = readSaved(key);
-      if (items.length >= MAX_SAVED_QUERIES) throw new Error(`At most ${MAX_SAVED_QUERIES} saved queries are allowed.`);
-      if (items.some((q) => q.name === normalizedName)) {
-        throw new Error(`Saved query "${normalizedName}" already exists.`);
-      }
-      const item = {
-        id: `${savedAt}-${Math.round((savedAt * 9301 + 49297) % 233280)}`,
-        name: normalizedName,
-        savedAt,
-        query: normalizeQueryState(query)
-      };
-      items.push(item);
-      writeSaved(key, items);
-      return item;
-    },
-    async deleteSaved(key, id) {
-      writeSaved(
-        key,
-        readSaved(key).filter((q) => q.id !== id)
-      );
-      if (readDefaultId(key) === id) writeDefaultId(key, null);
-    }
-  };
+  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 });
+  return { where, aggregations, ...diagnostics.length ? { diagnostics } : {} };
 }
 
 // src/formula.ts
@@ -1551,7 +1336,7 @@ var FormulaError = class extends Error {
     this.to = to;
   }
 };
-function compileFormula(source, fields, resolve) {
+function compileFormula(source, fields, resolve, extension) {
   if (!source.trim() || source.length > 1e4)
     throw new FormulaError("Formula must contain 1\u201310,000 characters.");
   const tokens = [];
@@ -1752,6 +1537,8 @@ function compileFormula(source, fields, resolve) {
       n.valueType = t === "enum" ? "text" : t;
       return n.valueType;
     }
+    const extended = extension?.(n, (arg) => check(arg, level + 1));
+    if (extended !== void 0) return extended;
     const ts = n.args.map((a) => check(a, level + 1));
     const need = (index, t) => {
       if (ts[index] !== void 0 && ts[index] !== "null" && ts[index] !== t)
@@ -1852,7 +1639,7 @@ function compileFormula(source, fields, resolve) {
   const type = check(ast);
   return { ast, dependencies: [...deps].sort(), type };
 }
-function formulaRuntime(ast, inputs) {
+function formulaRuntime(ast, inputs, extension) {
   const fail = (s) => {
     throw new Error(s);
   };
@@ -1906,6 +1693,11 @@ function formulaRuntime(ast, inputs) {
       if (n.valueType === "textarray") return arr(v);
       return v;
     }
+    const extended = extension?.(n);
+    if (extended) {
+      if (extended.error) fail(extended.error);
+      return bound(extended.value);
+    }
     const name = n.name;
     const args = n.args;
     if (name === "IF") return run(run(args[0]) === true ? args[1] : args[2]);
@@ -2296,6 +2088,1552 @@ function formulaRuntime(ast, inputs) {
     };
   }
 }
+
+// src/execution.ts
+function toServerQueryV2(q, schema, execution) {
+  const normalized = normalizeQueryState(q), legacy = toServerQuery(normalized, schema);
+  const diagnostics = [];
+  const expectedRevisions = /* @__PURE__ */ Object.create(null);
+  const requireField = (name, operation) => {
+    const cap = execution.fields[name];
+    const revision = execution.resolvedRevisions[name] ?? execution.resolvedRevisions[name.slice("@computed/".length)];
+    if (!cap?.[operation] || !revision) {
+      diagnostics.push({
+        code: "unsupported_computed",
+        message: `Computed field ${name} is unavailable for ${operation}.`,
+        from: 0,
+        to: 1
+      });
+      return false;
+    }
+    return true;
+  };
+  for (const [key, value] of Object.entries(execution.resolvedRevisions)) {
+    if (key.length > 256 || typeof value !== "string" || !value || value.length > 256)
+      throw Error("Invalid computed revision envelope.");
+    expectedRevisions[key] = value;
+  }
+  const select = [...legacy.select];
+  for (const c of normalized.select.length ? normalized.select : selectedFields(schema, normalized).map((f2) => ({ field: f2.name })))
+    if (isComputedField(c.field) && requireField(c.field, "select"))
+      select.push(c.field);
+  const orderBy = [];
+  for (const term of normalized.orderBy.length ? normalized.orderBy : schema.defaultSort ?? []) {
+    if (isComputedField(term.field)) {
+      if (requireField(term.field, "sort")) {
+        if (term.dir !== "asc" && term.dir !== "desc" || term.extract) {
+          diagnostics.push({
+            code: "unsupported_computed_sort",
+            message: "Invalid computed sort or extraction.",
+            from: 0,
+            to: 1
+          });
+          continue;
+        }
+        orderBy.push({
+          field: term.field,
+          dir: term.dir,
+          ...term.nulls === "first" || term.nulls === "last" ? { nulls: term.nulls } : {}
+        });
+      }
+    } else {
+      const projected = toServerQuery(
+        { ...normalized, orderBy: [term] },
+        schema
+      ).orderBy;
+      if (!projected.length)
+        diagnostics.push({
+          code: "unsupported_sort",
+          message: `Unavailable server sort: ${term.field}.`,
+          from: 0,
+          to: 1
+        });
+      orderBy.push(...projected);
+    }
+  }
+  if (legacy.where.length !== normalized.where.length || q.where.reduce((n, t) => n + predicatesOf(t).length, 0) !== normalized.where.reduce((n, t) => n + predicatesOf(t).length, 0))
+    diagnostics.push({
+      code: "residual_filter",
+      message: "Global execution is unavailable with residual client-only filters.",
+      from: 0,
+      to: 1
+    });
+  return {
+    ...legacy,
+    select: [...new Set(select)].sort(),
+    orderBy,
+    version: 2,
+    profile: execution.profile,
+    expectedRevisions,
+    ...execution.planToken ? { planToken: execution.planToken } : {},
+    ...execution.snapshot !== void 0 ? { snapshot: execution.snapshot } : {},
+    diagnostics
+  };
+}
+
+// src/metricPrecision.ts
+function assertMetricNumber(value) {
+  if (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw Error("Aggregate exceeds finite safe numeric precision.");
+  }
+}
+function checkedMetricResult(result) {
+  if (result.error || typeof result.value !== "number") return result;
+  try {
+    assertMetricNumber(result.value);
+    return result;
+  } catch (e) {
+    return { value: null, error: e.message };
+  }
+}
+
+// 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",
+  "COUNT_DISTINCT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX"
+]);
+function compileMetric(expression, schema, resolve) {
+  const fields = Array.isArray(schema) ? schema : schema.fields;
+  const nodes = [];
+  const aggregateTypes = [];
+  let inAggregate = false;
+  const plan = compileFormula(
+    expression,
+    resolve ? fields.filter(
+      (f2) => f2.source.kind !== "derived" || !f2.source.computedId
+    ) : fields,
+    resolve,
+    (node, check) => {
+      if (node.kind !== "call" || !aggregates.has(node.name)) return void 0;
+      if (inAggregate)
+        throw new FormulaError(
+          "Nested aggregates are not allowed.",
+          node.from,
+          node.to
+        );
+      if (node.args.length > 1 || node.name !== "COUNT" && node.args.length !== 1)
+        throw new FormulaError(
+          `${node.name} requires ${node.name === "COUNT" ? "zero or one argument" : "one argument"}.`,
+          node.from,
+          node.to
+        );
+      inAggregate = true;
+      let type;
+      try {
+        type = node.args[0] ? check(node.args[0]) : "number";
+      } finally {
+        inAggregate = false;
+      }
+      const visit = (n) => {
+        if (n.kind === "field") {
+          const field = fields.find((f2) => f2.name === n.name);
+          if (!field)
+            throw new FormulaError(
+              `Unresolved dependency ${n.name}.`,
+              n.from,
+              n.to
+            );
+          if (!isMeasurable(field) || (field.aggregate?.ops !== void 0 || node.args[0] === n) && !aggOpsForField(field).includes(node.name.toLowerCase()))
+            throw new FormulaError(
+              `Field ${n.name} does not allow ${node.name}.`,
+              n.from,
+              n.to
+            );
+        } else if (n.kind === "call") {
+          if (aggregates.has(n.name))
+            throw new FormulaError(
+              "Nested aggregates are not allowed.",
+              n.from,
+              n.to
+            );
+          n.args.forEach(visit);
+        }
+      };
+      node.args.forEach(visit);
+      if (["SUM", "AVG"].includes(node.name) && !["number", "null"].includes(type))
+        throw new FormulaError(
+          `${node.name} requires numeric input.`,
+          node.from,
+          node.to
+        );
+      if (["MIN", "MAX", "COUNT_DISTINCT"].includes(node.name) && (type === "textarray" || type === "bool" && node.name !== "COUNT_DISTINCT"))
+        throw new FormulaError(
+          `Unsupported ${node.name} input type.`,
+          node.from,
+          node.to
+        );
+      nodes.push(node);
+      aggregateTypes.push(type);
+      return ["COUNT", "COUNT_DISTINCT", "SUM", "AVG"].includes(node.name) ? "number" : type;
+    }
+  );
+  const groupCheck = (node) => {
+    if (node.kind === "field")
+      throw new FormulaError(
+        "Row fields must be inside an aggregate.",
+        node.from,
+        node.to
+      );
+    if (node.kind === "call" && !aggregates.has(node.name)) {
+      if (node.name.startsWith("REGEX_"))
+        throw new FormulaError(
+          "Regex is supported only inside aggregate row expressions.",
+          node.from,
+          node.to
+        );
+      node.args.forEach(groupCheck);
+    }
+  };
+  groupCheck(plan.ast);
+  if (!nodes.length)
+    throw new FormulaError("A metric must contain an aggregate.");
+  if (plan.type === "textarray")
+    throw new FormulaError("Metrics must return scalar values.");
+  return { ...plan, aggregates: nodes, aggregateTypes };
+}
+function metricAggregatePlans(plan) {
+  return plan.aggregates.map((node) => {
+    if (!node.args[0]) return null;
+    const dependencies = /* @__PURE__ */ new Set();
+    const visit = (n) => {
+      if (n.kind === "field") dependencies.add(n.name);
+      else if (n.kind === "call") n.args.forEach(visit);
+    };
+    visit(node.args[0]);
+    return {
+      ast: node.args[0],
+      dependencies: [...dependencies].sort(),
+      type: plan.aggregateTypes[plan.aggregates.indexOf(node)]
+    };
+  });
+}
+function distinctAccumulator(options) {
+  const values = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  const cardinality = options.maxDistinctValues ?? 1e5;
+  const byteLimit = options.maxDistinctBytes ?? 16e6;
+  if (!Number.isSafeInteger(cardinality) || cardinality < 0 || !Number.isSafeInteger(byteLimit) || byteLimit < 0)
+    throw Error("Invalid distinct budget.");
+  return {
+    add(value) {
+      const v = scalar(value);
+      if (typeof v === "number") assertMetricNumber(v);
+      if (v === null || values.has(v)) return;
+      const size = 64 + (typeof v === "string" ? v.length * 2 : 8);
+      if (values.size >= cardinality || size > byteLimit - bytes)
+        throw Error("Metric distinct retained-memory budget exceeded.");
+      values.add(v);
+      bytes += size;
+    },
+    result: () => ({ value: values.size })
+  };
+}
+function reduceMetricValues(node, results, options = {}) {
+  return reduceResults(node, results, options);
+}
+function reduceResults(node, results, options) {
+  try {
+    if (!aggregates.has(node.name)) throw Error("Expected an aggregate node.");
+    const distinct = node.name === "COUNT_DISTINCT" ? distinctAccumulator(options) : void 0;
+    const values = [];
+    let count = 0, nonnull = 0, error;
+    for (const r of results) {
+      count++;
+      if (r.error) {
+        error ?? (error = r.error);
+        continue;
+      }
+      if (r.value === null) continue;
+      if (node.name !== "COUNT" && !distinct && typeof r.value === "number")
+        assertMetricNumber(r.value);
+      nonnull++;
+      if (distinct) distinct.add(r.value);
+      else if (node.name !== "COUNT") values.push(r.value);
+    }
+    if (error) return { value: null, error };
+    if (distinct) return distinct.result();
+    if (node.name === "COUNT")
+      return { value: node.args.length ? nonnull : count };
+    if (!values.length) return { value: null };
+    if (node.name === "SUM" || node.name === "AVG") {
+      let sum = 0;
+      for (const v of values) {
+        if (typeof v !== "number" || !Number.isFinite(v))
+          throw Error("Expected a finite number.");
+        sum += v / (node.name === "AVG" ? values.length : 1);
+        assertMetricNumber(sum);
+      }
+      return { value: sum };
+    }
+    return {
+      value: values.reduce(
+        (a, b) => compareMetricValues(scalar(a), scalar(b)) * (node.name === "MIN" ? 1 : -1) <= 0 ? a : b
+      )
+    };
+  } catch (e) {
+    return { value: null, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+function evaluateMetricReductions(plan, reductions) {
+  const key = (n) => `${n.from}:${n.to}:${n.kind === "call" ? n.name : n.kind}`;
+  const byNode = new Map(
+    plan.aggregates.map((n, i) => [key(n), reductions[i]])
+  );
+  return checkedMetricResult(
+    formulaRuntime(
+      plan.ast,
+      {},
+      (node) => byNode.has(key(node)) ? checkedMetricResult(
+        byNode.get(key(node)) ?? {
+          value: null,
+          error: "Missing aggregate reduction."
+        }
+      ) : void 0
+    )
+  );
+}
+function metricExpression(clause) {
+  return clause.expression ?? `${clause.op.toUpperCase()}(${clause.field ? `[${clause.field.replace(/]/g, "]]")}]` : ""})`;
+}
+function hasRegex(plan) {
+  const visit = (n) => n.kind === "call" && (n.name.startsWith("REGEX_") || n.args.some(visit));
+  return visit(plan.ast);
+}
+function distributionActive(c) {
+  return !!c.distribution && (!c.display || c.display.kind === "box" || c.display.kind === "histogram");
+}
+function metricPlans(c, schema, resolve) {
+  if (distributionActive(c)) {
+    const p = compileFormula(
+      c.distribution.input,
+      resolve ? schema.fields.filter(
+        (f2) => f2.source.kind !== "derived" || !f2.source.computedId
+      ) : schema.fields,
+      resolve
+    );
+    if (p.type !== "number" && p.type !== "null")
+      throw new FormulaError("Distribution input must be numeric.");
+    if (!["box", "histogram"].includes(c.distribution.kind))
+      throw new FormulaError("Invalid distribution kind.");
+    if (c.distribution.kind === "histogram" && (!Number.isInteger(c.distribution.bins ?? 10) || (c.distribution.bins ?? 10) < 2 || (c.distribution.bins ?? 10) > 30))
+      throw new FormulaError("Choose 2\u201330 histogram bins.");
+    for (const name of p.dependencies) {
+      const field = schema.fields.find((f2) => f2.name === name);
+      if (!isMeasurable(field))
+        throw new FormulaError(`Field ${name} cannot be a distribution input.`);
+    }
+    if (c.scope !== "shownRows" && hasRegex(p))
+      throw new FormulaError("Regex is unavailable for all-matching metrics.");
+    return [p];
+  }
+  const out = [
+    compileMetric(
+      metricExpression(
+        c.expression === void 0 && c.field ? { ...c, field: resolveFieldName(schema, c.field) ?? c.field } : c
+      ),
+      schema,
+      resolve
+    )
+  ];
+  if (c.display?.kind === "scatter") {
+    out.push(compileMetric(c.expressionY ?? "", schema, resolve));
+    if (out.some((p) => p.type !== "number" && p.type !== "null"))
+      throw new FormulaError("Scatter expressions must be numeric.");
+  }
+  if (c.scope !== "shownRows" && out.some(hasRegex))
+    throw new FormulaError("Regex is unavailable for all-matching metrics.");
+  return out;
+}
+function validateMetric(c, schema, resolve) {
+  try {
+    if (c.diagnostics?.length) throw new FormulaError(c.diagnostics.join(" "));
+    if (c.groupBy.length > 20)
+      throw new FormulaError("At most 20 grouping fields are allowed.");
+    for (const key of c.groupBy) {
+      const f2 = schema.fields.find(
+        (f3) => f3.name === (resolveFieldName(schema, key) ?? key)
+      );
+      if (!f2 || !isGroupable(f2))
+        throw new FormulaError(`Field ${key} cannot group metrics.`);
+    }
+    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.");
+    for (const s of c.sort ?? []) {
+      if (s.key === "y" && c.display?.kind !== "scatter")
+        throw new FormulaError("Y sorting requires a scatter metric.");
+      if (s.key === "samples" && !distributionActive(c))
+        throw new FormulaError(
+          "Sample sorting requires a distribution metric."
+        );
+      if (s.key.startsWith("group") && Number(s.key.slice(5)) >= c.groupBy.length)
+        throw new FormulaError("Sort refers to an unavailable grouping key.");
+    }
+    const compiled = metricPlans(c, schema, resolve);
+    if (c.scope !== "shownRows" && compiled.some(hasRegex))
+      throw new FormulaError("Regex is unavailable for all-matching metrics.");
+    return [];
+  } catch (e) {
+    return [
+      {
+        message: e instanceof Error ? e.message : String(e),
+        from: e instanceof FormulaError ? e.from : 0,
+        to: e instanceof FormulaError ? e.to : 1
+      }
+    ];
+  }
+}
+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)
+    ])
+  ].sort();
+}
+function metricComputationKey(clauses) {
+  return JSON.stringify(
+    clauses.map((c) => ({
+      id: c.id,
+      diagnostics: c.diagnostics,
+      unsupportedOp: c.unsupportedOp,
+      expression: distributionActive(c) ? void 0 : metricExpression(c),
+      expressionY: c.display?.kind === "scatter" ? c.expressionY : void 0,
+      scope: c.scope ?? "allMatching",
+      groupBy: c.groupBy,
+      sort: c.sort,
+      groupLimit: c.groupLimit,
+      distribution: distributionActive(c) ? c.distribution : void 0
+    })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  );
+}
+function toMetricQuery(q, schema, execution) {
+  const originalSchema = schema;
+  const fields = new Map(schema.fields.map((f2) => [f2.name, f2]));
+  for (const [name, prior] of fields)
+    if (isComputedField(name))
+      fields.set(name, {
+        ...prior,
+        aggregate: { measure: false, groupable: false }
+      });
+  for (const [name, cap] of Object.entries(execution?.fields ?? {}))
+    if (isComputedField(name)) {
+      const prior = fields.get(name);
+      fields.set(name, {
+        ...prior,
+        name,
+        label: prior?.label ?? name,
+        type: cap.type,
+        source: { kind: "backend" },
+        filter: { enabled: false },
+        sort: { enabled: cap.sort },
+        aggregate: {
+          ...prior?.aggregate,
+          measure: cap.measure,
+          groupable: cap.group
+        }
+      });
+    }
+  schema = { ...schema, fields: [...fields.values()] };
+  const raw = q;
+  q = normalizeQueryState(q);
+  const server = toServerQuery(q, schema);
+  const metrics = (q.aggregations ?? []).map((c) => {
+    const {
+      label,
+      layout,
+      display,
+      distribution,
+      expression,
+      expressionY,
+      ...rest
+    } = c;
+    return {
+      ...rest,
+      ...!distributionActive(c) && expression !== void 0 ? { expression } : {},
+      ...display?.kind === "scatter" ? {
+        display: { kind: "scatter" },
+        ...expressionY !== void 0 ? { expressionY } : {}
+      } : {},
+      ...distributionActive(c) && distribution ? { distribution } : {}
+    };
+  });
+  const diagnostics = (q.aggregations ?? []).flatMap(
+    (c) => validateMetric(c, schema).map((d) => ({
+      ...d,
+      metricId: c.id,
+      code: "invalid_metric"
+    }))
+  );
+  try {
+    assertMetricQueryState(raw, originalSchema);
+  } catch (e) {
+    diagnostics.push({
+      message: String(e),
+      from: 0,
+      to: 1,
+      metricId: "",
+      code: "invalid_query"
+    });
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const c of q.aggregations ?? []) {
+    if (ids.has(c.id))
+      diagnostics.push({
+        message: "Duplicate metric ID.",
+        from: 0,
+        to: 1,
+        metricId: c.id,
+        code: "duplicate_metric"
+      });
+    ids.add(c.id);
+  }
+  if (server.where.length !== q.where.length || queryStateKey(raw.where) !== queryStateKey(q.where))
+    diagnostics.push({
+      message: "Metrics unavailable with residual client-only filters.",
+      from: 0,
+      to: 1,
+      metricId: "",
+      code: "residual_filter"
+    });
+  for (const c of q.aggregations ?? []) {
+    try {
+      for (const name of metricDependencies(c, schema))
+        if (isComputedField(name)) {
+          const revision = execution?.resolvedRevisions[name] ?? execution?.resolvedRevisions[name.slice("@computed/".length)];
+          if (typeof revision !== "string" || !revision || revision.length > 256)
+            diagnostics.push({
+              metricId: c.id,
+              code: "definition_revision",
+              message: `Missing expected revision for ${name}.`,
+              from: 0,
+              to: 1
+            });
+          if (!execution?.fields[name])
+            diagnostics.push({
+              metricId: c.id,
+              code: "unsupported_computed",
+              message: `Missing server capability for ${name}.`,
+              from: 0,
+              to: 1
+            });
+        }
+    } catch {
+    }
+  }
+  const rowProjection = toServerQueryV2(
+    { ...q, select: [{ field: schema.idField }] },
+    originalSchema,
+    execution ?? {
+      profile: "",
+      planToken: "",
+      fields: {},
+      resolvedRevisions: {}
+    }
+  );
+  if (q.aggregations?.some((c) => c.scope === "shownRows"))
+    diagnostics.push(
+      ...rowProjection.diagnostics.map((d) => ({
+        ...d,
+        metricId: "",
+        code: d.code ?? "residual_order"
+      }))
+    );
+  return {
+    version: 2,
+    where: server.where,
+    orderBy: rowProjection.orderBy,
+    limit: q.limit,
+    offset: q.offset,
+    metrics,
+    diagnostics,
+    ...execution ? {
+      profile: execution.profile,
+      expectedRevisions: { ...execution.resolvedRevisions },
+      planToken: execution.planToken,
+      ...execution.snapshot !== void 0 ? { snapshot: execution.snapshot } : {}
+    } : {}
+  };
+}
+function queryStateKey(value) {
+  return JSON.stringify(
+    value,
+    (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(
+      Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+    ) : item
+  );
+}
+function assertMetricQueryState(q, schema) {
+  const normalized = normalizeQueryState(q);
+  if ((q.aggregations?.length ?? 0) !== (normalized.aggregations?.length ?? 0))
+    throw Error("Malformed metric definitions cannot be dropped.");
+  const orderBy = q.orderBy.length ? q.orderBy : schema.defaultSort ?? [];
+  const normalizedOrder = normalizeQueryState({ ...q, orderBy }).orderBy;
+  if (queryStateKey(q.where) !== queryStateKey(normalized.where) || queryStateKey(orderBy) !== queryStateKey(normalizedOrder) || q.limit !== normalized.limit || q.offset !== normalized.offset)
+    throw Error("Malformed metric query state cannot be executed exactly.");
+}
+function selectMetricShownRows(rows, q, schema, options = {}) {
+  if (options.signal?.aborted) throw Error("Metric evaluation cancelled.");
+  assertMetricQueryState(q, schema);
+  if (options.shownRows) return options.shownRows;
+  const orderBy = q.orderBy.length ? q.orderBy : schema.defaultSort ?? [];
+  assertMetricPopulation(q, schema, orderBy);
+  if (rows.length > (options.maxRows ?? 1e6))
+    throw Error("Metric row budget exceeded.");
+  if ((options.maxOperations ?? 1e7) <= 0)
+    throw Error("Metric operation budget exceeded.");
+  return applyQuery(
+    rows,
+    {
+      ...q,
+      orderBy: orderBy.some((s) => s.field === schema.idField) ? orderBy : [...orderBy, { field: schema.idField, dir: "asc" }]
+    },
+    schema,
+    options
+  ).rows;
+}
+function assertMetricPopulation(q, schema, orderBy) {
+  const fields = indexFields(schema);
+  if (q.where.some(
+    (t) => predicatesOf(t).some(
+      (p) => p.op === "matches_regex" || p.op === "not_matches_regex"
+    )
+  ) || orderBy.some((s) => s.extract !== void 0))
+    throw Error(
+      "Query regex requires isolated execution; unavailable for metric population selection."
+    );
+  if (q.where.some(
+    (t) => predicatesOf(t).some(
+      (p) => isComputedField(p.field) || !fields.has(resolveFieldName(schema, p.field) ?? p.field)
+    )
+  ))
+    throw Error("Metric filter references an unavailable field.");
+  if (orderBy.some(
+    (s) => isComputedField(s.field) || !fields.has(resolveFieldName(schema, s.field) ?? s.field)
+  ))
+    throw Error("Shown-row ordering requires an authoritative committed page.");
+}
+var scalar = (v) => {
+  if (v instanceof Date) return v.toISOString();
+  if (v == null) return null;
+  if (typeof v === "string" || typeof v === "boolean" || typeof v === "number" && Number.isFinite(v))
+    return v;
+  throw Error("Metric keys and values must be finite scalars.");
+};
+function groupStringLength(value, limit) {
+  let length = value.length + 2;
+  if (length > limit)
+    throw Error("Metric grouping key length budget exceeded.");
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code === 34 || code === 92 || code === 8 || code === 9 || code === 10 || code === 12 || code === 13)
+      length++;
+    else if (code < 32) length += 5;
+    else if (code >= 55296 && code <= 56319 && i + 1 < value.length && value.charCodeAt(i + 1) >= 56320 && value.charCodeAt(i + 1) <= 57343)
+      i++;
+    else if (code >= 55296 && code <= 57343) length += 5;
+    if (length > limit)
+      throw Error("Metric grouping key length budget exceeded.");
+  }
+  return length;
+}
+function compareMetricValues(a, b) {
+  if (a === b) return 0;
+  if (a === null) return 1;
+  if (b === null) return -1;
+  if (typeof a !== typeof b) return typeof a < typeof b ? -1 : 1;
+  if (typeof a === "string" && typeof b === "string") {
+    const ac = Array.from(a), bc = Array.from(b);
+    for (let i = 0; i < Math.min(ac.length, bc.length); i++) {
+      const diff = ac[i].codePointAt(0) - bc[i].codePointAt(0);
+      if (diff) return Math.sign(diff);
+    }
+    return Math.sign(ac.length - bc.length);
+  }
+  return a < b ? -1 : 1;
+}
+function evaluateMetrics(rows, q, schema, options = {}) {
+  const now = evaluationTime(options), fields = indexFields(schema);
+  let matching;
+  let shown;
+  return {
+    metrics: (q.aggregations ?? []).map((c) => {
+      let budget = options.maxOperations ?? 1e7;
+      const tick = () => {
+        if (--budget < 0) throw Error("Metric operation budget exceeded.");
+        if (options.signal?.aborted)
+          throw Error("Metric evaluation cancelled.");
+      };
+      try {
+        if (options.signal?.aborted)
+          throw Error("Metric evaluation cancelled.");
+        assertMetricQueryState(q, schema);
+        if ((q.aggregations?.length ?? 0) > 20)
+          throw Error("At most 20 metrics are allowed.");
+        const diagnostics = validateMetric(c, schema, options.resolveComputed);
+        if (diagnostics.length)
+          throw Error(diagnostics.map((d) => d.message).join(" "));
+        const ps = metricPlans(c, schema, options.resolveComputed);
+        if (ps.some(hasRegex) && !options.evaluateInput)
+          throw Error(
+            "Regex metrics require an isolated worker with a watchdog."
+          );
+        let inputRows;
+        if (c.scope === "shownRows")
+          inputRows = shown ?? (shown = selectMetricShownRows(rows, q, schema, options));
+        else {
+          if (!matching) {
+            assertMetricPopulation(q, schema, []);
+            if (rows.length > (options.maxRows ?? 1e6))
+              throw Error("Metric row budget exceeded.");
+            matching = applyQuery(
+              rows,
+              { ...q, orderBy: [], offset: 0, limit: Number.MAX_SAFE_INTEGER },
+              schema,
+              { now }
+            ).rows;
+          }
+          inputRows = matching;
+        }
+        if (inputRows.length > (options.maxRows ?? 1e6))
+          throw Error("Metric row budget exceeded.");
+        const groups = /* @__PURE__ */ new Map();
+        const keyLimit = options.maxGroupKeyLength ?? 65536, byteLimit = options.maxGroupBytes ?? 16e6;
+        if (![keyLimit, byteLimit].every((v) => Number.isSafeInteger(v) && v >= 0))
+          throw Error("Invalid grouping budget.");
+        let groupBytes = 0;
+        const reserve = (bytes) => {
+          if (bytes > byteLimit - groupBytes)
+            throw Error("Metric grouping retained-memory budget exceeded.");
+        };
+        if (!c.groupBy.length) {
+          if (keyLimit < 2)
+            throw Error("Metric grouping key length budget exceeded.");
+          reserve(256);
+          groupBytes = 256;
+          groups.set("[]", { keys: [], rows: [] });
+        }
+        for (const row of inputRows) {
+          tick();
+          if (!c.groupBy.length) {
+            reserve(16);
+            groupBytes += 16;
+            groups.get("[]").rows.push(row);
+            continue;
+          }
+          const keys = c.groupBy.map(
+            (k) => scalar(
+              readFieldValue(
+                fields.get(resolveFieldName(schema, k) ?? k),
+                row
+              )
+            )
+          );
+          let keyLength = 1, payloadBytes = 0;
+          for (const value of keys) {
+            keyLength += 1 + (typeof value === "string" ? groupStringLength(value, keyLimit - keyLength - 1) : value === null ? 4 : typeof value === "boolean" ? value ? 4 : 5 : String(value).length);
+            payloadBytes += typeof value === "string" ? 2 * value.length : 8;
+            if (keyLength > keyLimit)
+              throw Error("Metric grouping key length budget exceeded.");
+          }
+          const retainedBytes = 256 + 16 * keys.length + payloadBytes + 2 * keyLength;
+          reserve(retainedBytes + 2 * keyLength + 16);
+          const key = JSON.stringify(keys);
+          let g = groups.get(key);
+          if (!g) {
+            if (groups.size >= (options.maxGroups ?? 1e4))
+              throw Error("Metric group budget exceeded.");
+            g = { keys, rows: [] };
+            groups.set(key, g);
+            groupBytes += retainedBytes;
+          }
+          groupBytes += 16;
+          g.rows.push(row);
+        }
+        const inputs = (row, p) => Object.fromEntries(
+          p.dependencies.map((name) => [
+            name,
+            (() => {
+              const value = readFieldValue(fields.get(name), row);
+              return value instanceof Date ? value.toISOString() : value ?? null;
+            })()
+          ])
+        );
+        const nodeCosts = /* @__PURE__ */ new Map();
+        const cost = (n) => {
+          const known = nodeCosts.get(n);
+          if (known !== void 0) return known;
+          const value = 1 + (n.kind === "call" ? n.args.reduce((s, a) => s + cost(a), 0) : 0);
+          nodeCosts.set(n, value);
+          return value;
+        };
+        const rowEval = (node, row, p) => {
+          budget -= cost(node);
+          tick();
+          return options.evaluateInput && hasRegex({ ...p, ast: node }) ? options.evaluateInput(node, row, p) : formulaRuntime(node, inputs(row, p));
+        };
+        const reduce = (p, rs, inputErrors) => {
+          const cache = /* @__PURE__ */ new Map();
+          return checkedMetricResult(
+            formulaRuntime(p.ast, {}, (node) => {
+              if (!aggregates.has(node.name)) return void 0;
+              if (cache.has(node)) return cache.get(node);
+              let result;
+              try {
+                function* results() {
+                  for (let i = 0; i < rs.length; i++) {
+                    tick();
+                    const v = node.args[0] ? rowEval(node.args[0], rs[i], p) : { value: 1 };
+                    if (v.error) inputErrors.add(i);
+                    yield v;
+                  }
+                }
+                result = reduceResults(node, results(), options);
+              } catch (e) {
+                result = {
+                  value: null,
+                  error: e instanceof Error ? e.message : String(e)
+                };
+              }
+              cache.set(node, result);
+              return result;
+            })
+          );
+        };
+        const populations = /* @__PURE__ */ new Map();
+        let buckets = [...groups.values()].map((g) => {
+          const bucket = {
+            keys: g.keys,
+            count: g.rows.length,
+            value: null
+          };
+          if (distributionActive(c)) {
+            const values = [];
+            bucket.nullCount = 0;
+            bucket.inputErrorCount = 0;
+            for (const row of g.rows) {
+              const r = checkedMetricResult(rowEval(ps[0].ast, row, ps[0]));
+              if (r.error) {
+                bucket.inputErrorCount++;
+                bucket.error = r.error;
+              } else if (r.value === null) bucket.nullCount++;
+              else values.push(Number(r.value));
+            }
+            populations.set(bucket, values);
+          } else {
+            const inputErrors = /* @__PURE__ */ new Set();
+            const x = reduce(ps[0], g.rows, inputErrors);
+            bucket.value = scalar(x.value);
+            if (x.error) bucket.error = x.error;
+            if (ps[1]) {
+              const y = reduce(ps[1], g.rows, inputErrors);
+              bucket.y = scalar(y.value);
+              if (y.error) bucket.yError = y.error;
+            }
+            if (inputErrors.size) bucket.inputErrorCount = inputErrors.size;
+          }
+          return bucket;
+        });
+        if (distributionActive(c)) {
+          const d = c.distribution;
+          if (d.kind === "histogram" && buckets.some((b) => b.error))
+            throw Error(
+              "Histogram input errors prevent an exact shared extent."
+            );
+          const all = [];
+          for (const values of populations.values())
+            for (const v of values) all.push(v);
+          const edges = d.kind === "histogram" ? histogramEdges(all, d.bins ?? 10) : [];
+          for (const b of buckets) {
+            const vs = populations.get(b);
+            if (b.error) continue;
+            if (d.kind === "box") {
+              const summary = boxSummary(vs, d.whiskers);
+              b.distribution = { kind: "box", summary };
+              b.value = summary?.median ?? null;
+            } else {
+              b.distribution = {
+                kind: "histogram",
+                edges: [...edges],
+                counts: histogramCounts(vs, edges),
+                n: vs.length
+              };
+              b.value = vs.length;
+            }
+          }
+        }
+        const ordering = c.sort?.length ? c.sort : [{ key: "value", dir: "desc", nulls: "last" }];
+        const target = (b, s) => s.key === "samples" ? b.count - (b.nullCount ?? 0) - (b.inputErrorCount ?? 0) : s.key.startsWith("group") ? b.keys[Number(s.key.slice(5))] ?? null : s.key === "count" ? b.count : s.key === "y" ? b.y ?? null : b.value;
+        buckets.sort((a, b) => {
+          if (!!(a.error || a.yError) !== !!(b.error || b.yError))
+            return a.error || a.yError ? 1 : -1;
+          for (const s of ordering) {
+            const av = target(a, s), bv = target(b, s);
+            const cmp = av === null || bv === null ? av === bv ? 0 : (av === null ? 1 : -1) * (s.nulls === "first" ? -1 : 1) : compareMetricValues(av, bv) * (s.dir === "asc" ? 1 : -1);
+            if (cmp) return cmp;
+          }
+          for (let i = 0; i < a.keys.length; i++) {
+            const cmp = compareMetricValues(a.keys[i], b.keys[i]);
+            if (cmp) return cmp;
+          }
+          return 0;
+        });
+        tick();
+        const groupCount = buckets.length;
+        let other;
+        if (c.groupLimit && buckets.length > c.groupLimit) {
+          const omitted = buckets.slice(c.groupLimit), ast = ps[0].ast;
+          if (!distributionActive(c) && ast.kind === "call" && ["SUM", "COUNT"].includes(ast.name) && omitted.every(
+            (b) => !b.error && (typeof b.value === "number" || ast.name === "SUM" && b.value === null)
+          )) {
+            const value = omitted.reduce((s, b) => s + Number(b.value), 0);
+            if (Number.isFinite(value) && (!Number.isInteger(value) || Number.isSafeInteger(value)))
+              other = {
+                keys: [],
+                value,
+                count: omitted.reduce((s, b) => s + b.count, 0)
+              };
+          }
+          buckets = buckets.slice(0, c.groupLimit);
+        }
+        return {
+          id: c.id,
+          buckets,
+          scope: c.scope ?? "allMatching",
+          processedRows: inputRows.length,
+          groupCount,
+          coverage: "exact",
+          ...other ? { other } : {}
+        };
+      } catch (e) {
+        return {
+          id: c.id,
+          buckets: [],
+          error: e instanceof Error ? e.message : String(e)
+        };
+      }
+    })
+  };
+}
+
+// src/apply.ts
+function applyQuery(rows, q, schema, options = {}) {
+  const now = evaluationTime(options);
+  const byName = indexFields(schema);
+  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
+  const whereTerms = q.where.filter((term) => !predicatesOf(term).some((c) => isComputedField(c.field))).map((term) => prepareWhereTerm(term, resolveField2, now));
+  prepareDatetimePredicates(whereTerms, byName);
+  const orderBy = q.orderBy.filter((term) => !isComputedField(term.field)).map((term) => ({ ...term, field: resolveField2(term.field) }));
+  let out = rows.filter(
+    (row) => whereTerms.every((term) => matchesTerm(byName, row, term))
+  );
+  const total = out.length;
+  if (orderBy.length) {
+    const terms = orderBy.map((t) => ({
+      field: byName.get(t.field),
+      dir: t.dir,
+      nullsLast: (t.nulls ?? "last") === "last",
+      extract: compileRegex(t.extract?.regex)
+    })).filter(
+      (t) => t.field != null
+    );
+    out = [...out].sort((a, b) => {
+      for (const t of terms) {
+        const av = extractSortValue(readFieldValue(t.field, a), t.extract);
+        const bv = extractSortValue(readFieldValue(t.field, b), t.extract);
+        const aNull = av == null;
+        const bNull = bv == null;
+        if (aNull || bNull) {
+          if (aNull && bNull) continue;
+          return (aNull ? 1 : -1) * (t.nullsLast ? 1 : -1);
+        }
+        const cmp = compare(av, bv);
+        if (cmp !== 0) return t.dir === "asc" ? cmp : -cmp;
+      }
+      return 0;
+    });
+  }
+  const start = q.offset > 0 ? q.offset : 0;
+  const end = q.limit > 0 ? start + q.limit : out.length;
+  return { rows: out.slice(start, end), total };
+}
+function matchesClause(row, clause, schema, options = {}) {
+  const field = resolveFieldName(schema, clause.field) ?? clause.field;
+  const byName = indexFields(schema);
+  const prepared = prepareWhereClause(
+    { ...clause, field },
+    evaluationTime(options)
+  );
+  prepareDatetimePredicates([{ kind: "lit", predicate: prepared }], byName);
+  return matchesWith(byName, row, prepared);
+}
+function applyAggregations(rows, q, schema, options = {}) {
+  if (options.signal?.aborted || q.where.some(
+    (t) => predicatesOf(t).some(
+      (p) => p.op === "matches_regex" || p.op === "not_matches_regex"
+    )
+  ))
+    return evaluateMetrics(rows, q, schema, options);
+  const advanced = (q.aggregations ?? []).filter(
+    (a) => a.diagnostics?.length || a.expression !== void 0 || a.expressionY !== void 0 || a.scope !== void 0 || a.distribution || a.sort || a.groupLimit !== void 0
+  );
+  if (advanced.length) {
+    if ((q.aggregations?.length ?? 0) > 20 || normalizeQueryState(q).aggregations?.length !== q.aggregations?.length)
+      return evaluateMetrics(rows, q, schema, options);
+    const legacy = (q.aggregations ?? []).filter((a) => !advanced.includes(a));
+    const results = [
+      ...evaluateMetrics(
+        rows,
+        { ...q, aggregations: advanced },
+        schema,
+        options
+      ).metrics,
+      ...legacy.length ? applyAggregations(
+        rows,
+        { ...q, aggregations: legacy },
+        schema,
+        options
+      ).metrics : []
+    ];
+    const byId = new Map(results.map((result) => [result.id, result]));
+    return {
+      metrics: (q.aggregations ?? []).flatMap((a) => byId.get(a.id) ?? [])
+    };
+  }
+  const now = evaluationTime(options);
+  const byName = indexFields(schema);
+  const resolveField2 = (name) => resolveFieldName(schema, name) ?? name;
+  const whereTerms = q.where.filter((term) => !predicatesOf(term).some((c) => isComputedField(c.field))).map((term) => prepareWhereTerm(term, resolveField2, now));
+  prepareDatetimePredicates(whereTerms, byName);
+  const filtered = rows.filter(
+    (row) => whereTerms.every((term) => matchesTerm(byName, row, term))
+  );
+  const metrics = (q.aggregations ?? []).filter(
+    (a) => !isComputedField(a.field ?? "") && !a.groupBy.some(isComputedField)
+  ).map((agg) => {
+    const field = agg.field ? byName.get(resolveField2(agg.field)) : void 0;
+    if (field && (!isMeasurable(field) || !aggOpsForField(field).includes(agg.op)))
+      return {
+        id: agg.id,
+        buckets: [],
+        error: `Field ${field.name} does not allow ${agg.op}.`
+      };
+    return {
+      id: agg.id,
+      buckets: computeBuckets(filtered, agg, byName, resolveField2)
+    };
+  });
+  return { metrics };
+}
+function computeBuckets(rows, agg, byName, resolveField2) {
+  const groupFields = agg.groupBy.map((n) => byName.get(resolveField2(n)));
+  const measure = agg.field ? byName.get(resolveField2(agg.field)) : void 0;
+  const groups = /* @__PURE__ */ new Map();
+  if (!agg.groupBy.length) groups.set("[]", { keys: [], rows: [] });
+  for (const row of rows) {
+    const keys = groupFields.map((f2) => {
+      if (!f2) return null;
+      const v = readFieldValue(f2, row);
+      return v == null || v === "" ? null : typeof v === "number" || typeof v === "boolean" || typeof v === "string" ? v : String(v);
+    });
+    const k = JSON.stringify(keys);
+    let g = groups.get(k);
+    if (!g) {
+      g = { keys, rows: [] };
+      groups.set(k, g);
+    }
+    g.rows.push(row);
+  }
+  const buckets = [...groups.values()].map((g) => ({
+    keys: g.keys,
+    count: g.rows.length,
+    value: aggValue(agg.op, measure, g.rows)
+  }));
+  return sortBuckets(buckets);
+}
+function aggValue(op, measure, rows) {
+  if (op === "count") {
+    if (!measure) return rows.length;
+    let n = 0;
+    for (const r of rows) if (readFieldValue(measure, r) != null) n++;
+    return n;
+  }
+  if (!measure) return null;
+  const values = rows.map((r) => readFieldValue(measure, r)).filter((v) => v != null);
+  switch (op) {
+    case "count_distinct":
+      return new Set(values.map((v) => String(v))).size;
+    case "sum":
+    case "avg": {
+      let sum = 0;
+      let n = 0;
+      for (const v of values) {
+        const num = typeof v === "number" ? v : Number(v);
+        if (Number.isFinite(num)) {
+          sum += num;
+          n++;
+        }
+      }
+      if (op === "avg") return n ? sum / n : null;
+      return n ? sum : null;
+    }
+    case "min":
+    case "max": {
+      let best;
+      for (const v of values) {
+        if (best === void 0) {
+          best = v;
+          continue;
+        }
+        const cmp = compare(v, best);
+        if (op === "min" ? cmp < 0 : cmp > 0) best = v;
+      }
+      return best ?? null;
+    }
+    default:
+      return null;
+  }
+}
+function sortBuckets(buckets) {
+  return [...buckets].sort((a, b) => {
+    const av = typeof a.value === "number" ? a.value : a.count;
+    const bv = typeof b.value === "number" ? b.value : b.count;
+    if (av !== bv) return bv - av;
+    return JSON.stringify(a.keys).localeCompare(JSON.stringify(b.keys));
+  });
+}
+function prepareWhereClause(clause, now) {
+  const usesRegex = clause.op === "matches_regex" || clause.op === "not_matches_regex";
+  return {
+    clause,
+    now,
+    regex: usesRegex ? compileRegex(clause.value) : void 0
+  };
+}
+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
+    )
+  };
+}
+function prepareDatetimePredicates(terms, fields) {
+  for (const term of terms)
+    for (const p of term.kind === "lit" ? [term.predicate] : term.predicates) {
+      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;
+      p.datetime = coerceValue("datetime", p.clause.value, p.now);
+    }
+}
+function matchesTerm(byName, row, term) {
+  if (term.kind === "lit") return matchesWith(byName, row, term.predicate);
+  return term.predicates.some((p) => matchesWith(byName, row, p));
+}
+function matchesWith(byName, row, prepared) {
+  const { clause } = prepared;
+  const field = byName.get(clause.field);
+  if (!field) return true;
+  const v = readFieldValue(field, row);
+  if (clause.value === "" && clause.op !== "=" && clause.op !== "!=" && clause.op !== "is_null" && clause.op !== "is_not_null") {
+    return true;
+  }
+  if (clause.op === "length_gt" || clause.op === "length_lt" || clause.op === "length_eq") {
+    if (!/^(0|[1-9]\d*)$/.test(clause.value) || !Number.isSafeInteger(Number(clause.value)))
+      return false;
+  }
+  let base;
+  if (prepared.datetime !== void 0) {
+    const timestamp = v instanceof Date ? v.getTime() : typeof v === "number" ? v : typeof v === "string" ? Date.parse(v) : NaN;
+    if (v === "" || !Number.isFinite(timestamp)) return false;
+    base = matchesDatetime(timestamp, prepared.datetime, clause.op);
+  } else {
+    base = matchesBase(field, v, prepared);
+  }
+  if (!clause.negated) return base;
+  const isNull = Array.isArray(v) ? v.length === 0 : v == null || v === "";
+  return !isNull && !base;
+}
+function matchesDatetime(timestamp, rhs, op) {
+  switch (op) {
+    case "=":
+      return timestamp === rhs;
+    case "!=":
+      return timestamp !== rhs;
+    case ">":
+      return timestamp > rhs;
+    case ">=":
+      return timestamp >= rhs;
+    case "<":
+      return timestamp < rhs;
+    case "<=":
+      return timestamp <= rhs;
+    default:
+      return false;
+  }
+}
+function matchesBase(field, v, prepared) {
+  const { clause, regex } = prepared;
+  if (clause.op === "is_null")
+    return Array.isArray(v) ? v.length === 0 : v == null || v === "";
+  if (clause.op === "is_not_null")
+    return Array.isArray(v) ? v.length > 0 : v != null && v !== "";
+  const arrayText = (value) => field.filter?.arrayCaseSensitive ? String(value) : String(value).toLowerCase();
+  if (clause.op === "includes") {
+    const arr = Array.isArray(v) ? v : [];
+    const needle = arrayText(clause.value);
+    return arr.some((x) => arrayText(x) === needle);
+  }
+  if (clause.op === "matches_regex" || clause.op === "not_matches_regex") {
+    if (v == null || Array.isArray(v)) return false;
+    if (!regex) return false;
+    const matches = regex.test(String(v));
+    return clause.op === "matches_regex" ? matches : !matches;
+  }
+  if (clause.op === "length_gt" || clause.op === "length_lt" || clause.op === "length_eq") {
+    if (typeof v !== "string" || !/^(0|[1-9]\d*)$/.test(clause.value))
+      return false;
+    const limit = Number(clause.value);
+    if (!Number.isSafeInteger(limit)) return false;
+    const length = Array.from(v).length;
+    return clause.op === "length_gt" ? length > limit : clause.op === "length_lt" ? length < limit : length === limit;
+  }
+  if (Array.isArray(v)) {
+    const needle = arrayText(clause.value);
+    const hay = v.map(arrayText);
+    switch (clause.op) {
+      case "contains":
+        return hay.some((s) => s.includes(needle));
+      case "=":
+        return hay.includes(needle);
+      case "!=":
+        return !hay.includes(needle);
+      default:
+        return true;
+    }
+  }
+  switch (clause.op) {
+    case "=":
+      return String(v ?? "") === String(coerceSafe(field, clause.value));
+    case "!=":
+      return String(v ?? "") !== String(coerceSafe(field, clause.value));
+    case ">":
+      return compare(v, coerceSafe(field, clause.value)) > 0;
+    case ">=":
+      return compare(v, coerceSafe(field, clause.value)) >= 0;
+    case "<":
+      return compare(v, coerceSafe(field, clause.value)) < 0;
+    case "<=":
+      return compare(v, coerceSafe(field, clause.value)) <= 0;
+    case "contains":
+      return String(v ?? "").toLowerCase().includes(clause.value.toLowerCase());
+    case "starts_with":
+      return String(v ?? "").toLowerCase().startsWith(clause.value.toLowerCase());
+    case "ends_with":
+      return String(v ?? "").toLowerCase().endsWith(clause.value.toLowerCase());
+    default:
+      return true;
+  }
+}
+function compileRegex(pattern) {
+  if (pattern === void 0) return void 0;
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return null;
+  }
+}
+function extractSortValue(value, regex) {
+  if (regex === void 0) return value;
+  if (regex === null || value == null) return null;
+  const match = regex.exec(String(value));
+  if (!match) return null;
+  return match.length > 1 ? match[1] ?? null : match[0];
+}
+function coerceSafe(field, raw) {
+  try {
+    return coerceValue(field.type, raw);
+  } catch {
+    return raw;
+  }
+}
+function compare(a, b) {
+  if (a == null && b == null) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "boolean" && typeof b === "boolean")
+    return a === b ? 0 : a ? 1 : -1;
+  return String(a).localeCompare(String(b));
+}
+
+// src/adapters.ts
+var LAST_PREFIX = "query-table:last:";
+var SAVED_PREFIX = "query-table:saved:";
+var DEFAULT_PREFIX = "query-table:default:";
+var MAX_SAVED_QUERIES = 100;
+var MAX_SAVED_NAME_LENGTH = 200;
+function normalizeSavedQuery(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.id !== "string" || !raw.id || raw.id.length > 256 || typeof raw.name !== "string" || !raw.name || raw.name.length > MAX_SAVED_NAME_LENGTH || typeof raw.savedAt !== "number" || !Number.isFinite(raw.savedAt) || raw.query == null || typeof raw.query !== "object") {
+    return null;
+  }
+  return { id: raw.id, name: raw.name, savedAt: raw.savedAt, query: normalizeQueryState(raw.query) };
+}
+function normalizeSavedQueries(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, MAX_SAVED_QUERIES).map(normalizeSavedQuery).filter((item) => item != null);
+}
+function memoryStorageAdapter() {
+  const last = /* @__PURE__ */ new Map();
+  const saved = /* @__PURE__ */ new Map();
+  const defaults = /* @__PURE__ */ new Map();
+  return {
+    async loadLast(key) {
+      const query = last.get(key);
+      return query ? normalizeQueryState(query) : null;
+    },
+    async saveLast(key, query) {
+      last.set(key, normalizeQueryState(query));
+    },
+    async listSaved(key) {
+      return (saved.get(key) ?? []).map((item) => ({ ...item, query: normalizeQueryState(item.query) }));
+    },
+    async loadDefaultSaved(key) {
+      const id = defaults.get(key);
+      return id ? (saved.get(key) ?? []).find((item) => item.id === id) ?? null : null;
+    },
+    async setDefaultSaved(key, id) {
+      if (id == null) {
+        defaults.delete(key);
+        return;
+      }
+      if (!(saved.get(key) ?? []).some((item) => item.id === id)) throw new Error(`Saved query "${id}" does not exist.`);
+      defaults.set(key, id);
+    },
+    async saveNamed(key, name, query, savedAt) {
+      const normalizedName = name.trim();
+      if (!normalizedName || normalizedName.length > MAX_SAVED_NAME_LENGTH) {
+        throw new Error(`Saved query name must be between 1 and ${MAX_SAVED_NAME_LENGTH} characters.`);
+      }
+      const items = saved.get(key) ?? [];
+      if (items.length >= MAX_SAVED_QUERIES) throw new Error(`At most ${MAX_SAVED_QUERIES} saved queries are allowed.`);
+      if (items.some((item2) => item2.name === normalizedName)) throw new Error(`Saved query "${normalizedName}" already exists.`);
+      const item = {
+        id: `${savedAt}-${Math.round((savedAt * 9301 + 49297) % 233280)}`,
+        name: normalizedName,
+        savedAt,
+        query: normalizeQueryState(query)
+      };
+      saved.set(key, [...items, item]);
+      return item;
+    },
+    async deleteSaved(key, id) {
+      saved.set(key, (saved.get(key) ?? []).filter((item) => item.id !== id));
+      if (defaults.get(key) === id) defaults.delete(key);
+    }
+  };
+}
+function localStorageAdapter() {
+  const ls = (() => {
+    try {
+      return typeof localStorage !== "undefined" ? localStorage : null;
+    } catch {
+      return null;
+    }
+  })();
+  const readSaved = (key) => {
+    if (!ls) return [];
+    try {
+      const raw = ls.getItem(SAVED_PREFIX + key);
+      return normalizeSavedQueries(raw ? JSON.parse(raw) : []);
+    } catch {
+      return [];
+    }
+  };
+  const writeSaved = (key, items) => {
+    if (ls) ls.setItem(SAVED_PREFIX + key, JSON.stringify(items));
+  };
+  const readDefaultId = (key) => {
+    if (!ls) return null;
+    return ls.getItem(DEFAULT_PREFIX + key);
+  };
+  const writeDefaultId = (key, id) => {
+    if (!ls) return;
+    if (id) ls.setItem(DEFAULT_PREFIX + key, id);
+    else ls.removeItem(DEFAULT_PREFIX + key);
+  };
+  return {
+    async loadLast(key) {
+      if (!ls) return null;
+      try {
+        const raw = ls.getItem(LAST_PREFIX + key);
+        return raw ? normalizeQueryState(JSON.parse(raw)) : null;
+      } catch {
+        return null;
+      }
+    },
+    async saveLast(key, query) {
+      if (ls) ls.setItem(LAST_PREFIX + key, JSON.stringify(normalizeQueryState(query)));
+    },
+    async listSaved(key) {
+      return readSaved(key).sort((a, b) => b.savedAt - a.savedAt);
+    },
+    async loadDefaultSaved(key) {
+      const id = readDefaultId(key);
+      if (!id) return null;
+      const found = readSaved(key).find((q) => q.id === id);
+      if (!found) writeDefaultId(key, null);
+      return found ?? null;
+    },
+    async setDefaultSaved(key, id) {
+      if (id && !readSaved(key).some((q) => q.id === id)) {
+        throw new Error(`Saved query "${id}" does not exist.`);
+      }
+      writeDefaultId(key, id);
+    },
+    async saveNamed(key, name, query, savedAt) {
+      const normalizedName = name.trim();
+      if (!normalizedName || normalizedName.length > MAX_SAVED_NAME_LENGTH) {
+        throw new Error(`Saved query name must be between 1 and ${MAX_SAVED_NAME_LENGTH} characters.`);
+      }
+      const items = readSaved(key);
+      if (items.length >= MAX_SAVED_QUERIES) throw new Error(`At most ${MAX_SAVED_QUERIES} saved queries are allowed.`);
+      if (items.some((q) => q.name === normalizedName)) {
+        throw new Error(`Saved query "${normalizedName}" already exists.`);
+      }
+      const item = {
+        id: `${savedAt}-${Math.round((savedAt * 9301 + 49297) % 233280)}`,
+        name: normalizedName,
+        savedAt,
+        query: normalizeQueryState(query)
+      };
+      items.push(item);
+      writeSaved(key, items);
+      return item;
+    },
+    async deleteSaved(key, id) {
+      writeSaved(
+        key,
+        readSaved(key).filter((q) => q.id !== id)
+      );
+      if (readDefaultId(key) === id) writeDefaultId(key, null);
+    }
+  };
+}
 export {
   AGG_OPS_BY_TYPE,
   AGG_OPS_NEEDING_FIELD,
@@ -2309,6 +3647,7 @@ export {
   MAX_QUERY_LIMIT,
   MAX_QUERY_OFFSET,
   MAX_QUERY_TOKEN_LENGTH,
+  MAX_RELATIVE_TIME_MS,
   MAX_SELECT_COLUMNS,
   MAX_WHERE_CLAUSES,
   NULLARY_OPS,
@@ -2318,15 +3657,23 @@ export {
   aggOpsForField,
   applyAggregations,
   applyQuery,
+  boxSummary,
   coerceValue,
+  compareMetricValues,
   compileFormula,
+  compileMetric,
   computedFieldName,
   createSetFilter,
   decodeQuery,
   encodeQuery,
+  evaluateMetricReductions,
+  evaluateMetrics,
   filterValues,
   formulaRuntime,
   groupPreview,
+  hasRegex,
+  histogramCounts,
+  histogramEdges,
   httpComputedColumnStore,
   indexFields,
   isComputedCellError,
@@ -2345,19 +3692,32 @@ export {
   matchesClause,
   memoryComputedColumnStore,
   memoryStorageAdapter,
+  metricAggregatePlans,
+  metricComputationKey,
+  metricDependencies,
+  metricExpression,
+  metricPlans,
   negateClause,
   normalizeQueryState,
   opAllowedForType,
   opPairsForField,
   opsForField,
+  parseRelativeDuration,
+  percentile,
   predicatesOf,
   queriesEqual,
   readFieldValue,
   readSetFilter,
+  reduceMetricValues,
+  resolveFieldName,
+  selectMetricShownRows,
   selectedFields,
   stripSetFilter,
   toAggregationQuery,
+  toMetricQuery,
   toServerQuery,
-  validateComputedColumn
+  toServerQueryV2,
+  validateComputedColumn,
+  validateMetric
 };
 //# sourceMappingURL=index.js.map