@objectstack/service-analytics 17.0.0-rc.0 → 17.0.0-rc.2

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/analytics-service.ts
+import { percentScaleOf } from "@objectstack/spec/data";
 import { createLogger, bucketKeyToCalendarRange, zonedDateStartToUtcMs } from "@objectstack/core";
 
 // src/cube-registry.ts
@@ -128,7 +129,8 @@ var MONGO_TO_CUBE_OP = {
   $nin: "notIn",
   $contains: "contains",
   $notContains: "notContains",
-  $exists: "set"
+  $startsWith: "startsWith",
+  $endsWith: "endsWith"
 };
 function stringifyForCube(v) {
   if (v == null) return "";
@@ -137,55 +139,102 @@ function stringifyForCube(v) {
   if (typeof v === "object") return JSON.stringify(v);
   return String(v);
 }
-function flattenCondition(cond, out) {
-  for (const [key, raw] of Object.entries(cond)) {
-    if (raw === void 0) continue;
-    if (key === "$and" && Array.isArray(raw)) {
-      for (const sub of raw) {
-        if (sub && typeof sub === "object") {
-          flattenCondition(sub, out);
+function andOf(children) {
+  if (children.length === 0) return null;
+  if (children.length === 1) return children[0];
+  return { kind: "and", children };
+}
+function fieldLeaves(key, raw) {
+  const out = [];
+  const leaf = (operator, values) => {
+    out.push({ kind: "leaf", member: key, operator, values });
+  };
+  if (raw === null) {
+    leaf("notSet", []);
+    return out;
+  }
+  if (typeof raw === "object" && !Array.isArray(raw) && !(raw instanceof Date)) {
+    const wrapper = raw;
+    const opKeys = Object.keys(wrapper).filter((k) => k.startsWith("$"));
+    if (opKeys.length > 0) {
+      for (const opKey of opKeys) {
+        if (opKey === "$between") {
+          const v2 = wrapper[opKey];
+          if (!Array.isArray(v2) || v2.length !== 2) {
+            throw new Error(
+              `[analytics] "$between" on "${key}" needs a two-element [min, max] array, got ${JSON.stringify(v2)}. Dropping the predicate would silently widen the query to every row.`
+            );
+          }
+          leaf("gte", [stringifyForCube(v2[0])]);
+          leaf("lte", [stringifyForCube(v2[1])]);
+          continue;
         }
+        if (opKey === "$null" || opKey === "$exists") {
+          const isNull = opKey === "$null" ? wrapper[opKey] === true : wrapper[opKey] === false;
+          leaf(isNull ? "notSet" : "set", []);
+          continue;
+        }
+        const cubeOp = MONGO_TO_CUBE_OP[opKey];
+        if (!cubeOp) {
+          throw new Error(
+            `[analytics] Unsupported filter operator "${opKey}" on "${key}". Supported: ${Object.keys(MONGO_TO_CUBE_OP).join(", ")}, $between, $null, $exists, and the $and/$or/$not combinators. Dropping it would silently widen the query to rows the filter excludes.`
+          );
+        }
+        const v = wrapper[opKey];
+        leaf(cubeOp, Array.isArray(v) ? v.map(stringifyForCube) : [stringifyForCube(v)]);
       }
-      continue;
+      return out;
     }
-    if (key === "$or" || key === "$not") continue;
-    if (raw === null) {
-      out.push({ member: key, operator: "notSet", values: [] });
-      continue;
+    for (const [nestedKey, nestedVal] of Object.entries(wrapper)) {
+      out.push(...fieldLeaves(`${key}.${nestedKey}`, nestedVal));
     }
-    if (typeof raw === "object" && !Array.isArray(raw) && !(raw instanceof Date)) {
-      const wrapper = raw;
-      const opKeys = Object.keys(wrapper).filter((k) => k.startsWith("$"));
-      if (opKeys.length > 0) {
-        for (const opKey of opKeys) {
-          const cubeOp = MONGO_TO_CUBE_OP[opKey];
-          if (!cubeOp) continue;
-          const v = wrapper[opKey];
-          const values = Array.isArray(v) ? v.map(stringifyForCube) : [stringifyForCube(v)];
-          out.push({ member: key, operator: cubeOp, values });
-        }
-        continue;
-      }
-      for (const [nestedKey, nestedVal] of Object.entries(wrapper)) {
-        flattenCondition({ [`${key}.${nestedKey}`]: nestedVal }, out);
+    return out;
+  }
+  if (Array.isArray(raw)) leaf("in", raw.map(stringifyForCube));
+  else leaf("equals", [stringifyForCube(raw)]);
+  return out;
+}
+function buildNode(cond) {
+  const children = [];
+  for (const [key, raw] of Object.entries(cond)) {
+    if (raw === void 0) continue;
+    if (key === "$and" || key === "$or") {
+      if (!Array.isArray(raw) || raw.length === 0) {
+        throw new Error(
+          `[analytics] "${key}" requires a non-empty array. An empty combinator has no defensible reading \u2014 dropping it widens the query, and treating it as "match nothing" silently empties a chart.`
+        );
       }
+      const branches = raw.map((sub) => sub && typeof sub === "object" ? buildNode(sub) : null).filter((n) => n !== null);
+      if (branches.length === 0) continue;
+      if (key === "$and") children.push(...branches);
+      else children.push(branches.length === 1 ? branches[0] : { kind: "or", children: branches });
       continue;
     }
-    if (Array.isArray(raw)) {
-      out.push({ member: key, operator: "in", values: raw.map(stringifyForCube) });
-    } else {
-      out.push({ member: key, operator: "equals", values: [stringifyForCube(raw)] });
+    if (key === "$not") {
+      const inner = raw && typeof raw === "object" ? buildNode(raw) : null;
+      if (inner) children.push({ kind: "not", child: inner });
+      continue;
+    }
+    if (key.startsWith("$")) {
+      throw new Error(
+        `[analytics] Unsupported top-level filter operator "${key}". Dropping it would silently widen the query to rows the filter excludes.`
+      );
     }
+    children.push(...fieldLeaves(key, raw));
   }
+  return andOf(children);
 }
-function normalizeAnalyticsFilters(query) {
-  if (!query || typeof query !== "object") return [];
-  const out = [];
+function normalizeAnalyticsFilterTree(query) {
+  if (!query || typeof query !== "object") return null;
   const where = query.where;
-  if (where && typeof where === "object" && !Array.isArray(where)) {
-    flattenCondition(where, out);
-  }
-  return out;
+  if (!where || typeof where !== "object" || Array.isArray(where)) return null;
+  return buildNode(where);
+}
+function collectFilterLeaves(node) {
+  if (!node) return [];
+  if (node.kind === "leaf") return [{ member: node.member, operator: node.operator, values: node.values }];
+  if (node.kind === "not") return collectFilterLeaves(node.child);
+  return node.children.flatMap(collectFilterLeaves);
 }
 function recoverNumber(s) {
   if (/^-?\d+(\.\d+)?$/.test(s)) {
@@ -317,6 +366,18 @@ function compileOperator(col, op, val, field, params) {
 }
 
 // src/strategies/native-sql-strategy.ts
+import { nextUtcCalendarDay } from "@objectstack/core";
+var AGGREGATE_SQL = {
+  "count": () => "COUNT(*)",
+  "sum": (col) => `SUM(${col})`,
+  "avg": (col) => `AVG(${col})`,
+  "min": (col) => `MIN(${col})`,
+  "max": (col) => `MAX(${col})`,
+  "count_distinct": (col) => `COUNT(DISTINCT ${col})`
+};
+var SUPPORTED_AGGREGATE_SQL_KEYS = Object.keys(AGGREGATE_SQL);
+var EXPRESSION_METRIC_TYPES = /* @__PURE__ */ new Set(["number", "string", "boolean"]);
+var IDENTIFIER_PATH = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
 var NativeSQLStrategy = class {
   constructor() {
     this.name = "NativeSQLStrategy";
@@ -371,15 +432,15 @@ var NativeSQLStrategy = class {
       }
     }
     const whereClauses = [];
-    const normalizedFilters = normalizeAnalyticsFilters(query);
-    if (normalizedFilters.length > 0) {
-      for (const filter of normalizedFilters) {
-        const colExpr = this.resolveFieldSql(cube, filter.member, tableName, joins);
-        const target = this.resolveStorageTarget(cube, filter.member, tableName);
-        const clause = this.buildFilterClause(colExpr, filter.operator, filter.values, params, ctx, target);
-        if (clause) whereClauses.push(clause);
-      }
-    }
+    const filterSql = this.compileFilterNode(
+      normalizeAnalyticsFilterTree(query),
+      cube,
+      tableName,
+      joins,
+      params,
+      ctx
+    );
+    if (filterSql) whereClauses.push(filterSql);
     if (query.timeDimensions && query.timeDimensions.length > 0) {
       for (const td of query.timeDimensions) {
         const colExpr = this.resolveFieldSql(cube, td.dimension, tableName, joins);
@@ -387,11 +448,17 @@ var NativeSQLStrategy = class {
           const range = Array.isArray(td.dateRange) ? td.dateRange : [td.dateRange, td.dateRange];
           if (range.length === 2) {
             const td2 = this.resolveStorageTarget(cube, td.dimension, tableName);
-            params.push(
-              this.coerceTemporal(ctx, td2, range[0]),
-              this.coerceTemporal(ctx, td2, range[1])
-            );
-            whereClauses.push(`${colExpr} BETWEEN $${params.length - 1} AND $${params.length}`);
+            const column = this.temporalColumn(ctx, td2, colExpr);
+            const nextDay = nextUtcCalendarDay(range[1]);
+            params.push(this.coerceTemporal(ctx, td2, range[0]));
+            const lower = `${column} >= $${params.length}`;
+            if (nextDay != null) {
+              params.push(this.coerceTemporal(ctx, td2, nextDay));
+              whereClauses.push(`(${lower} AND ${column} < $${params.length})`);
+            } else {
+              params.push(this.coerceTemporal(ctx, td2, range[1]));
+              whereClauses.push(`(${lower} AND ${column} <= $${params.length})`);
+            }
           }
         }
       }
@@ -489,6 +556,7 @@ var NativeSQLStrategy = class {
       }
       return rawSql;
     }
+    if (!IDENTIFIER_PATH.test(rawSql)) return rawSql;
     const segments = rawSql.split(".");
     const column = segments[segments.length - 1];
     const hops = segments.slice(0, -1);
@@ -548,24 +616,19 @@ var NativeSQLStrategy = class {
   }
   resolveMeasureSql(cube, member, parentTable, joins) {
     const measure = this.lookupMember(cube, member, "measure");
-    if (!measure) return `COUNT(*)`;
-    const col = measure.sql === "*" ? "*" : this.qualifyAndRegisterJoin(measure.sql, parentTable, joins, cube);
-    switch (measure.type) {
-      case "count":
-        return "COUNT(*)";
-      case "sum":
-        return `SUM(${col})`;
-      case "avg":
-        return `AVG(${col})`;
-      case "min":
-        return `MIN(${col})`;
-      case "max":
-        return `MAX(${col})`;
-      case "count_distinct":
-        return `COUNT(DISTINCT ${col})`;
-      default:
-        return `COUNT(*)`;
+    if (!measure) {
+      const declared = Object.keys(cube.measures ?? {});
+      throw new Error(
+        `[native-sql-strategy] cube "${cube.name}" declares no measure "${member}"` + (declared.length ? ` (declared: ${declared.join(", ")})` : " (it declares none)")
+      );
     }
+    const col = measure.sql === "*" ? "*" : this.qualifyAndRegisterJoin(measure.sql, parentTable, joins, cube);
+    const wrap = AGGREGATE_SQL[measure.type];
+    if (wrap) return wrap(col);
+    if (EXPRESSION_METRIC_TYPES.has(measure.type)) return col;
+    throw new Error(
+      `[native-sql-strategy] measure "${member}" on cube "${cube.name}" has unrecognised type "${measure.type}" \u2014 expected an aggregate (${SUPPORTED_AGGREGATE_SQL_KEYS.join(", ")}) or a custom-expression type (${[...EXPRESSION_METRIC_TYPES].join(", ")}).`
+    );
   }
   resolveFieldSql(cube, member, parentTable, joins) {
     const dim = this.lookupMember(cube, member, "dimension");
@@ -618,7 +681,53 @@ var NativeSQLStrategy = class {
     }
     return coerceFilterValueForSql(value);
   }
-  buildFilterClause(col, operator, values, params, ctx, target) {
+  /**
+   * The column side of {@link coerceTemporal}: normalise the reference so it
+   * reads in the storage form the comparand was coerced into.
+   *
+   * A SQLite `Field.datetime` column carries an INTEGER epoch (a `Date` write)
+   * and ISO TEXT (a REST/JSON write, a `NOW()` default — including the platform's
+   * own `created_at`) at the SAME time, so coercing the value alone fixes one half
+   * and empties the other. That is #3912: a `dateRange: last_30_days` on
+   * `created_date` read 0 with 29 rows in range. Every other column and dialect
+   * gets its reference back verbatim.
+   */
+  temporalColumn(ctx, target, col) {
+    if (typeof ctx.coerceTemporalFilterColumn !== "function") return col;
+    return ctx.coerceTemporalFilterColumn(target.object, target.field, col) || col;
+  }
+  /**
+   * Compile a normalized filter node into a boolean SQL expression, recursing
+   * through the combinators. `null` = no constraint.
+   *
+   * Leaves go through {@link buildFilterClause} exactly as they did when this
+   * was a flat loop, so the storage-form coercion and the calendar-day
+   * upper-bound rule (#3777) apply at every depth — including inside an `$or`,
+   * where a second, combinator-aware implementation would have been free to
+   * drift from the first.
+   *
+   * Parenthesisation is explicit rather than left to SQL's precedence: `AND`
+   * does bind tighter than `OR`, so `a AND b OR c` happens to be right, but
+   * being right by construction is what keeps a future edit from making it
+   * wrong.
+   */
+  compileFilterNode(node, cube, parentTable, joins, params, ctx) {
+    if (!node) return null;
+    if (node.kind === "leaf") {
+      const colExpr = this.resolveFieldSql(cube, node.member, parentTable, joins);
+      const target = this.resolveStorageTarget(cube, node.member, parentTable);
+      return this.buildFilterClause(colExpr, node.operator, node.values, params, ctx, target);
+    }
+    if (node.kind === "not") {
+      const inner = this.compileFilterNode(node.child, cube, parentTable, joins, params, ctx);
+      return inner ? `NOT (${inner})` : null;
+    }
+    const parts = node.children.map((child) => this.compileFilterNode(child, cube, parentTable, joins, params, ctx)).filter((s) => !!s);
+    if (parts.length === 0) return null;
+    if (parts.length === 1) return parts[0];
+    return `(${parts.join(node.kind === "or" ? " OR " : " AND ")})`;
+  }
+  buildFilterClause(rawCol, operator, values, params, ctx, target) {
     const opMap = {
       equals: "=",
       notEquals: "!=",
@@ -627,26 +736,42 @@ var NativeSQLStrategy = class {
       lt: "<",
       lte: "<=",
       contains: "LIKE",
-      notContains: "NOT LIKE"
+      notContains: "NOT LIKE",
+      startsWith: "LIKE",
+      endsWith: "LIKE"
     };
-    if (operator === "set") return `${col} IS NOT NULL`;
-    if (operator === "notSet") return `${col} IS NULL`;
+    const likePattern = {
+      contains: (v) => `%${v}%`,
+      notContains: (v) => `%${v}%`,
+      startsWith: (v) => `${v}%`,
+      endsWith: (v) => `%${v}`
+    };
+    if (operator === "set") return `${rawCol} IS NOT NULL`;
+    if (operator === "notSet") return `${rawCol} IS NULL`;
     if (operator === "in" || operator === "notIn") {
       if (!values || values.length === 0) return null;
       const placeholders = values.map((v) => {
         params.push(this.coerceTemporal(ctx, target, v));
         return `$${params.length}`;
       }).join(", ");
-      return `${col} ${operator === "in" ? "IN" : "NOT IN"} (${placeholders})`;
+      return `${this.temporalColumn(ctx, target, rawCol)} ${operator === "in" ? "IN" : "NOT IN"} (${placeholders})`;
     }
     const sqlOp = opMap[operator];
     if (!sqlOp || !values || values.length === 0) return null;
-    if (operator === "contains" || operator === "notContains") {
-      params.push(`%${values[0]}%`);
-    } else {
-      params.push(this.coerceTemporal(ctx, target, values[0]));
+    const pattern = likePattern[operator];
+    if (pattern) {
+      params.push(pattern(values[0]));
+      return `${rawCol} ${sqlOp} $${params.length}`;
     }
-    return `${col} ${sqlOp} $${params.length}`;
+    if (operator === "lte") {
+      const nextDay = nextUtcCalendarDay(values[0]);
+      if (nextDay != null) {
+        params.push(this.coerceTemporal(ctx, target, nextDay));
+        return `${this.temporalColumn(ctx, target, rawCol)} < $${params.length}`;
+      }
+    }
+    params.push(this.coerceTemporal(ctx, target, values[0]));
+    return `${this.temporalColumn(ctx, target, rawCol)} ${sqlOp} $${params.length}`;
   }
   extractObjectName(cube) {
     return cube.sql.trim();
@@ -668,6 +793,9 @@ var NativeSQLStrategy = class {
   }
 };
 
+// src/strategies/objectql-strategy.ts
+import { nextUtcCalendarDay as nextUtcCalendarDay2 } from "@objectstack/core";
+
 // src/strategies/cross-object-rebucket.ts
 var RECOMBINABLE_METHODS = /* @__PURE__ */ new Set([
   "sum",
@@ -770,11 +898,7 @@ var ObjectQLStrategy = class {
     }
     const filter = {};
     const conjuncts = [];
-    for (const f of normalizeAnalyticsFilters(query)) {
-      const fieldName = this.resolveFieldName(cube, f.member, "any");
-      const extra = this.mergeFilterOperand(filter, fieldName, this.convertFilter(f.operator, f.values));
-      if (extra) conjuncts.push(extra);
-    }
+    this.applyFilterNode(normalizeAnalyticsFilterTree(query), cube, filter, conjuncts);
     for (const { field, bounds } of this.dateRangeBounds(cube, query)) {
       const extra = this.mergeFilterOperand(filter, field, bounds);
       if (extra) conjuncts.push(extra);
@@ -806,11 +930,9 @@ var ObjectQLStrategy = class {
     });
     const mappedRows = rows.map((row) => {
       const mapped = {};
-      if (query.dimensions) {
-        for (const dim of query.dimensions) {
-          const shortName = this.resolveFieldName(cube, dim, "dimension");
-          if (shortName in row) mapped[dim] = row[shortName];
-        }
+      for (const dim of this.projectedDimensions(query)) {
+        const shortName = this.resolveFieldName(cube, dim, "dimension");
+        if (shortName in row) mapped[dim] = row[shortName];
       }
       if (query.measures) {
         for (const m of query.measures) {
@@ -856,7 +978,7 @@ var ObjectQLStrategy = class {
     }
     const tableName = this.extractObjectName(cube);
     const plan = this.planCrossObject(cube, query, Object.fromEntries(
-      normalizeAnalyticsFilters(query).map((f) => [this.resolveFieldName(cube, f.member, "any"), true])
+      collectFilterLeaves(normalizeAnalyticsFilterTree(query)).map((f) => [this.resolveFieldName(cube, f.member, "any"), true])
     ));
     const crossByDim = new Map((plan?.crossDims ?? []).map((cd) => [cd.outputName, cd]));
     const joinClauses = [];
@@ -893,18 +1015,18 @@ var ObjectQLStrategy = class {
       }
     }
     const whereParts = [];
-    for (const f of normalizeAnalyticsFilters(query)) {
-      const clause = this.buildFilterClauseSql(
-        this.resolveFieldName(cube, f.member, "any"),
-        f.operator,
-        f.values,
-        params
-      );
-      if (clause) whereParts.push(clause);
-    }
+    const filterClause = this.renderFilterNodeSql(
+      normalizeAnalyticsFilterTree(query),
+      cube,
+      params
+    );
+    if (filterClause) whereParts.push(filterClause);
     for (const { field, bounds } of this.dateRangeBounds(cube, query)) {
-      params.push(bounds.$gte, bounds.$lte);
-      whereParts.push(`${field} BETWEEN $${params.length - 1} AND $${params.length}`);
+      const nextDay = nextUtcCalendarDay2(bounds.$lte);
+      params.push(bounds.$gte, nextDay ?? bounds.$lte);
+      whereParts.push(
+        `(${field} >= $${params.length - 1} AND ${field} ${nextDay ? "<" : "<="} $${params.length})`
+      );
     }
     const scope = ctx.getReadScope?.(tableName);
     if (scope != null) {
@@ -1078,7 +1200,7 @@ var ObjectQLStrategy = class {
     const merged = rebucketCrossObject(baseRows, baseDimFields, resolvedDims, measures);
     const mappedRows = merged.map((row) => {
       const out = {};
-      for (const dim of query.dimensions ?? []) {
+      for (const dim of this.projectedDimensions(query)) {
         if (crossByDim.has(dim)) {
           if (dim in row) out[dim] = row[dim];
         } else {
@@ -1086,11 +1208,6 @@ var ObjectQLStrategy = class {
           if (field in row) out[dim] = row[field];
         }
       }
-      for (const td of query.timeDimensions ?? []) {
-        if (query.dimensions?.includes(td.dimension)) continue;
-        const field = this.resolveFieldName(cube, td.dimension, "dimension");
-        if (field in row) out[td.dimension] = row[field];
-      }
       for (const m of query.measures ?? []) {
         if (m in row) out[m] = row[m];
       }
@@ -1233,6 +1350,75 @@ var ObjectQLStrategy = class {
    * are handed back for the caller to AND in separately, so the engine
    * intersects them instead of the strategy picking a winner.
    */
+  /**
+   * Fold a normalized filter node into the engine filter being built.
+   *
+   * AND-ed LEAVES merge per field through {@link mergeFilterOperand}, exactly
+   * as the flat loop this replaced did — so a query without combinators still
+   * produces byte-identical engine input. Anything structural (`$or`, `$not`,
+   * a nested `$and` that cannot merge) becomes its own conjunct, which the
+   * caller ANDs in. The engine speaks these combinators natively
+   * (`FilterCondition` declares them and every driver compiles them), so this
+   * path hands them over rather than lowering them.
+   */
+  applyFilterNode(node, cube, filter, conjuncts) {
+    if (!node) return;
+    if (node.kind === "leaf") {
+      const fieldName = this.resolveFieldName(cube, node.member, "any");
+      const extra = this.mergeFilterOperand(filter, fieldName, this.convertFilter(node.operator, node.values));
+      if (extra) conjuncts.push(extra);
+      return;
+    }
+    if (node.kind === "and") {
+      for (const child of node.children) this.applyFilterNode(child, cube, filter, conjuncts);
+      return;
+    }
+    const rendered = this.filterNodeToCondition(node, cube);
+    if (rendered) conjuncts.push(rendered);
+  }
+  /** A node as a standalone `FilterCondition` the engine can consume. */
+  filterNodeToCondition(node, cube) {
+    if (!node) return null;
+    if (node.kind === "not") {
+      const inner = this.filterNodeToCondition(node.child, cube);
+      return inner ? { $not: inner } : null;
+    }
+    if (node.kind === "or") {
+      const branches = node.children.map((child) => this.filterNodeToCondition(child, cube)).filter((c) => !!c);
+      return branches.length > 0 ? { $or: branches } : null;
+    }
+    const filter = {};
+    const conjuncts = [];
+    this.applyFilterNode(node, cube, filter, conjuncts);
+    if (conjuncts.length > 0) {
+      filter.$and = [...Array.isArray(filter.$and) ? filter.$and : [], ...conjuncts];
+    }
+    return Object.keys(filter).length > 0 ? filter : null;
+  }
+  /**
+   * Render a normalized filter node as the display SQL `/analytics/sql`
+   * echoes. Values still bind as `$n` placeholders — the echo travels to the
+   * browser, so a comparand is never inlined.
+   */
+  renderFilterNodeSql(node, cube, params) {
+    if (!node) return null;
+    if (node.kind === "leaf") {
+      return this.buildFilterClauseSql(
+        this.resolveFieldName(cube, node.member, "any"),
+        node.operator,
+        node.values,
+        params
+      );
+    }
+    if (node.kind === "not") {
+      const inner = this.renderFilterNodeSql(node.child, cube, params);
+      return inner ? `NOT (${inner})` : null;
+    }
+    const parts = node.children.map((child) => this.renderFilterNodeSql(child, cube, params)).filter((s) => !!s);
+    if (parts.length === 0) return null;
+    if (parts.length === 1) return parts[0];
+    return `(${parts.join(node.kind === "or" ? " OR " : " AND ")})`;
+  }
   mergeFilterOperand(filter, field, operand) {
     const existing = filter[field];
     if (existing === void 0) {
@@ -1256,9 +1442,13 @@ var ObjectQLStrategy = class {
    * HERE on every driver — and "bucketed trend" is precisely the shape that also
    * carries a range ("last 12 months", "this quarter").
    *
-   * Bounds are inclusive on both ends — the same `$gte`/`$lte` pair
-   * `NativeSQLStrategy` binds as `BETWEEN` and the memory driver builds as a
-   * `$match`, so one dashboard reads the same on every driver.
+   * Bounds are inclusive on both ends — logically "from day X through day Y".
+   * The `$lte` end is left as the bare calendar day on purpose: the driver's
+   * filter compiler owns the calendar-day → instant translation, compiling a
+   * bare-day `$lte` on a `datetime` column into the half-open `< nextDay`
+   * (#3777) while a `date` column keeps the plain `<=`. `NativeSQLStrategy`
+   * performs the same half-open translation itself because it binds into raw
+   * SQL, so one dashboard reads the same on every driver.
    *
    * Comparands are coerced by the SAME helper the `where` path uses, so an
    * epoch-ms bound recovers as a number and an ISO string stays a string. No
@@ -1318,24 +1508,60 @@ var ObjectQLStrategy = class {
         return { $lte: v0 };
       case "contains":
         return { $regex: values[0] };
+      // `notContains` had no arm and fell to the `default` below, which returns
+      // a BARE VALUE — i.e. `{field: 'x'}`, an equality. "does not contain x"
+      // was compiled as "equals x". These three pass through as the canonical
+      // spec operators every driver implements directly, so an anchored match
+      // stays anchored rather than depending on regex dialect (#4128).
+      case "notContains":
+        return { $notContains: values[0] };
+      case "startsWith":
+        return { $startsWith: values[0] };
+      case "endsWith":
+        return { $endsWith: values[0] };
       case "in":
         return { $in: all };
       case "notIn":
         return { $nin: all };
       default:
-        return v0;
+        throw new Error(
+          `[analytics] ObjectQL strategy cannot express filter operator "${operator}". Treating it as an equality would silently query something the author did not ask for.`
+        );
     }
   }
   extractObjectName(cube) {
     return cube.sql.trim();
   }
+  /**
+   * The dimensions this query PROJECTS, in the order the result carries them:
+   * every `dimensions` entry, then every granular `timeDimensions` entry that
+   * is not already one of them.
+   *
+   * `timeDimensions` is not merely a filter carrier. An entry with a
+   * `granularity` is GROUPED BY — see the `td.granularity` sites that build
+   * groupBy here, in `generateSql` and in the cross-object path — so its
+   * bucket is a COLUMN of the result; an entry without one only contributes a
+   * `dateRange` predicate and must NOT be projected.
+   *
+   * Grouping, row mapping and {@link buildFieldMeta} have to agree on exactly
+   * that set. When they did not, a bucketed query returned rows carrying only
+   * the measures and a `fields` list that never mentioned the bucket — a trend
+   * chart got N values and no x-axis (#4033) — even though the SQL had
+   * selected `date_trunc(…) AS "<dim>"` all along. One definition, every
+   * consumer.
+   */
+  projectedDimensions(query) {
+    const out = [...query.dimensions ?? []];
+    for (const td of query.timeDimensions ?? []) {
+      if (td.granularity && !out.includes(td.dimension)) out.push(td.dimension);
+    }
+    return out;
+  }
   buildFieldMeta(query, cube) {
     const fields = [];
-    if (query.dimensions) {
-      for (const dim of query.dimensions) {
-        const d = this.lookupMember(cube, dim, "dimension");
-        fields.push({ name: dim, type: d?.type || "string" });
-      }
+    for (const dim of this.projectedDimensions(query)) {
+      const d = this.lookupMember(cube, dim, "dimension");
+      fields.push({ name: dim, type: d?.type || "string" });
     }
     if (query.measures) {
       for (const m of query.measures) {
@@ -1347,14 +1573,16 @@ var ObjectQLStrategy = class {
 };
 
 // src/dataset-compiler.ts
+import { AggregationFunction } from "@objectstack/spec/data";
 var UNSUPPORTED_AGGREGATES = /* @__PURE__ */ new Set(["array_agg", "string_agg"]);
+var SUPPORTED_AGGREGATES = AggregationFunction.options.filter((a) => !UNSUPPORTED_AGGREGATES.has(a));
 function aggregateToMetricType(m) {
   if (!m.aggregate) {
     throw new Error(`[dataset-compiler] non-derived measure "${m.name}" has no aggregate`);
   }
   if (UNSUPPORTED_AGGREGATES.has(m.aggregate)) {
     throw new Error(
-      `[dataset-compiler] measure "${m.name}" uses aggregate "${m.aggregate}" which is not supported by the v1 dataset runtime (supported: count, sum, avg, min, max, count_distinct).`
+      `[dataset-compiler] measure "${m.name}" uses aggregate "${m.aggregate}" which is not supported by the v1 dataset runtime (supported: ${SUPPORTED_AGGREGATES.join(", ")}).`
     );
   }
   return m.aggregate;
@@ -1481,6 +1709,7 @@ function compileDataset(dataset, resolver) {
 }
 
 // src/dataset-executor.ts
+import { emptyGroupValueFor } from "@objectstack/spec/data";
 import { filterTokenContextFrom, resolveFilterTokens } from "@objectstack/core";
 function resolveSelectionTokens(compiled, selection, context) {
   const tokenCtx = filterTokenContextFrom(context, /* @__PURE__ */ new Date());
@@ -1502,6 +1731,12 @@ function combineFilters(a, b) {
   if (a && b) return { $and: [a, b] };
   return a ?? b;
 }
+function splitMeasuresByFilter(measures, measureFilters) {
+  const unfiltered = [];
+  const filtered = [];
+  for (const m of measures) (measureFilters[m] ? filtered : unfiltered).push(m);
+  return { unfiltered, filtered };
+}
 function evaluateDerivedMeasures(rows, derived) {
   if (derived.length === 0) return rows;
   return rows.map((row) => {
@@ -1512,6 +1747,14 @@ function evaluateDerivedMeasures(rows, derived) {
     return out;
   });
 }
+function fillEmptyGroups(rows, columnAggregates) {
+  for (const [column, aggregate2] of Object.entries(columnAggregates)) {
+    const empty = emptyGroupValueFor(aggregate2);
+    if (empty === void 0) continue;
+    for (const row of rows) if (row[column] == null) row[column] = empty;
+  }
+  return rows;
+}
 function num(v) {
   if (v == null) return null;
   const n = typeof v === "number" ? v : Number(v);
@@ -1581,7 +1824,7 @@ function applyWindow(rows, limit, offset) {
   if (start === 0 && limit == null) return rows;
   return rows.slice(start, limit != null ? start + limit : void 0);
 }
-function resolveOrdering(selection, dimensions) {
+function resolveOrdering(selection, dimensions, timeDimensions = []) {
   const order = selection.order;
   if (order && Object.keys(order).length > 0) {
     const selectable = /* @__PURE__ */ new Set([
@@ -1600,6 +1843,10 @@ function resolveOrdering(selection, dimensions) {
   if ((selection.limit != null || selection.offset != null) && dimensions.length > 0) {
     return Object.fromEntries(dimensions.map((d) => [d, "asc"]));
   }
+  const timeKeys = timeDimensions.filter((d) => dimensions.includes(d));
+  if (timeKeys.length > 0) {
+    return Object.fromEntries(timeKeys.map((d) => [d, "asc"]));
+  }
   return void 0;
 }
 function parseUTC(date) {
@@ -1686,14 +1933,10 @@ var DatasetExecutor = class {
     for (const d of selectedDerived) {
       for (const dep of d.of) baseMeasures.add(dep);
     }
-    const unfiltered = [];
-    const filtered = [];
-    for (const m of baseMeasures) {
-      (compiled.measureFilters[m] ? filtered : unfiltered).push(m);
-    }
+    const { unfiltered, filtered } = splitMeasuresByFilter(baseMeasures, compiled.measureFilters);
     const baseFilter = combineFilters(compiled.filter, selection.runtimeFilter);
     const dimensions = selection.dimensions ?? [];
-    const order = resolveOrdering(selection, dimensions);
+    const order = resolveOrdering(selection, dimensions, this.timeDimensionsOf(compiled, dimensions));
     const labelOrderKeys = this.orderLabels ? Object.keys(order ?? {}).filter(
       (k) => dimensions.includes(k) && this.orderLabels.isLabelBearing(k)
     ) : [];
@@ -1701,6 +1944,76 @@ var DatasetExecutor = class {
     const pushDownKeys = /* @__PURE__ */ new Set([...dimensions, ...unfiltered]);
     const canPushDownWindow = singleQuery && labelOrderKeys.length === 0 && Object.keys(order ?? {}).every((k) => pushDownKeys.has(k));
     const windowQuery = canPushDownWindow ? { order, limit: selection.limit, offset: selection.offset } : void 0;
+    const result = await this.runMeasurePass(compiled, selection, {
+      measures: [...baseMeasures],
+      dimensions,
+      baseFilter,
+      window: windowQuery,
+      context
+    });
+    if (selection.compareTo) {
+      const compareRows = await this.runCompare(compiled, selection, [...baseMeasures], dimensions, baseFilter, context);
+      result.rows = mergeByDimensions(
+        result.rows,
+        compareRows,
+        dimensions,
+        [...baseMeasures].map((m) => `${m}__compare`)
+      );
+      for (const m of baseMeasures) result.fields.push({ name: `${m}__compare`, type: "number" });
+    }
+    const fillColumns = {};
+    for (const m of baseMeasures) {
+      const aggregate2 = compiled.cube.measures?.[m]?.type;
+      fillColumns[m] = aggregate2;
+      if (selection.compareTo) fillColumns[`${m}__compare`] = aggregate2;
+    }
+    fillEmptyGroups(result.rows, fillColumns);
+    result.rows = evaluateDerivedMeasures(result.rows, selectedDerived);
+    for (const d of selectedDerived) result.fields.push({ name: d.name, type: "number" });
+    let sortKeys;
+    for (const key of labelOrderKeys) {
+      const values = [...new Set(result.rows.map((r) => r[key]).filter((v) => v != null))];
+      if (values.length === 0) continue;
+      const labels = await this.orderLabels.resolveLabels(key, values);
+      if (labels && labels.size > 0) (sortKeys ?? (sortKeys = {}))[key] = labels;
+    }
+    result.rows = applyOrdering(result.rows, order, sortKeys);
+    result.rows = applyWindow(result.rows, selection.limit, selection.offset);
+    return result;
+  }
+  /**
+   * Run ONE grouped pass over a set of base measures, honouring each measure's
+   * own scoped `filter`: the unfiltered measures in a single query, plus one
+   * supplementary query per filter-scoped measure, merged back by dimension key.
+   *
+   * **This is the executor's only implementation of "how a measure filter is
+   * applied", and every window goes through it** — the current period, each
+   * `totals` subset (which re-enters via `executeSelection`), and the
+   * `compareTo` window. Before #4820 the comparison window had its own,
+   * simpler answer: one shifted query over all base measures with only the
+   * base filter, so `compiled.measureFilters` was never read on that path.
+   * `won_count` counted won deals and `won_count__compare` counted every deal,
+   * under one label, in adjacent columns. Only measures carrying a filter were
+   * wrong — which is what made it survive: the unfiltered ones next to them
+   * compared correctly.
+   *
+   * The caller supplies the `selection` this pass queries under, which is how
+   * the comparison window differs at all: same measures, same dimensions, same
+   * filters — a `timeDimensions` shifted by {@link shiftRange}. Nothing else
+   * about the two passes may drift, because anything that does becomes a
+   * discrepancy between two columns the reader is invited to subtract.
+   *
+   * Cost: one extra query per filter-scoped measure when `compareTo` is set.
+   * The alternative — declaring the discrepancy in the response — is not one,
+   * since the two columns exist to be directly comparable.
+   *
+   * @param window - Ordering/window to push into the SQL. Only ever set for a
+   *   selection the caller proved is a single self-sufficient query; a pass
+   *   that fans out must return its whole grid for the merge.
+   */
+  async runMeasurePass(compiled, selection, opts) {
+    const { measures, dimensions, baseFilter, window, context } = opts;
+    const { unfiltered, filtered } = splitMeasuresByFilter(measures, compiled.measureFilters);
     let result;
     if (unfiltered.length > 0 || filtered.length === 0) {
       result = await this.service.query(this.buildQuery(compiled, {
@@ -1709,7 +2022,7 @@ var DatasetExecutor = class {
         where: baseFilter,
         selection,
         contextTimezone: context?.timezone,
-        window: windowQuery
+        window
       }), context);
     } else {
       result = { rows: [], fields: [] };
@@ -1726,29 +2039,21 @@ var DatasetExecutor = class {
       result.rows = mergeByDimensions(result.rows, sub.rows, dimensions, [m]);
       result.fields.push({ name: m, type: "number" });
     }
-    if (selection.compareTo) {
-      const compareRows = await this.runCompare(compiled, selection, [...baseMeasures], dimensions, baseFilter, context);
-      result.rows = mergeByDimensions(
-        result.rows,
-        compareRows,
-        dimensions,
-        [...baseMeasures].map((m) => `${m}__compare`)
-      );
-      for (const m of baseMeasures) result.fields.push({ name: `${m}__compare`, type: "number" });
-    }
-    result.rows = evaluateDerivedMeasures(result.rows, selectedDerived);
-    for (const d of selectedDerived) result.fields.push({ name: d.name, type: "number" });
-    let sortKeys;
-    for (const key of labelOrderKeys) {
-      const values = [...new Set(result.rows.map((r) => r[key]).filter((v) => v != null))];
-      if (values.length === 0) continue;
-      const labels = await this.orderLabels.resolveLabels(key, values);
-      if (labels && labels.size > 0) (sortKeys ?? (sortKeys = {}))[key] = labels;
-    }
-    result.rows = applyOrdering(result.rows, order, sortKeys);
-    result.rows = applyWindow(result.rows, selection.limit, selection.offset);
     return result;
   }
+  /**
+   * The selected dimensions the compiled cube types as `time`, in selection
+   * order (#3916) — the axis {@link resolveOrdering} defaults to ascending.
+   *
+   * Membership is decided by the DIMENSION's declared type, not by whether the
+   * selection happens to bucket it: a `date` dimension left ungranulated groups
+   * raw timestamps, and those want chronological order every bit as much as
+   * month buckets do. (Both sort correctly — `compareValues` compares Dates and
+   * ISO strings chronologically, and bucket keys are minted sort-stable.)
+   */
+  timeDimensionsOf(compiled, dimensions) {
+    return dimensions.filter((d) => compiled.cube.dimensions[d]?.type === "time");
+  }
   buildQuery(compiled, opts) {
     const q = {
       cube: compiled.cube.name,
@@ -1798,13 +2103,11 @@ var DatasetExecutor = class {
     const shiftedTd = (selection.timeDimensions ?? []).map(
       (t) => t.dimension === cmp.dimension ? { ...t, dateRange: shifted } : t
     );
-    const sub = await this.service.query(this.buildQuery(compiled, {
-      measures,
-      dimensions,
-      where: baseFilter,
-      selection: { ...selection, timeDimensions: shiftedTd },
-      contextTimezone: context?.timezone
-    }), context);
+    const sub = await this.runMeasurePass(
+      compiled,
+      { ...selection, timeDimensions: shiftedTd },
+      { measures, dimensions, baseFilter, context }
+    );
     return sub.rows.map((row) => {
       const out = {};
       for (const dim of dimensions) out[dim] = row[dim];
@@ -1990,11 +2293,21 @@ function pickDisplayField(fields) {
 }
 
 // src/preview-evaluator.ts
-import { calendarPartsInTzOrUtc } from "@objectstack/core";
+import { calendarPartsInTzOrUtc, nextUtcCalendarDay as nextUtcCalendarDay3, utcInstantMs } from "@objectstack/core";
 function compare(a, b) {
   if (typeof a === "number" && typeof b === "number") return a - b;
+  if (a instanceof Date || b instanceof Date) {
+    const ai = utcInstantMs(a);
+    const bi = utcInstantMs(b);
+    if (ai !== null && bi !== null) return ai - bi;
+  }
   return String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
 }
+function lteBound(value, bound) {
+  const nextDay = nextUtcCalendarDay3(bound);
+  if (nextDay != null) return compare(value, nextDay) < 0;
+  return compare(value, bound) <= 0;
+}
 function matchOp(value, op, expected) {
   switch (op) {
     case "$eq":
@@ -2007,8 +2320,16 @@ function matchOp(value, op, expected) {
       return value != null && compare(value, expected) >= 0;
     case "$lt":
       return value != null && compare(value, expected) < 0;
-    case "$lte":
-      return value != null && compare(value, expected) <= 0;
+    case "$lte": {
+      if (value == null) return false;
+      return lteBound(value, expected);
+    }
+    case "$between": {
+      if (value == null || !Array.isArray(expected) || expected.length !== 2) return false;
+      const [min, max] = expected;
+      if (min == null || max == null) return false;
+      return compare(value, min) >= 0 && lteBound(value, max);
+    }
     case "$in":
       return Array.isArray(expected) && expected.some((e) => value === e || String(value) === String(e));
     case "$nin":
@@ -2095,7 +2416,9 @@ function evaluateAnalyticsQueryOverRows(query, cube, rows) {
     const [start, end] = Array.isArray(td.dateRange) ? td.dateRange : [td.dateRange, td.dateRange];
     filtered = filtered.filter((r) => {
       const v = String(r[field] ?? "");
-      return v >= String(start) && v <= `${end}~`;
+      const nextDay = nextUtcCalendarDay3(end);
+      const inUpper = nextDay != null ? v < nextDay : v <= `${end}~`;
+      return v >= String(start) && inUpper;
     });
   }
   const dimensions = query.dimensions ?? [];
@@ -2154,6 +2477,7 @@ function isMissingSourceError(err) {
   msg.includes("not registered") || // framework: object not in registry
   msg.includes("unknown object") || msg.includes("is not a registered object");
 }
+var BARE_IDENTIFIER = /^[a-z_][a-z0-9_]*$/i;
 var DEFAULT_CAPABILITIES = {
   nativeSql: false,
   objectqlAggregate: false,
@@ -2172,10 +2496,11 @@ var AnalyticsService = class {
     }
     this.readScopeProvider = config.getReadScope;
     this.relationshipResolver = config.relationshipResolver;
-    this.measureCurrency = config.measureCurrency;
+    this.sourceFieldMeta = config.sourceFieldMeta;
     this.labelResolver = config.labelResolver;
     this.draftRowsResolver = config.draftRowsResolver;
     this.isRegisteredObject = config.isRegisteredObject;
+    this.getObjectFieldNames = config.getObjectFieldNames;
     if (config.datasets) {
       for (const ds of config.datasets) {
         try {
@@ -2195,6 +2520,7 @@ var AnalyticsService = class {
       // fall back to any explicitly-configured provider for legacy cubes.
       getAllowedRelationships: (cubeName) => this.datasetRegistry.get(cubeName)?.allowedRelationships ?? config.getAllowedRelationships?.(cubeName),
       coerceTemporalFilterValue: config.coerceTemporalFilterValue,
+      coerceTemporalFilterColumn: config.coerceTemporalFilterColumn,
       isExternalObject: config.isExternalObject
     };
     const builtIn = [
@@ -2392,7 +2718,7 @@ var AnalyticsService = class {
       if (!d.field || d.type !== "date") continue;
       const granularity = resolveDimensionGranularity(selection, d.name, d.dateGranularity);
       if (!granularity) continue;
-      const ftype = this.measureCurrency?.(dataset.object, d.field)?.type;
+      const ftype = this.sourceFieldMeta?.(dataset.object, d.field)?.type;
       if (ftype === "datetime") rangeDims.push({ d, granularity, instant: true });
       else if (ftype === "date") rangeDims.push({ d, granularity, instant: false });
       else if (rangeTz === "UTC") rangeDims.push({ d, granularity, instant: false });
@@ -2441,14 +2767,17 @@ var AnalyticsService = class {
         if (f.format == null && m.format) f.format = m.format;
         const fc = f;
         const mc = m;
+        const meta = m.field ? this.sourceFieldMeta?.(dataset.object, m.field) : void 0;
         if (fc.currency == null) {
-          const meta = m.field ? this.measureCurrency?.(dataset.object, m.field) : void 0;
           const monetary = !!mc.currency || meta?.type === "currency";
           if (monetary) {
             const resolved = mc.currency ?? meta?.defaultCurrency ?? context?.currency;
             if (resolved) fc.currency = resolved;
           }
         }
+        if (f.percentScale == null) {
+          f.percentScale = m.derived?.op === "ratio" ? "fraction" : percentScaleOf(meta);
+        }
       }
     }
     if (result.fields?.length && selectedDims.length) {
@@ -2514,6 +2843,7 @@ var AnalyticsService = class {
     if (!cube) {
       this.assertInferableCube(name);
       cube = this.inferCubeFromQuery(query);
+      this.assertMeasureFields(query, cube, Object.keys(cube.measures));
       this.cubeRegistry.register(cube);
       const isScalarMetric = (query.dimensions?.length ?? 0) === 0 && (query.timeDimensions?.length ?? 0) === 0;
       const message = `[Analytics] No cube registered for "${name}"; auto-inferred a minimal cube (sql="${name}", measures=${Object.keys(cube.measures).join(",") || "(none)"}, dimensions=${Object.keys(cube.dimensions).join(",") || "(none)"}). Define an explicit Cube in your stack for full control.`;
@@ -2533,10 +2863,82 @@ var AnalyticsService = class {
         ...cube,
         measures: { ...cube.measures, ...extraMeasures }
       };
+      this.assertMeasureFields(query, augmented, Object.keys(cube.measures));
       this.cubeRegistry.register(augmented);
       this.logger.debug(
         `[Analytics] Augmented cube "${name}" with inferred measures: ${Object.keys(extraMeasures).join(",")}`
       );
+    } else {
+      this.assertMeasureFields(query, cube, Object.keys(cube.measures));
+    }
+  }
+  /**
+   * [#4437] Reject a measure whose SOURCE FIELD the backing object does not
+   * have, BEFORE the strategy compiles it into SQL.
+   *
+   * `inferMeasure` maps a suffix convention onto a field name and has no way to
+   * know whether that field exists: `ghost_sum` happily became `SUM(ghost)`, the
+   * driver threw `no such column`, and the caller got
+   * `500 {"code":"SQLITE_ERROR","message":"Internal server error"}` — a driver
+   * error class on the wire, and nothing actionable, for what is a plain typo.
+   * The DATA route has refused the same mistake with a `400 INVALID_FIELD`
+   * naming the field since #4315/#4254; this is the analytics half of that
+   * answer, and it is deliberately the SAME envelope (`code`/`field`/`object`/
+   * `param`) so one mistake has one shape across both routes.
+   *
+   * What it checks, and what it deliberately does not:
+   *
+   * - Only when the cube's `sql` is a bare OBJECT NAME. An authored cube whose
+   *   `sql` is a real SQL expression has no field list to check against.
+   * - Only when {@link AnalyticsServiceConfig.getObjectFieldNames} answers.
+   *   Absent hook / unknown object → stand down (see the config field's doc).
+   * - Only measures whose source is a BARE COLUMN. `count(*)` has no source
+   *   field, and a dotted reference (`account.industry`) resolves through a
+   *   join whose target this check cannot see — both pass through untouched.
+   * - `id` / `created_at` / `updated_at` are admitted unconditionally, matching
+   *   the data path's `resolveQueryFields`: they are engine-assigned rather than
+   *   declared, and a gate stricter than the engine it guards would reject
+   *   queries that used to work.
+   */
+  assertMeasureFields(query, cube, declaredMeasures) {
+    const probe = this.getObjectFieldNames;
+    if (!probe) return;
+    const measures = query.measures ?? [];
+    if (measures.length === 0) return;
+    const object = typeof cube.sql === "string" ? cube.sql.trim() : "";
+    if (!object || !BARE_IDENTIFIER.test(object)) return;
+    const fieldNames = probe(object);
+    if (!fieldNames || fieldNames.length === 0) return;
+    const known = /* @__PURE__ */ new Set([...fieldNames, "id", "created_at", "updated_at"]);
+    const stripPrefix = (m) => m.includes(".") ? m.split(".").slice(1).join(".") : m;
+    const sourceFieldOf = (measure) => {
+      const metric = cube.measures[stripPrefix(measure)];
+      if (!metric) return null;
+      if (metric.type === "count" && (metric.sql === "*" || metric.sql == null)) return null;
+      const source = typeof metric.sql === "string" ? metric.sql.trim() : "";
+      if (!source || source === "*" || !BARE_IDENTIFIER.test(source)) return null;
+      return source;
+    };
+    const invalid = /* @__PURE__ */ new Set();
+    for (const measure of measures) {
+      const source = sourceFieldOf(measure);
+      if (source && !known.has(source)) invalid.add(stripPrefix(measure));
+    }
+    if (invalid.size === 0) return;
+    const usable = declaredMeasures.filter((m) => !invalid.has(m));
+    for (const measure of measures) {
+      const source = sourceFieldOf(measure);
+      if (!source || known.has(source)) continue;
+      const err = new Error(
+        `Measure '${measure}' on cube '${cube.name}' aggregates field '${source}', which object '${object}' does not have. Valid measures: ${usable.join(", ") || "(none)"}. Other measures are inferred from the object's OWN fields as '<field>_sum' / '_avg' / '_min' / '_max' / '_count_distinct', so check the spelling of '${source}' \u2014 known fields: ${[...fieldNames].sort().join(", ")}.`
+      );
+      err.code = "INVALID_FIELD";
+      err.status = 400;
+      err.field = source;
+      err.object = object;
+      err.param = "measures";
+      err.measure = measure;
+      throw err;
     }
   }
   /**
@@ -2682,9 +3084,22 @@ var FallbackDelegateStrategy = class {
 var AnalyticsServicePlugin = class {
   constructor(options = {}) {
     this.name = "com.objectstack.service-analytics";
+    /**
+     * Services init() registers on every path (ADR-0116, #4131) — lets the
+     * kernel name this plugin when a consumer requires one before it inits.
+     */
+    this.providesServices = ["analytics"];
     this.version = "1.0.0";
     this.type = "standard";
     this.dependencies = [];
+    /**
+     * init() probes the `data` engine ObjectQLPlugin provides for the
+     * auto-bridge — order-if-present so the probe verdict is deterministic
+     * (ADR-0116, #4471). Soft, not hard: without an engine the plugin
+     * degrades on purpose (per-query lazy resolution / explicit
+     * `executeAggregate`).
+     */
+    this.optionalDependencies = ["com.objectstack.engine.objectql"];
     this.options = options;
   }
   async init(ctx) {
@@ -2884,6 +3299,17 @@ var AnalyticsServicePlugin = class {
       }
       return value;
     };
+    const coerceTemporalFilterColumn = (objectName, fieldName, columnSql) => {
+      try {
+        const svc = ctx.getService("data");
+        const driver = svc?.getDriverForObject?.(objectName);
+        if (driver && typeof driver.temporalFilterColumnSql === "function") {
+          return driver.temporalFilterColumnSql(objectName, fieldName, columnSql);
+        }
+      } catch {
+      }
+      return columnSql;
+    };
     const config = {
       cubes: this.options.cubes,
       logger: ctx.logger,
@@ -2894,12 +3320,15 @@ var AnalyticsServicePlugin = class {
       getReadScope,
       getAllowedRelationships: this.options.getAllowedRelationships,
       coerceTemporalFilterValue,
+      coerceTemporalFilterColumn,
       relationshipResolver,
       labelResolver,
-      // ADR-0053 — source-field currency metadata for the measure currency chain.
-      measureCurrency: (object, field) => {
+      // Source-field metadata behind the display chains on result columns:
+      // ADR-0053 currency (`currencyConfig.defaultCurrency`) and percent scale
+      // (`max`, which is what marks whole-percent storage — objectui#3136).
+      sourceFieldMeta: (object, field) => {
         const f = dataEngine()?.getObject?.(object)?.fields?.[field];
-        return f ? { type: f.type, defaultCurrency: f.currencyConfig?.defaultCurrency } : void 0;
+        return f ? { type: f.type, max: f.max, defaultCurrency: f.currencyConfig?.defaultCurrency } : void 0;
       },
       // ADR-0062 D6 — a federated object carries an `external` block (ADR-0015).
       // Reported so NativeSQLStrategy declines it (its hand-compiled FROM would
@@ -2922,6 +3351,18 @@ var AnalyticsServicePlugin = class {
         if (!engine) return true;
         return engine.getObject?.(name) != null;
       },
+      // [#4437] Field names for the measure source-field gate. Read from the
+      // SAME schema registry `isRegisteredObject` above consults (and the data
+      // path's #4315 gate reads), so "which fields exist" has one answer across
+      // /data and /analytics. `undefined` — no engine, unknown object, or an
+      // object with no field map (an external datasource whose columns are not
+      // mirrored locally) — means "cannot answer", and the gate stands down.
+      getObjectFieldNames: (objectName) => {
+        const fields = dataEngine()?.getObject?.(objectName)?.fields;
+        if (!fields || typeof fields !== "object") return void 0;
+        const names = Object.keys(fields);
+        return names.length > 0 ? names : void 0;
+      },
       draftRowsResolver
     };
     if (autoBridgedReadScope && securityPresentAtInit) {
@@ -2977,6 +3418,7 @@ export {
   compileScopedFilterToSql,
   createOrderLabelResolver,
   evaluateDerivedMeasures,
+  fillEmptyGroups,
   mergeByDimensions,
   pickDisplayField,
   resolveDimensionLabels,