@@ -0,0 +1,13 @@
+---
+'@objectstack/service-analytics': patch
+---
+
+fix(service-analytics): an all-NULL `sum` group sorts and pages as the `0` it answers, the same on SQLite and PostgreSQL
+
+Clause-②: no
+Metadata-protocol: none
+
+- **Before.** The native-SQL strategy folded a NULL `sum` (a group whose aggregand is NULL in every row, or a measure-scoped `sum` with no admitted row) to `0` in JavaScript, after the statement had already ordered and paged on the NULL. SQLite sorts NULL lowest and PostgreSQL highest, so `order { total: 'asc' }, limit 2` answered `0` before `-3` on SQLite and cut the `0` group from the page on PostgreSQL. The ObjectQL face answered `-3`, `0`.
+- **Now.** The identity `emptyGroupValueFor` declares is in the statement, `COALESCE(SUM(…), 0)`, so `ORDER BY`, `LIMIT` and `OFFSET` read the value the group answers, on every dialect. The echoed `sql` and `/analytics/sql` show it. `count` is not wrapped: SQL `COUNT` already answers `0` over nothing.
+- **NULL placement is stated.** `avg`, `min` and `max` keep NULL over nothing, and a dimension can hold NULL. On SQLite and PostgreSQL every `ORDER BY` key now carries `NULLS LAST`, in both directions: the ordering the ObjectQL face and the dataset door's post-pass already apply. A host whose dialect is MySQL or unnamed keeps the driver's placement, because no one spelling parses on all of them.
+- **The ObjectQL face's echo states it too.** That face already orders NULL last (`applyOrdering`); its echoed `sql` and `/analytics/sql` now render the same `ORDER BY` as the native face, `NULLS LAST` included, so the printed statement runs to the order the face answered.
@@ -78,7 +78,8 @@ describe('a retired custom-SQL metric type is refused, never emitted', () => {
   it('still wraps the aggregate types', async () => {
     const sql = await sqlFor({ cube: 'orders', measures: ['count', 'total'] });
     expect(sql).toContain('COUNT(*) AS "count"');
-    expect(sql).toContain('SUM(amount) AS "total"');
+    // [#25907] A `sum` answers its empty-group identity in the statement.
+    expect(sql).toContain('COALESCE(SUM(amount), 0) AS "total"');
   });
 });
 
@@ -105,14 +106,14 @@ describe('an expression containing a dot is not mistaken for a join path', () =>
 
   it('emits the expression intact and registers no phantom join', async () => {
     const sql = await dottedSql({ cube: 'orders', measures: ['acct_total'] });
-    expect(sql).toContain('SUM(COALESCE(account.amount, 0) / 2) AS "acct_total"');
+    expect(sql).toContain('COALESCE(SUM(COALESCE(account.amount, 0) / 2), 0) AS "acct_total"');
     expect(sql).not.toContain('"COALESCE(account"');
     expect(sql).not.toContain('LEFT JOIN "COALESCE(account"');
   });
 
   it('still lowers a real relationship path into a qualified column and a join', async () => {
     const sql = await dottedSql({ cube: 'orders', measures: ['acct_amount'] });
-    expect(sql).toContain('SUM("account"."amount") AS "acct_amount"');
+    expect(sql).toContain('COALESCE(SUM("account"."amount"), 0) AS "acct_amount"');
     expect(sql).toContain('LEFT JOIN "account" ON "orders"."account" = "account"."id"');
   });
 });
 
@@ -185,7 +185,8 @@ describe('[#10298] `/api/v1/analytics/query` compiles every per-measure `filter`
     // …and each filtered one carries its own predicate.
     expect(sql).toContain('COUNT(CASE WHEN stage = $1 THEN 1 END) AS "won_count"');
     expect(sql).toContain('COUNT(CASE WHEN stage = $2 THEN 1 END) AS "lost_count"');
-    expect(sql).toContain('SUM(CASE WHEN stage = $3 THEN amount END) AS "won_amount"');
+    // [#25907] A conditional `sum` answers `0` over no admitted row, in the statement.
+    expect(sql).toContain('COALESCE(SUM(CASE WHEN stage = $3 THEN amount END), 0) AS "won_amount"');
 
     // Comparands are BOUND, in the order their placeholders appear. The SELECT
     // list precedes the WHERE clause and `$n` is positional, so a filter
@@ -239,7 +240,7 @@ describe('[#10298] `/api/v1/analytics/query` compiles every per-measure `filter`
       }],
     });
     const { sql, params } = await sqlFor(svc, { cube: 'crm_case', measures: ['count', 'amount_sum'] });
