feat(spec): boolean aggregand column in the aggregation conformance fixture — ruled numeric min/max on every face (#12947)

* feat(spec): boolean aggregand column in the aggregation conformance fixture, ruled numeric on every face

Adds flag (3 true / 3 false, the FLAG_BY_ID distribution) to AGGREGATION_ROWS
with seven ruled cases (sum=3, avg=0.5, min=0, max=1, count=6,
count_distinct=2, grouped min east=1/west=0), extends the three SQL harness
DDLs, aligns min/max over booleans to the numeric domain on every face per the
2026-08-28 maintainer ruling (option A, superseding #11249's false/true):
objectql in-memory fallback, driver-memory data + analytics faces, driver-sql
result presentation (boolean kind skipped for min/max), driver-mongodb
lowering (numericAggregandExpr on min/max). FLAG_BY_ID private maps deleted in
favour of the fixture column; ruling-B pins in the 11635/11151 suites flipped
to the ruled 0/1.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LpRNHxWZgSUgVnFT9mQQo4

* chore: changeset for the ruled numeric boolean min/max

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LpRNHxWZgSUgVnFT9mQQo4

* test: flip the two remaining ruling-B boolean min/max pins to the ruled 0/1

The 11782 cross-door parity suite keeps every row-read boolean pin (find,
distinct, group keys — NOT superseded) and asserts the ruled numbers on the
two order-statistic cells; the mongodb pipeline-builder unit test pins the
boolean-only coercion wrapper on min/max stages, the same shape it already
pins for sum/avg. Pin sweep across driver-sql/mongodb/memory/objectql/rest/qa
surfaced no third file.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LpRNHxWZgSUgVnFT9mQQo4

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: Trump

.changeset/boolean-aggregands-numeric-min-max.md

@@ -0,0 +1,13 @@
+---
+'@objectstack/spec': patch
+'@objectstack/driver-sql': patch
+'@objectstack/driver-memory': patch
+'@objectstack/driver-mongodb': patch
+'@objectstack/objectql': patch
+---
+
+`min`/`max` over a **boolean** aggregand now answer the numbers `0`/`1` on every face — maintainer ruling 2026-08-28 (#11152, option A), superseding #11249's `false`/`true`: booleans aggregate as numbers, with no per-aggregate exception, so one flag column's `sum`/`avg`/`min`/`max` all answer in one numeric domain.
+
+FROM → TO, per face: `driver-sql` (every dialect, `driver-sqlite-wasm` included via the shared compiler) no longer re-presents `min`/`max` results over a declared boolean as JSON booleans — `false`/`true` → `0`/`1`; row reads (`find()`) still present booleans, and `min`/`max` over an empty window still answer `null`. `driver-memory` (data and analytics faces) and objectql's in-memory fallback compare booleans as the numbers they are worth — `false`/`true` → `0`/`1`; strings, dates and numbers reach the same comparison they always did. `driver-mongodb` wraps `$min`/`$max` in the same boolean-only `$cond` coercion `$sum`/`$avg` use — `false`/`true` → `0`/`1`; null/missing still pass through, so the empty window still answers `null`. A caller reading `min`/`max` over a boolean column as a JSON boolean should read the number (`0` is false-y, `1` truthy, so boolean coercion at the call site keeps working).
+
+The cross-driver aggregation conformance fixture (`AGGREGATION_ROWS`, `@objectstack/spec/data`) now carries the boolean column those rulings are pinned by: `flag` (3 true / 3 false), with cases for `sum`=3, `avg`=0.5, `min`=0, `max`=1, `count`=6, `count_distinct`=2 and a grouped `min` over the deliberately asymmetric groups — the reach gap #11065 and #11151 were both found through (a boolean aggregand no conformance cell could see) is closed.

packages/drivers/driver-memory/src/memory-analytics.ts

@@ -482,7 +482,9 @@ function sizeDistinctSet(values: readonly unknown[]): number {
 
 /**
  * [#11065] `path`, with a BOOLEAN rendered as the number it is worth — the
- * aggregand expression `$sum` and `$avg` consume on this face.
+ * aggregand expression `$sum` and `$avg` consume on this face, and, since the
+ * #11152 ruling (maintainer 2026-08-28: booleans aggregate as numbers on every
+ * face, no per-aggregate exception), `$min` and `$max` as well.
  *
  * ## What it is for
  *
@@ -1241,10 +1243,20 @@ export class MemoryAnalyticsService implements IAnalyticsService {
         return { $sum: numericAggregandExpr(`$${fieldPath}`) };
       case 'avg':
         return { $avg: numericAggregandExpr(`$${fieldPath}`) };
+      // [#11152] `min`/`max` take the SAME boolean coercion as `sum`/`avg` —
+      // maintainer ruling 2026-08-28 (superseding #11249's `false`/`true`):
+      // booleans aggregate as NUMBERS on every face, no per-aggregate
+      // exception, so a boolean measure's order statistics answer 0/1. mingo's
+      // `$min`/`$max` rank whatever the expression yields, so the coerced
+      // number is what gets ranked; every non-boolean value passes through the
+      // `$cond` untouched and is ranked exactly as before. The data face
+      // carries the identical rule in JavaScript (`memory-driver.ts`,
+      // `computeAggregate`) — one face aligned alone is how this package's
+      // faces come to disagree.
       case 'min':
-        return { $min: `$${fieldPath}` };
+        return { $min: numericAggregandExpr(`$${fieldPath}`) };
       case 'max':
-        return { $max: `$${fieldPath}` };
+        return { $max: numericAggregandExpr(`$${fieldPath}`) };
       case 'count_distinct':
         // Collects the distinct values; {@link sizeDistinctSet} turns the array
         // into the NUMBER, excluding null — see the note there for why the

packages/drivers/driver-memory/src/memory-boolean-aggregand.test.ts

@@ -215,6 +215,32 @@ describe('[#11065] InMemoryDriver data face — a boolean aggregand is worth 1 o
     }) as any[];
     expect(row.rate).toBeNull();
   });
+
+  /**
+   * [#11152] `min`/`max` join the numeric family — maintainer ruling
+   * 2026-08-28 (superseding #11249's `false`/`true`): booleans aggregate as
+   * NUMBERS on every face, no per-aggregate exception. Asserted STRICTLY
+   * (`toBe(0)`/`toBe(1)`): the superseded booleans satisfy a `Number()`
+   * reading, so a coerced comparison would pass on exactly the wrong
+   * spelling. Grouped: the open group is all-true, so its `min` is `1` — a
+   * whole-table computation or a sticky `0` fails there and only there.
+   */
+  it('min/max over the boolean answer the NUMBERS 0/1, ungrouped and grouped', async () => {
+    const [row] = await driver.aggregate(TABLE, {
+      aggregations: [
+        { function: 'min', field: 'is_sla_violated', alias: 'lo' },
+        { function: 'max', field: 'is_sla_violated', alias: 'hi' },
+      ],
+    }) as any[];
+    expect(row.lo).toBe(0);
+    expect(row.hi).toBe(1);
+    const rows = await driver.aggregate(TABLE, {
+      groupBy: ['is_closed'],
+      aggregations: [{ function: 'min', field: 'is_sla_violated', alias: 'lo' }],
+    }) as any[];
+    const byClosed = Object.fromEntries(rows.map((r) => [String(r.is_closed), r.lo]));
+    expect(byClosed).toEqual({ true: 0, false: 1 });
+  });
 });
 
 /**
@@ -235,6 +261,8 @@ describe('[#11065] the analytics face answers the same rate', () => {
     measures: {
       slaViolationRate: { name: 'sla_violation_rate', label: 'SLA Violation Rate', type: 'avg', sql: 'is_sla_violated' },
       slaViolations: { name: 'sla_violations', label: 'SLA Violations', type: 'sum', sql: 'is_sla_violated' },
+      minViolated: { name: 'min_violated', label: 'Min violated', type: 'min', sql: 'is_sla_violated' },
+      maxViolated: { name: 'max_violated', label: 'Max violated', type: 'max', sql: 'is_sla_violated' },
       count: { name: 'count', label: 'Cases', type: 'count', sql: 'id' },
       avgNote: { name: 'avg_note', label: 'Avg note', type: 'avg', sql: 'note' },
     },
@@ -288,6 +316,23 @@ describe('[#11065] the analytics face answers the same rate', () => {
     expect(byClosed).toEqual({ true: [0.25, 4], false: [1, 1] });
   });
 
+  /**
+   * [#11152] The mingo route answers the same ruled numbers — the `$min`/
+   * `$max` arms wrap `numericAggregandExpr` exactly as `$sum`/`$avg` do, and
+   * one face aligned alone is how this package's faces come to disagree.
+   * Strict for the data-face reason: the superseded `false`/`true` (#11249)
+   * satisfies any coerced reading.
+   */
+  it('min/max over the boolean answer the NUMBERS 0/1 here too', async () => {
+    const result = await service.query({
+      cube: 'cases',
+      measures: ['cases.minViolated', 'cases.maxViolated'],
+    } as any);
+    const row = result.rows[0] as Record<string, unknown>;
+    expect(row['cases.minViolated']).toBe(0);
+    expect(row['cases.maxViolated']).toBe(1);
+  });
+
   /** The same narrowness guard the data face carries: text stays excluded. */
   it('a non-numeric text column is still excluded here too', async () => {
     const result = await service.query({ cube: 'cases', measures: ['cases.avgNote'] } as any);

packages/drivers/driver-memory/src/memory-driver.ts

@@ -1342,16 +1342,30 @@ export class InMemoryDriver implements IDataDriver {
               return nums.length > 0 ? sum / nums.length : null;
           }
 
+          // [#11152] `min`/`max` read a BOOLEAN as the number it is worth —
+          // maintainer ruling 2026-08-28 (superseding #11249's `false`/`true`):
+          // booleans aggregate as NUMBERS on every face, no per-aggregate
+          // exception, so the order statistics answer 0/1 in the same numeric
+          // domain the `sum`/`avg` arms above already answer in. The coercion
+          // is BOOLEAN-ONLY for the same reason theirs is: strings and dates
+          // reach the same raw comparison they always did. The analytics face
+          // carries the identical rule in its `$min`/`$max` mingo arms
+          // (`memory-analytics.ts`, `buildAggregator`) — one face aligned
+          // alone leaves the other free to keep its own answer.
           case 'min': {
               // Handle comparable values
-              const valid = values.filter(v => v !== null && v !== undefined);
+              const valid = values
+                  .filter(v => v !== null && v !== undefined)
+                  .map(v => (typeof v === 'boolean' ? (v ? 1 : 0) : v));
               if (valid.length === 0) return null;
               // Works for numbers and strings
               return valid.reduce((min, v) => (v < min ? v : min), valid[0]);
           }
 
           case 'max': {
-              const valid = values.filter(v => v !== null && v !== undefined);
+              const valid = values
+                  .filter(v => v !== null && v !== undefined)
+                  .map(v => (typeof v === 'boolean' ? (v ? 1 : 0) : v));
               if (valid.length === 0) return null;
               return valid.reduce((max, v) => (v > max ? v : max), valid[0]);
           }