@@ -10,10 +10,11 @@ import {
   virtualFieldAggregateRemedy,
 } from '@objectstack/spec/data';
 import type { Dataset, DatasetMeasure, DatasetDimension } from '@objectstack/spec/ui';
-import { resolveI18nLabel } from '@objectstack/spec/ui';
+import { DATASET_DURATION_AGGREGATES, resolveI18nLabel } from '@objectstack/spec/ui';
 import type { FilterCondition } from '@objectstack/spec/data';
 import { datasetInvalidError } from './dataset-refusal.js';
 import { TEMPORAL_SOURCE_FIELD_TYPES } from './measure-result-type.js';
+import type { DurationMeasureSpec } from './strategies/types.js';
 
 /**
  * Dataset → Cube compiler (ADR-0021 D-A=(c), WS2).
@@ -86,6 +87,12 @@ export interface CompiledDataset {
   filter?: FilterCondition;
   /** Per-measure scoped filters, keyed by measure name (applied by executor). */
   measureFilters: Record<string, FilterCondition>;
+  /**
+   * [#25778] Duration measures, keyed by measure name — NOT in `cube.measures`
+   * (a cube metric reads one column, a duration two). Carried to the
+   * strategies on the dataset-scope channel; see `DatasetScope.measureDurations`.
+   */
+  durations: Record<string, DurationMeasureSpec>;
 }
 
 /**
@@ -260,8 +267,10 @@ const DIVERGENCE_BY_AGGREGATE = (aggregate: string, fieldType: string, column =
  * prescribes; it never re-states which pairs are accepted (that is the table's
  * line above it).
  *
- * The temporal sentence is the one #16737 measured and shipped, kept verbatim
- * for the class it was written about. The deriving sentence is #16099's
+ * The temporal sentence is the one #16737 measured and shipped; [#25778] its
+ * second half named a stored "days open" number as the only way to a duration,
+ * and now names the `duration` measure that answers one without a stored copy.
+ * The deriving sentence is #16099's
  * generalisation: counting is the aggregate that reads no arithmetic off a
  * value, so it is what an author who wanted "how much text is there" actually
  * wants. [#17560] The selecting sentence is the third: an author who wrote
@@ -281,8 +290,9 @@ const REMEDY_BY_SOURCE_CLASS = (fieldType: string, aggregate: string): string =>
   const virtual = virtualFieldAggregateRemedy(aggregate, fieldType);
   if (virtual !== undefined) return virtual;
   return TEMPORAL_SOURCE_FIELD_TYPES.has(fieldType)
-    ? 'For a temporal field, `min`/`max` return a real instant; a DURATION has to be '
-      + 'stored as a number (a computed "days open" field) and aggregated as one.'
+    ? 'For a temporal field, `min`/`max` return a real instant; the time BETWEEN two `datetime` '
+      + 'fields of a record is a `duration: { from, to, unit }` measure, aggregated by '
+      + `${DATASET_DURATION_AGGREGATES.join(' / ')}.`
     : aggregate === 'count_distinct'
       ? 'For a JSON-stored field, `count` counts the rows; a distinct count has to be taken '
         + 'over a field that stores one scalar value, so store the part you count in a field '
@@ -441,6 +451,62 @@ function assertAggregateFieldTypeCompatible(
   );
 }
 
+/**
+ * The one field type a duration measure's `from` / `to` may be declared as.
+ * A `datetime` is an instant (ADR-0053), and the time between two instants is
+ * a duration on every backend. A `date` is a calendar day with no instant and
+ * a `time` a wall clock with no day, so neither denotes a point a duration can
+ * be measured from.
+ */
+const DURATION_COLUMN_TYPE = 'datetime';
+
+/**
+ * [#25778] Compile one dataset measure's `duration` — the column pair, the
+ * unit, and the measure's aggregate — after judging what the metadata can
+ * settle before any query runs.
+ *
+ * - The AGGREGATE is one of `DATASET_DURATION_AGGREGATES`. The spec refuses
+ *   any other at parse; this is the guard for a dataset that reaches the
+ *   compiler without meeting that parse (the same posture as every other
+ *   `DATASET_INVALID` here).
+ * - Each COLUMN is a field the base object declares as `datetime`, judged
+ *   through the same `declaredValueShape` hook the aggregate × field-type gate
+ *   reads, with the same tiering: no hook, or a field the hook cannot resolve,
+ *   is not judged. A column of another declared type is refused, naming the
+ *   column, its type and the one type accepted — so a `text` column holding
+ *   ISO strings, or a `date`, never reaches the SQL as an instant it is not.
+ *   An undeclared column is the field gate's and the database's to refuse.
+ */
+function compileDurationMeasure(
+  datasetName: string,
+  objectName: string,
+  measure: DatasetMeasure & { duration: NonNullable<DatasetMeasure['duration']> },
+  declaredValueShape?: (objectName: string, field: string) => ValueShapeFieldDef | undefined,
+): DurationMeasureSpec {
+  const { from, to, unit } = measure.duration;
+  const aggregate = measure.aggregate;
+  if (!aggregate || !(DATASET_DURATION_AGGREGATES as readonly string[]).includes(aggregate)) {
+    throw datasetInvalidError(
+      `[dataset-compiler] dataset "${datasetName}" duration measure "${measure.name}" takes \`aggregate\` ` +
+      `${DATASET_DURATION_AGGREGATES.join(' / ')}; it declares ${aggregate ? `"${aggregate}"` : 'none'}.`,
+    );
+  }
+  if (declaredValueShape) {
+    for (const [slot, column] of [['from', from], ['to', to]] as const) {
+      const fieldType = declaredValueShape(objectName, column)?.type;
+      if (!fieldType || fieldType === DURATION_COLUMN_TYPE) continue;
+      throw datasetInvalidError(
+        `[dataset-compiler] dataset "${datasetName}" duration measure "${measure.name}" reads ` +
+        `\`duration.${slot}\` "${column}", which object "${objectName}" declares as \`${fieldType}\`. ` +
+        `A duration spans two \`${DURATION_COLUMN_TYPE}\` fields of the same record, because an instant is ` +
+        `the one value every backend measures the time between alike; a \`${fieldType}\` field holds no ` +
+        `instant. Point \`duration.${slot}\` at a \`${DURATION_COLUMN_TYPE}\` field of "${objectName}".`,
+      );
+    }
+  }
+  return { aggregate: aggregate as DurationMeasureSpec['aggregate'], from, to, unit };
+}
+
 /** Map a dataset dimension type to the Cube dimension `type`. */
 function dimensionType(d: DatasetDimension): CubeDimension['type'] {
   switch (d.type) {
@@ -707,12 +773,28 @@ export function compileDataset(
   const measures: Record<string, Metric> = {};
   const derived: DerivedMeasureSpec[] = [];
   const measureFilters: Record<string, FilterCondition> = {};
+  const durations: Record<string, DurationMeasureSpec> = {};
 
   for (const m of dataset.measures) {
     if (m.derived) {
       derived.push({ name: m.name, op: m.derived.op, of: m.derived.of });
       continue;
     }
+    // [#25778] A duration measure reads two columns, which no cube metric can
+    // carry: it goes to the dataset-scope sidecar and NOT into
+    // `cube.measures`, so any reader that does not know it refuses it rather
+    // than aggregating one of its columns (see `DatasetScope.measureDurations`).
+    // Its scoped `filter` rides the ordinary channel.
+    if (m.duration) {
+      durations[m.name] = compileDurationMeasure(
+        dataset.name,
+        dataset.object,
+        m as DatasetMeasure & { duration: NonNullable<DatasetMeasure['duration']> },
+        options?.declaredValueShape,
+      );
+      if (m.filter) measureFilters[m.name] = m.filter;
+      continue;
+    }
     if (m.field) assertDeclared(m.field, 'measure', m.name);
     // [#16737 / #16099] …and the aggregate ITSELF must be one the field's
     // declared type can carry. Placed after the join-declaration check so a
@@ -755,5 +837,6 @@ export function compileDataset(
     derived,
     filter: dataset.filter,
     measureFilters,
+    durations,
   };
 }
@@ -17,6 +17,7 @@ export type {
 
 import type { FilterCondition, ValueShapeFieldDef } from '@objectstack/spec/data';
 import type { IObjectQLEngine, StrategyContext } from '@objectstack/spec/contracts';
+import type { DATASET_DURATION_AGGREGATES, DatasetDurationUnitValue } from '@objectstack/spec/ui';
 
 /**
  * [#19995] The engine's judge-only `where` admission, as the contract declares
@@ -65,6 +66,35 @@ export interface DatasetScope {
   filter?: FilterCondition;
   /** Per-measure scoped filters, keyed by measure name. */
   measureFilters?: Record<string, FilterCondition>;
+  /**
+   * [#25778] The dataset's duration measures, keyed by measure name — the
+   * second half of a compiled dataset the Cube cannot carry. A cube metric
+   * names ONE column; a duration reads two, so a duration measure is
+   * deliberately ABSENT from `cube.measures` and present here only.
+   *
+   * Absent rather than approximated, so it fails closed: a reader that does
+   * not know this channel finds no such measure and refuses it (`INVALID_FIELD`
+   * / 400), where a cube metric standing in for it (an aggregate over one of
+   * its columns) would have answered an instant, or the average year (#16737),
+   * under the duration's name. The readers that DO serve it: the native-SQL
+   * strategy (`duration-measure-sql.ts`), the draft-preview evaluator, and the
+   * service's own gates (the field-level read gate, the measure mint, the
+   * strategy-route refusal).
+   */
+  measureDurations?: Record<string, DurationMeasureSpec>;
+}
+
+/**
+ * [#25778] One compiled duration measure: the time from `from` to `to` — two
+ * `datetime` columns of the dataset's base object — on each record, in `unit`,
+ * reduced by `aggregate`. The dataset's `duration` key (`@objectstack/spec/ui`,
+ * `DatasetMeasureDurationSchema`) with the measure's aggregate beside it.
+ */
+export interface DurationMeasureSpec {
+  aggregate: (typeof DATASET_DURATION_AGGREGATES)[number];
+  from: string;
+  to: string;
+  unit: DatasetDurationUnitValue;
 }
 
 /** A {@link StrategyContext} that can answer for a compiled dataset (#10298). */
 
@@ -416,11 +416,15 @@
     "ui/DatasetMeasure:aggregate",
     "ui/DatasetMeasure:currency",
     "ui/DatasetMeasure:derived",
+    "ui/DatasetMeasure:duration",
     "ui/DatasetMeasure:field",
     "ui/DatasetMeasure:filter",
     "ui/DatasetMeasure:format",
     "ui/DatasetMeasure:label",
     "ui/DatasetMeasure:name",
+    "ui/DatasetMeasureDuration:from",
+    "ui/DatasetMeasureDuration:to",
+    "ui/DatasetMeasureDuration:unit",
     "ui/DocNavItem:badge",
     "ui/DocNavItem:badgeVariant",
     "ui/DocNavItem:book",
 
@@ -47,7 +47,9 @@
     "ui/DashboardWidgetOptions",
     "ui/Dataset",
     "ui/DatasetDimension",
+    "ui/DatasetDurationUnit",
     "ui/DatasetMeasure",
+    "ui/DatasetMeasureDuration",
     "ui/DerivedMeasureOp",
     "ui/DocNavItem",
     "ui/ElementApiDataSource",
 
@@ -298,16 +298,6 @@ export const DatasetMeasureDurationSchema = lazySchema(() => strictObject({
   unit: DatasetDurationUnit
     .describe('Unit of the result: the measure answers a number of these (1.5 with "days" is a day and a half).')
     .meta({ title: 'Unit' }),
-}).superRefine((duration, ctx) => {
-  if (duration.from === duration.to) {
-    ctx.addIssue({
-      code: 'custom',
-      path: ['to'],
-      message:
-        `\`from\` and \`to\` both name "${duration.from}", so every record's duration is zero. `
-        + 'Name the two instants the duration spans — e.g. `from: \'submitted_at\'`, `to: \'activated_at\'`.',
-    });
-  }
 }));
 
 /**
@@ -522,6 +512,17 @@ export const DatasetMeasureSchema = lazySchema(() => strictObject({
           + 'two instants are set).',
       });
     }
+    // Judged here rather than on the duration spec itself, so the published
+    // JSON Schema keeps ONE dropped-refinement site for the measure.
+    if (measure.duration.from === measure.duration.to) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['duration', 'to'],
+        message:
+          `\`duration.from\` and \`duration.to\` both name "${measure.duration.from}", so every record's duration `
+          + 'is zero. Name the two instants the duration spans — e.g. `from: \'submitted_at\'`, `to: \'activated_at\'`.',
+      });
+    }
     if (measure.currency !== undefined) {
       ctx.addIssue({
         code: 'custom',