-    expect(sql).toBe('SELECT COUNT(*) AS "count", SUM(amount) AS "amount_sum" FROM "crm_case"');
+    expect(sql).toBe('SELECT COUNT(*) AS "count", COALESCE(SUM(amount), 0) AS "amount_sum" FROM "crm_case"');
     expect(params).toEqual([]);
   });
 });
 
@@ -222,7 +222,8 @@ for (const cell of CELLS) {
       it("the card's row: ordered, offset 1, no limit — both faces answer every row after the first", async () => {
         const native = await ask('native', OFFSET_ONLY);
         expect(native.statements, 'the native face ran ONE statement').toHaveLength(1);
-        expect(native.statements[0].endsWith(`ORDER BY "note" ASC${cell.noLimit} OFFSET 1`), native.statements[0]).toBe(true);
+        // [#25907] The order states its NULL placement on this dialect.
+        expect(native.statements[0].endsWith(`ORDER BY "note" ASC NULLS LAST${cell.noLimit} OFFSET 1`), native.statements[0]).toBe(true);
         expect(tuples(native.res.rows, ['note', 'amount_sum']), 'native face').toEqual(AFTER_FIRST);
 
         const objectql = await ask('objectql', OFFSET_ONLY);
@@ -253,7 +254,7 @@ for (const cell of CELLS) {
       it('CONTROL: an integer window keeps its bytes — `LIMIT 2 OFFSET 1` — and both faces agree', async () => {
         const query = { ...OFFSET_ONLY, limit: 2 };
         const native = await ask('native', query);
-        expect(native.statements[0].endsWith('ORDER BY "note" ASC LIMIT 2 OFFSET 1'), native.statements[0]).toBe(true);
+        expect(native.statements[0].endsWith('ORDER BY "note" ASC NULLS LAST LIMIT 2 OFFSET 1'), native.statements[0]).toBe(true);
         expect(tuples(native.res.rows, ['note', 'amount_sum'])).toEqual([['x', 15], ['y', 20]]);
         const objectql = await ask('objectql', query);
         expect(tuples(objectql.res.rows, ['note', 'amount_sum'])).toEqual([['x', 15], ['y', 20]]);
 
@@ -234,7 +234,7 @@ describe('[#10413] the three doors on one dataset', () => {
     expect(sql).toContain('is_deleted = $');
     // ...and one conditional aggregate per measure-scoped filter.
     expect(sql).toContain('THEN 1 END) AS "won_count"');
-    expect(sql).toContain('THEN amount END) AS "won_amount"');
+    expect(sql).toContain('THEN amount END), 0) AS "won_amount"');
   });
 
   it('the DASHBOARD door answers the fully-declared numbers (it always did)', async () => {
@@ -326,7 +326,7 @@ describe('[#10413 phase 2] per-measure filters lower into the aggregation they b
     const svc = sqlService([OPPORTUNITY_METRICS]);
     const { sql } = await svc.generateSql({ cube: 'opportunity_metrics', measures: MEASURES });
     expect(sql).toContain('THEN 1 END) AS "won_count"');
-    expect(sql).toContain('THEN amount END) AS "won_amount"');
+    expect(sql).toContain('THEN amount END), 0) AS "won_amount"');
   });
 });
 
 
@@ -208,7 +208,8 @@ for (const cell of CELLS) {
         expect(tuples(objectql.res.rows, ['note', 'amount_sum']), 'ObjectQL face').toEqual(AFTER_FIRST);
 
         const echo = objectql.res.sql!;
-        expect(echo.endsWith(`ORDER BY "note" ASC${cell.noLimit} OFFSET 1`), echo).toBe(true);
+        // [#25907] The echo states the NULL placement the face applies, on this dialect.
+        expect(echo.endsWith(`ORDER BY "note" ASC NULLS LAST${cell.noLimit} OFFSET 1`), echo).toBe(true);
         // `generateSql` is the body `POST /analytics/sql` answers with.
         const dryRun = await services.objectql!.generateSql!(OFFSET_ONLY as any);
         expect(dryRun.sql).toBe(echo);
@@ -237,7 +238,7 @@ for (const cell of CELLS) {
       it('CONTROL: an integer window keeps its bytes — `LIMIT 2 OFFSET 1` — and the echo runs', async () => {
         const query = { ...OFFSET_ONLY, limit: 2 };
         const { res } = await ask('objectql', query);
-        expect(res.sql!.endsWith('ORDER BY "note" ASC LIMIT 2 OFFSET 1'), res.sql).toBe(true);
+        expect(res.sql!.endsWith('ORDER BY "note" ASC NULLS LAST LIMIT 2 OFFSET 1'), res.sql).toBe(true);
         expect(tuples(res.rows, ['note', 'amount_sum'])).toEqual([['x', 15], ['y', 20]]);
         expect(tuples(await run(res.sql!), ['note', 'amount_sum'])).toEqual([['x', 15], ['y', 20]]);
       });
 
@@ -29,10 +29,11 @@
  * ## What "equal to the native face" covers
  *
  * The face orders with the package's one row comparator (`applyOrdering`).
- * The native face's `ORDER BY` follows the driver: SQLite sorts NULL lowest and
- * PostgreSQL highest, and text follows the column collation. The fixtures
- * below therefore carry no NULL, no `''`, no numeric text and no mixed case in
- * an ordered column, which is where the two faces agree on both drivers.
+ * The native face's `ORDER BY` text follows the column collation, and its NULL
+ * placement is stated (`NULLS LAST` on SQLite and PostgreSQL, #25907, pinned
+ * in `native-sql-empty-sum-order-window.test.ts`). The fixtures below carry no
+ * NULL, no `''`, no numeric text and no mixed case in an ordered column, which
+ * is where the two faces agree on both drivers.
  *
  * ## The dialect axis of THIS file
  *
@@ -315,7 +316,8 @@ for (const cell of CELLS) {
       it('the echoed sql, run on the same driver, answers the rows the ObjectQL face answered', async () => {
         const query = { cube: CUBE, measures: ['amount_sum'], dimensions: ['note'], order: { amount_sum: 'desc' }, offset: 1, limit: 2 };
         const { res } = await ask('objectql', query);
-        expect(res.sql).toContain('ORDER BY "amount_sum" DESC LIMIT 2 OFFSET 1');
+        // [#25907] The echo states the NULL placement the face applies.
+        expect(res.sql).toContain('ORDER BY "amount_sum" DESC NULLS LAST LIMIT 2 OFFSET 1');
         const ran = (await driver.execute(res.sql)) as unknown;
         const echoed = Array.isArray(ran) ? ran : (ran as { rows: Row[] }).rows;
         expect(tuples(res.rows, ['note', 'amount_sum'])).toEqual(tuples(echoed, ['note', 'amount_sum']));
 
@@ -245,6 +245,76 @@ export function windowClauseSql(
   return sql;
 }
 
+/**
+ * [#25907] The NULL placement an `ORDER BY` key states, per dialect — `null`
+ * where the dialect has no spelling for it, so the driver's placement stands.
+ *
+ * A key can still order a NULL after the empty-group identity moved into the
+ * statement ({@link withEmptyGroupIdentity}): an aggregate with no identity
+ * (`avg`, `min`, `max`) over nothing, and a NULL dimension value. Left to the
+ * driver, SQLite sorts it lowest and PostgreSQL highest, so the same sorted,
+ * paged query answered a different page per dialect; and the dataset door's
+ * post-pass re-sorts a pushed-down page with `applyOrdering`, which keeps NULL
+ * last in both directions, so on SQLite the window was cut on one order and
+ * shown in another. The stated placement is that comparator's: last, in both
+ * directions, the order the ObjectQL face answers too.
+ *
+ * MySQL has no `NULLS LAST`, and `unknown` covers it among others (see
+ * {@link OFFSET_ONLY_LIMIT_SQL}); no one spelling parses on every dialect it
+ * covers, so those two keep the driver's placement. ⛔ An `IS NULL` sort
+ * expression is not that spelling: PostgreSQL resolves a name inside an
+ * expression against the INPUT columns, never the select alias, so a measure
+ * aliased like a column would sort on that column. ⚠️ The `mysql` cell is NOT
+ * MEASURED, the same declared skip as {@link OFFSET_ONLY_LIMIT_SQL}'s.
+ */
+const NULLS_LAST_SQL: Readonly<Record<AnalyticsSqlDialect, string | null>> = {
+  sqlite: 'NULLS LAST',
+  postgres: 'NULLS LAST',
+  mysql: null,
+  unknown: null,
+};
+
+/**
+ * [#25907] The `ORDER BY` clause a statement carries for `order`, for
+ * `dialect`, or `''` for no order. Each key names a select alias and states
+ * the dialect's NULL placement ({@link NULLS_LAST_SQL}).
+ */
+export function orderClauseSql(
+  order: Readonly<Record<string, 'asc' | 'desc'>> | undefined,
+  dialect: AnalyticsSqlDialect,
+): string {
+  const keys = Object.entries(order ?? {});
+  if (keys.length === 0) return '';
+  const nulls = NULLS_LAST_SQL[dialect];
+  return ` ORDER BY ${keys
+    .map(([member, dir]) => `"${member}" ${dir.toUpperCase()}${nulls ? ` ${nulls}` : ''}`)
+    .join(', ')}`;
+}
+
+/**
+ * [#25907, #21042] An aggregate's SQL, answering the identity the platform
+ * declares for it over NOTHING (`emptyGroupValueFor`, spec
+ * `data/aggregation-policy.ts`) where SQL answers NULL.
+ *
+ * `SUM` over a group whose aggregand is NULL in every row, or over no row a
+ * measure-scoped filter admits, is NULL in SQL; summing nothing is `0`, the
+ * answer the engine and the ObjectQL face give (#15546). This face folded the
+ * NULL in JavaScript after the rows came back, by which time `ORDER BY` and
+ * `LIMIT` / `OFFSET` had placed and paged it as a NULL: the folded `0` sat
+ * where no `0` sorts, and the page differed per dialect. `COALESCE` in the
+ * select list puts the identity where the sort and the window read it, on
+ * every dialect, and the echoed statement says so.
+ *
+ * Read from the policy, never restated, so `avg` / `min` / `max` (no identity)
+ * keep their NULL. `count` / `count_distinct` are not wrapped: SQL `COUNT`
+ * answers `0` over nothing on every dialect, the identity already.
+ */
+function withEmptyGroupIdentity(aggregate: string, aggregateSql: string): string {
+  const identity = emptyGroupValueFor(aggregate);
+  if (identity === undefined || aggregate === 'count' || aggregate === 'count_distinct') return aggregateSql;
+  return `COALESCE(${aggregateSql}, ${identity})`;
+}
+
 /**
  * A dot-separated chain of bare identifiers — `amount`, `account.amount`,
  * `account.owner.region`. Distinguishes a relationship PATH, which
@@ -1087,33 +1157,13 @@ export class NativeSQLStrategy implements AnalyticsStrategy {
 
     const rows = await ctx.executeRawSql!(objectName, sql, params);
 
-    // [#21042, #15546] A measure whose aggregate answers NULL over nothing — SQL
-    // `SUM` over a group whose aggregand is NULL in every row, or over no row a
-    // measure-scoped filter admits — answers the identity the platform declares
-    // for that aggregate over NOTHING (`emptyGroupValueFor`, spec
-    // `data/aggregation-policy.ts`): summing nothing is `0`, a measured fact.
-    // The engine and the ObjectQL face fold it (`driver-sql`'s
-    // `foldEmptyAggregateAnswers`, the rows path); this face answered `null` for
-    // the same group. Read from the policy, never restated, for EVERY measure —
-    // a measure-scoped one carries its aggregate in the same `type` — so
-    // `avg` / `min` / `max` (no identity, `undefined`) keep their NULL. Only `null` folds, before the
-    // presenter, in `driver-sql`'s order: an `undefined` would be a column
-    // never projected, a different defect that must stay visible. The dataset
+    // [#21042, #15546 → #25907] A measure whose aggregate answers NULL over
+    // nothing answers the identity the platform declares for it
+    // (`emptyGroupValueFor`) IN the statement — `withEmptyGroupIdentity`, at the
+    // measure's compile — never here: folded after the rows came back, the
+    // `ORDER BY` and window had already placed and paged the NULL. The dataset
     // door's `DatasetExecutor` fill still runs after this and is idempotent on
-    // a folded row.
-    const folds: Array<readonly [string, number]> = [];
-    for (const member of query.measures ?? []) {
-      const identity = emptyGroupValueFor(this.lookupMember(cube, member, 'measure')?.type);
-      if (identity !== undefined) folds.push([member, identity]);
-    }
-    if (folds.length > 0 && Array.isArray(rows)) {
-      for (const row of rows) {
-        if (!row || typeof row !== 'object') continue;
-        for (const [member, identity] of folds) {
-          if (row[member] === null) row[member] = identity;
-        }
-      }
-    }
+    // an answered identity.
 
     // [#20889] A measure column `fields[]` declares `number` answers a number,
     // on every dialect. The SQL client hands an aggregate back as the wire type
@@ -1443,13 +1493,12 @@ export class NativeSQLStrategy implements AnalyticsStrategy {
     if (groupByClauses.length > 0) {
       sql += ` GROUP BY ${groupByClauses.join(', ')}`;
     }
-    if (query.order && Object.keys(query.order).length > 0) {
-      const orderClauses = Object.entries(query.order).map(([f, d]) => `"${f}" ${d.toUpperCase()}`);
-      sql += ` ORDER BY ${orderClauses.join(', ')}`;
-    }
     // [#21365] The dialect of the driver `execute()` hands this statement to —
-    // the base object's, the one `executeRawSql` is called with.
-    sql += windowClauseSql(query.limit, query.offset, sqlDialectFor(ctx, this.extractObjectName(cube)));
+    // the base object's, the one `executeRawSql` is called with. [#25907] The
+    // order states its NULL placement in it.
+    const dialect = sqlDialectFor(ctx, this.extractObjectName(cube));
+    sql += orderClauseSql(query.order, dialect);
+    sql += windowClauseSql(query.limit, query.offset, dialect);
 
     return { sql, params };
   }
@@ -1744,7 +1793,7 @@ export class NativeSQLStrategy implements AnalyticsStrategy {
 
     if (predicate !== null) {
       const wrapConditional = CONDITIONAL_AGGREGATE_SQL[aggregate];
-      if (wrapConditional) return wrapConditional(col, predicate);
+      if (wrapConditional) return withEmptyGroupIdentity(aggregate, wrapConditional(col, predicate));
       // [#10298] Deliberately BARE — an undeclared 500, the tier
       // {@link aggregateOfMeasure} answers in. The conditional table is keyed
       // identically to {@link AGGREGATE_SQL} (`aggregation-lockstep.test.ts`),
@@ -1763,7 +1812,7 @@ export class NativeSQLStrategy implements AnalyticsStrategy {
     // {@link aggregateOfMeasure} admitted `aggregate` FROM this table, and
     // refused (bare, undeclared 500, the spec's own words) every type it does
     // not key, before anything was lowered.
-    return AGGREGATE_SQL[aggregate](col);
+    return withEmptyGroupIdentity(aggregate, AGGREGATE_SQL[aggregate](col));
   }
 
   private resolveFieldSql(