@noy-db/hub 0.7.1-pre.0 → 0.8.0

package/dist/chunk-MBMTND6D.js

@@ -0,0 +1,456 @@
+import {
+  distinctKeyOf
+} from "./chunk-SUZKW6UR.js";
+import {
+  readPath
+} from "./chunk-5WWDGFOS.js";
+
+// src/with-lookup/reduce/reducers.ts
+function count(opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "count",
+    init: () => 0,
+    step: (state) => state + 1,
+    remove: (state) => state - 1,
+    finalize: (state) => state,
+    merge: (a, b) => a + b
+  };
+}
+function countDistinct(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  const via = opts?.canonicalize;
+  const keyOf = (record) => distinctKeyOf(field, readPath(record, field), via);
+  return {
+    op: "countDistinct",
+    field,
+    init: () => ({ counts: /* @__PURE__ */ new Map() }),
+    step: (state, record) => {
+      const key = keyOf(record);
+      if (key === void 0) return state;
+      const counts = new Map(state.counts);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+      return { counts };
+    },
+    remove: (state, record) => {
+      const key = keyOf(record);
+      if (key === void 0) return state;
+      const current = state.counts.get(key);
+      if (current === void 0) return state;
+      const counts = new Map(state.counts);
+      if (current <= 1) counts.delete(key);
+      else counts.set(key, current - 1);
+      return { counts };
+    },
+    finalize: (state) => state.counts.size,
+    merge: (a, b) => {
+      const counts = new Map(a.counts);
+      for (const [k, n] of b.counts) counts.set(k, (counts.get(k) ?? 0) + n);
+      return { counts };
+    }
+  };
+}
+function bindDistinctReducers(spec, via) {
+  if (!via) return spec;
+  const entries = Object.entries(spec);
+  let changed = false;
+  const out = {};
+  for (const [key, reducer] of entries) {
+    if (reducer?.op === "countDistinct" && typeof reducer.field === "string") {
+      out[key] = countDistinct(reducer.field, { canonicalize: via });
+      changed = true;
+    } else {
+      out[key] = reducer;
+    }
+  }
+  return changed ? out : spec;
+}
+function sum(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "sum",
+    field,
+    // Money-only metadata, read by `wrapMoneyReducers`. No effect on a
+    // generic numeric sum.
+    ...opts?.convertTo !== void 0 ? { convertTo: opts.convertTo } : {},
+    ...opts?.fx !== void 0 ? { fx: opts.fx } : {},
+    init: () => 0,
+    step: (state, record) => state + readNumber(record, field),
+    remove: (state, record) => state - readNumber(record, field),
+    finalize: (state) => state,
+    merge: (a, b) => a + b
+  };
+}
+function avg(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "avg",
+    field,
+    init: () => ({ sum: 0, count: 0 }),
+    step: (state, record) => ({
+      sum: state.sum + readNumber(record, field),
+      count: state.count + 1
+    }),
+    remove: (state, record) => ({
+      sum: state.sum - readNumber(record, field),
+      count: state.count - 1
+    }),
+    finalize: (state) => state.count === 0 ? null : state.sum / state.count,
+    merge: (a, b) => ({ sum: a.sum + b.sum, count: a.count + b.count })
+  };
+}
+function pushValue(state, value) {
+  return { values: [...state.values, value] };
+}
+function removeValue(state, value) {
+  const idx = state.values.indexOf(value);
+  if (idx < 0) return state;
+  const next = state.values.slice();
+  next.splice(idx, 1);
+  return { values: next };
+}
+function min(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "min",
+    field,
+    init: () => ({ values: [] }),
+    step: (state, record) => pushValue(state, readNumber(record, field)),
+    remove: (state, record) => removeValue(state, readNumber(record, field)),
+    finalize: (state) => {
+      if (state.values.length === 0) return null;
+      let out = state.values[0];
+      for (let i = 1; i < state.values.length; i++) {
+        const v = state.values[i];
+        if (v < out) out = v;
+      }
+      return out;
+    },
+    merge: (a, b) => ({ values: [...a.values, ...b.values] })
+  };
+}
+function max(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "max",
+    field,
+    init: () => ({ values: [] }),
+    step: (state, record) => pushValue(state, readNumber(record, field)),
+    remove: (state, record) => removeValue(state, readNumber(record, field)),
+    finalize: (state) => {
+      if (state.values.length === 0) return null;
+      let out = state.values[0];
+      for (let i = 1; i < state.values.length; i++) {
+        const v = state.values[i];
+        if (v > out) out = v;
+      }
+      return out;
+    },
+    merge: (a, b) => ({ values: [...a.values, ...b.values] })
+  };
+}
+function welfordReducer(op, field, population) {
+  return {
+    op,
+    field,
+    init: () => ({ n: 0, mean: 0, m2: 0 }),
+    step: (state, record) => {
+      const x = readNumber(record, field);
+      const n = state.n + 1;
+      const delta = x - state.mean;
+      const mean = state.mean + delta / n;
+      return { n, mean, m2: state.m2 + delta * (x - mean) };
+    },
+    remove: (state, record) => {
+      const x = readNumber(record, field);
+      const n = state.n - 1;
+      if (n <= 0) return { n: 0, mean: 0, m2: 0 };
+      const mean = (state.mean * state.n - x) / n;
+      return { n, mean, m2: state.m2 - (x - state.mean) * (x - mean) };
+    },
+    // Chan et al.'s parallel combination — the reason a reduction can be
+    // sharded and rolled up without re-reading the leaves.
+    merge: (a, b) => {
+      if (a.n === 0) return b;
+      if (b.n === 0) return a;
+      const n = a.n + b.n;
+      const delta = b.mean - a.mean;
+      return {
+        n,
+        mean: a.mean + delta * b.n / n,
+        m2: a.m2 + b.m2 + delta * delta * a.n * b.n / n
+      };
+    },
+    finalize: (state) => {
+      const divisor = population ? state.n : state.n - 1;
+      if (divisor <= 0) return null;
+      const v = state.m2 / divisor;
+      return op === "stddev" ? Math.sqrt(v) : v;
+    }
+  };
+}
+function variance(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return welfordReducer("variance", field, opts?.population === true);
+}
+function stddev(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return welfordReducer("stddev", field, opts?.population === true);
+}
+function assertProbability(op, p) {
+  if (!Number.isFinite(p) || p < 0 || p > 1) {
+    throw new Error(`${op}(): p must be a number between 0 and 1, got ${p}.`);
+  }
+}
+function asExact(state) {
+  if (state.kind !== "exact") throw new Error("percentile: expected the exact quantile state");
+  return state;
+}
+function asDigest(state) {
+  if (state.kind !== "tdigest") throw new Error("percentile: expected the t-digest state");
+  return state;
+}
+function quantileOf(values, p) {
+  const n = values.length;
+  if (n === 0) return null;
+  if (n === 1) return values[0];
+  const sorted = [...values].sort((a, b) => a - b);
+  const x = p * (n - 1);
+  const lo = Math.floor(x);
+  const frac = x - lo;
+  if (frac === 0) return sorted[lo];
+  return sorted[lo] + (sorted[lo + 1] - sorted[lo]) * frac;
+}
+var TDIGEST_COMPRESSION = 100;
+var TDIGEST_BUFFER = 256;
+function tdigestFlush(state, force = false) {
+  if (state.buffer.length === 0 && !force) return;
+  const all = state.centroids.concat(state.buffer.map((mean) => ({ mean, count: 1 })));
+  state.buffer = [];
+  if (all.length === 0) return;
+  all.sort((a, b) => a.mean - b.mean);
+  const total = state.n;
+  const out = [];
+  let curMean = all[0].mean;
+  let curCount = all[0].count;
+  let before = 0;
+  for (let i = 1; i < all.length; i++) {
+    const c = all[i];
+    const q = (before + curCount + c.count / 2) / total;
+    const limit = 4 * total * q * (1 - q) / TDIGEST_COMPRESSION;
+    if (curCount + c.count <= Math.max(limit, 1)) {
+      const count2 = curCount + c.count;
+      curMean = curMean + (c.mean - curMean) * c.count / count2;
+      curCount = count2;
+    } else {
+      out.push({ mean: curMean, count: curCount });
+      before += curCount;
+      curMean = c.mean;
+      curCount = c.count;
+    }
+  }
+  out.push({ mean: curMean, count: curCount });
+  state.centroids = out;
+}
+function tdigestQuantile(state, p) {
+  tdigestFlush(state);
+  const cs = state.centroids;
+  if (cs.length === 0) return null;
+  if (cs.length === 1) return cs[0].mean;
+  const centres = [];
+  let acc = 0;
+  for (const c of cs) {
+    centres.push(acc + (c.count - 1) / 2);
+    acc += c.count;
+  }
+  const target = p * (state.n - 1);
+  const last = cs.length - 1;
+  if (target <= centres[0]) return cs[0].mean;
+  if (target >= centres[last]) return cs[last].mean;
+  for (let i = 0; i < last; i++) {
+    const a = centres[i];
+    const b = centres[i + 1];
+    if (target <= b) {
+      const t = b === a ? 0 : (target - a) / (b - a);
+      return cs[i].mean + (cs[i + 1].mean - cs[i].mean) * t;
+    }
+  }
+  return cs[last].mean;
+}
+function exactQuantileReducer(op, field, p) {
+  return {
+    op,
+    field,
+    p,
+    init: () => ({ kind: "exact", values: [] }),
+    step: (state, record) => {
+      asExact(state).values.push(readNumber(record, field));
+      return state;
+    },
+    remove: (state, record) => {
+      const values = asExact(state).values;
+      const idx = values.indexOf(readNumber(record, field));
+      if (idx >= 0) values.splice(idx, 1);
+      return state;
+    },
+    merge: (a, b) => ({ kind: "exact", values: [...asExact(a).values, ...asExact(b).values] }),
+    finalize: (state) => quantileOf(asExact(state).values, p)
+  };
+}
+function approxQuantileReducer(field, p) {
+  return {
+    op: "percentile",
+    field,
+    p,
+    approx: true,
+    init: () => ({ kind: "tdigest", centroids: [], buffer: [], n: 0 }),
+    step: (state, record) => {
+      const d = asDigest(state);
+      d.buffer.push(readNumber(record, field));
+      d.n += 1;
+      if (d.buffer.length >= TDIGEST_BUFFER) tdigestFlush(d);
+      return state;
+    },
+    // No `remove`: a centroid has forgotten which values it absorbed, so an
+    // un-fold is not expressible. Deliberate, and asserted by a test.
+    merge: (a, b) => {
+      const A = asDigest(a);
+      const B = asDigest(b);
+      const s = {
+        kind: "tdigest",
+        centroids: [...A.centroids, ...B.centroids],
+        buffer: [...A.buffer, ...B.buffer],
+        n: A.n + B.n
+      };
+      tdigestFlush(s, true);
+      return s;
+    },
+    finalize: (state) => tdigestQuantile(asDigest(state), p)
+  };
+}
+function median(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return exactQuantileReducer("median", field, 0.5);
+}
+function percentile(field, p, opts) {
+  assertProbability("percentile", p);
+  const _seed = opts?.seed;
+  void _seed;
+  return opts?.approx === true ? approxQuantileReducer(field, p) : exactQuantileReducer("percentile", field, p);
+}
+function mode(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "mode",
+    field,
+    init: () => ({ counts: /* @__PURE__ */ new Map() }),
+    step: (state, record) => {
+      const v = readNumber(record, field);
+      state.counts.set(v, (state.counts.get(v) ?? 0) + 1);
+      return state;
+    },
+    remove: (state, record) => {
+      const v = readNumber(record, field);
+      const current = state.counts.get(v);
+      if (current === void 0) return state;
+      if (current <= 1) state.counts.delete(v);
+      else state.counts.set(v, current - 1);
+      return state;
+    },
+    merge: (a, b) => {
+      const counts = new Map(a.counts);
+      for (const [v, c] of b.counts) counts.set(v, (counts.get(v) ?? 0) + c);
+      return { counts };
+    },
+    finalize: (state) => {
+      let best = null;
+      let bestCount = 0;
+      for (const [v, c] of state.counts) {
+        if (c > bestCount || c === bestCount && best !== null && v < best) {
+          best = v;
+          bestCount = c;
+        }
+      }
+      return best;
+    }
+  };
+}
+function moneySum(field, opts) {
+  return sum(field, opts);
+}
+function moneyMin(field, opts) {
+  return min(field, opts);
+}
+function moneyMax(field, opts) {
+  return max(field, opts);
+}
+function moneyMedian(field, opts) {
+  return median(field, opts);
+}
+function moneyPercentile(field, p, opts) {
+  return percentile(field, p, opts);
+}
+var reducerBuilder = {
+  count,
+  countDistinct,
+  // The generic F parameter on sum/min/max in the interface is type-only; the
+  // standalone factories are plain `(field: string)` functions. With M=never the
+  // conditional return collapses to the numeric branch, matching the factories'
+  // return type, but TypeScript cannot verify that collapse for a generic method
+  // signature — so each factory is cast directly to the method's type.
+  sum,
+  avg,
+  min,
+  max,
+  median,
+  percentile,
+  variance,
+  stddev,
+  mode,
+  moneySum,
+  moneyMin,
+  moneyMax,
+  moneyMedian,
+  moneyPercentile
+};
+function readNumber(record, field) {
+  const value = readPath(record, field);
+  if (typeof value === "object" && value !== null && "amount" in value && "currency" in value) {
+    throw new Error(
+      `aggregate: field "${field}" holds a money value but was not money-aware \u2014 declare it in the collection's moneyFields so sum/min/max stay exact`
+    );
+  }
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+export {
+  count,
+  countDistinct,
+  bindDistinctReducers,
+  sum,
+  avg,
+  min,
+  max,
+  variance,
+  stddev,
+  median,
+  percentile,
+  mode,
+  moneySum,
+  moneyMin,
+  moneyMax,
+  moneyMedian,
+  moneyPercentile,
+  reducerBuilder
+};
+//# sourceMappingURL=chunk-MBMTND6D.js.map

package/dist/chunk-MBMTND6D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-lookup/reduce/reducers.ts"],"sourcesContent":["/**\n * Reduction reducers for the query DSL.\n *\n * the reducer protocol plus five built-in factories\n * (`count`, `sum`, `avg`, `min`, `max`) consumed by `Query.aggregate()`\n * and, in the future, `Scan.aggregate()`. Every factory accepts\n * an optional `{ seed }` parameter that is plumbed through the\n * protocol but unused by the executor — that's the load-bearing\n * half of  constraint #2. When partition-aware reduction\n * lands, the seed carries the previous partition's running total into\n * the next partition without requiring a protocol change.\n *\n * Reducers are intentionally generic over their internal state type\n * `S` so compound reducers (avg keeps `{sum, count}`, min/max keep a\n * value bag) can model internal bookkeeping without leaking the\n * implementation through the accumulator's public shape. `finalize`\n * collapses `S` back into the user-visible `R`.\n *\n * Reducers are pure data — `init` / `step` / `finalize` / optional\n * `remove` are stateless functions that receive and return `S`. This\n * is the shape that admits O(1) incremental maintenance in a future\n * optimization (delta-aware `LiveReduction` applies `step` or\n * `remove` per delta), without blocking the simpler \"full re-run on\n * source change\" that ships.\n */\n\nimport { readPath } from '../../kernel/query/predicate.js'\nimport { distinctKeyOf, type BucketKeyCanonicalizer } from '../../kernel/query/distinct-key.js'\nimport type { MoneyString } from '../../via/money/branded.js'\nimport type { QueryField } from '../../kernel/types.js'\n\n/**\n * A single reducer: factory-produced, ready to plug into an\n * `.aggregate()` spec.\n *\n * Type parameters:\n *   - `R` — user-visible result type (what the reduction returns\n *     for this slot, e.g. `number` for `sum()`)\n *   - `S` — internal state type, defaults to `R` for simple reducers\n *     that don't need compound bookkeeping\n *\n * A reducer is stateless: every method is pure over `S`. `init()` is\n * called once per reduction run to build the initial state; `step()`\n * folds a record into the state; `remove()` (optional) un-folds a\n * record, enabling incremental live maintenance; `finalize()` reads\n * the final answer out of the state at the end of the run.\n */\nexport interface Reducer<R, S = R> {\n  /** Build the initial state for a fresh reduction run. */\n  init(): S\n  /** Fold a record into the state. Returns the new state. */\n  step(state: S, record: unknown): S\n  /**\n   * Un-fold a record from the state. Returns the new state.\n   *\n   * Optional — reducers without `remove` cannot be maintained\n   * incrementally and must be re-run from scratch when the underlying\n   * record set changes. `sum`, `count`, `avg` implement `remove` in\n   * O(1); `min` and `max` implement it in O(N) worst case (when the\n   * extremum itself is removed and the next extremum must be\n   * recomputed from the remaining contributing values).\n   */\n  remove?(state: S, record: unknown): S\n  /** Collapse the internal state into the user-visible result. */\n  finalize(state: S): R\n  /**\n   * Combine two independent partial states into one (then `finalize` once).\n   * Optional. MUST be associative + commutative with `init()` as identity.\n   * Never merge finalized results — only states. Enables parallel /\n   * hierarchical reduction (e.g. cross-shard or advisor→firm rollup).\n   */\n  merge?(a: S, b: S): S\n  /**\n   * Identifying operation tag stamped by each built-in factory.\n   * Used by `summariseAggregateOp` in the introspection walker to\n   * render human-readable aggregate descriptors in `dumpSchema()`.\n   * Optional so third-party custom reducers are unaffected.\n   */\n  readonly op?:\n    | 'count'\n    | 'countDistinct'\n    | 'sum'\n    | 'avg'\n    | 'min'\n    | 'max'\n    | 'median'\n    | 'percentile'\n    | 'variance'\n    | 'stddev'\n    | 'mode'\n  /**\n   * Field name for field-based reducers (`sum`, `avg`, `min`, `max`).\n   * Absent on `count` which aggregates over record count, not a field.\n   */\n  readonly field?: string\n  /**\n   * Money-only: target currency for `sum` over a multi-currency money\n   * field. Consumed by `wrapMoneyReducers` to convert per-currency\n   * subtotals to one figure. Ignored for non-money fields.\n   */\n  readonly convertTo?: string\n  /**\n   * Money-only: FX rate map (`'USD->EUR' → rate`) used with `convertTo`.\n   */\n  readonly fx?: Record<string, number | string>\n  /**\n   * Quantile reducers only (#1353): the probability in `[0, 1]`. Carried as\n   * metadata so `wrapMoneyReducers` can rebuild the reducer on the exact\n   * BigInt path — a rewrite that must reproduce the SAME p, not guess one.\n   * `median` stamps `0.5`.\n   */\n  readonly p?: number\n  /**\n   * `percentile` only (#1353): `true` when the reducer is the bounded-memory\n   * t-digest rather than the exact O(n) one. Read by `wrapMoneyReducers`,\n   * which refuses it over a money field — a t-digest is a float structure.\n   */\n  readonly approx?: boolean\n}\n\n/**\n * Common options accepted by every reducer factory.\n *\n * `seed` — optional initial value for the internal state. **Unused by\n * the executor**, plumbed through the protocol for  constraint\n * #2 (partition-aware reduction seam). In, partitioned\n * reductions will pass the previous partition's carry as `seed` so\n * a long time series can be rolled forward one partition at a time\n * without re-reducing closed partitions.\n *\n * always uses `init()` with the factory's zero value, regardless\n * of whether `seed` was passed. Do not remove the parameter — that's\n * the whole point of having it exist now.\n */\nexport interface ReducerOptions<TSeed = unknown> {\n  /**  constraint #2 — seed is plumbed through but unused in. */\n  readonly seed?: TSeed\n  /**\n   * Money-only (honored by `sum` over a multi-currency money field):\n   * convert per-currency subtotals to this currency for a single figure.\n   */\n  readonly convertTo?: string\n  /** Money-only: FX rate map (`'USD->EUR' → rate`) used with `convertTo`. */\n  readonly fx?: Record<string, number | string>\n}\n\n// ---------------------------------------------------------------------------\n// Factories\n// ---------------------------------------------------------------------------\n\n/**\n * Count the number of records that match the query. Ignores field\n * values entirely — the count is over the number of records, not over\n * the number of non-null field values in any column.\n */\nexport function count(opts?: ReducerOptions<number>): Reducer<number> {\n  // Seed captured on the closure but unused at execution time in\n  //. The reference in _seed keeps lint happy.\n  const _seed = opts?.seed\n  void _seed\n  return {\n    op: 'count',\n    init: () => 0,\n    step: (state) => state + 1,\n    remove: (state) => state - 1,\n    finalize: (state) => state,\n    merge: (a, b) => a + b,\n  }\n}\n\n/**\n * Multiset state behind {@link countDistinct}: canonical distinct key →\n * how many records currently contribute it. The COUNT, not a bare Set, is\n * what makes `remove()` correct — dropping one of three records holding\n * `'c1'` must not drop `'c1'` from the distinct set.\n */\nexport interface CountDistinctState {\n  readonly counts: ReadonlyMap<string, number>\n}\n\n/**\n * Number of DISTINCT non-nullish values of `field` across matching records\n * (#1347) — `COUNT(DISTINCT field)`.\n *\n * Distinctness is decided on the canonical index key, not on the stored\n * string and not on any formatted rendering, so a money field's `'0100'` and\n * `'100'` count once; see `kernel/query/distinct-key.ts` for why, and for why\n * nullish values are excluded rather than counted as a value of their own.\n *\n * The canonicalizer is bound LATE, by {@link bindDistinctReducers}, at the\n * same two points `wrapReducers` runs — a bare `countDistinct('amount')` in a\n * spec has no way to know which collection it will be reduced against, so a\n * constructor argument would be a footgun. Unbound, it falls back to the raw\n * stringified key, which is exactly what a non-Via field wants.\n *\n * Incremental complexity: O(1) `step` and `remove`, O(1) `finalize`.\n */\nexport function countDistinct(\n  field: string,\n  opts?: ReducerOptions<number> & { readonly canonicalize?: BucketKeyCanonicalizer },\n): Reducer<number, CountDistinctState> {\n  const _seed = opts?.seed\n  void _seed\n  const via = opts?.canonicalize\n  const keyOf = (record: unknown): string | undefined =>\n    distinctKeyOf(field, readPath(record, field), via)\n  return {\n    op: 'countDistinct',\n    field,\n    init: () => ({ counts: new Map() }),\n    step: (state, record) => {\n      const key = keyOf(record)\n      if (key === undefined) return state\n      const counts = new Map(state.counts)\n      counts.set(key, (counts.get(key) ?? 0) + 1)\n      return { counts }\n    },\n    remove: (state, record) => {\n      const key = keyOf(record)\n      if (key === undefined) return state\n      const current = state.counts.get(key)\n      if (current === undefined) return state\n      const counts = new Map(state.counts)\n      if (current <= 1) counts.delete(key)\n      else counts.set(key, current - 1)\n      return { counts }\n    },\n    finalize: (state) => state.counts.size,\n    merge: (a, b) => {\n      const counts = new Map(a.counts)\n      for (const [k, n] of b.counts) counts.set(k, (counts.get(k) ?? 0) + n)\n      return { counts }\n    },\n  }\n}\n\n/**\n * Rebind every `countDistinct` reducer in a spec to a Via canonicalizer.\n *\n * Called wherever `ViaPipeline.wrapReducers` is called — the two are the same\n * seam, kept separate only because `wrapReducers` folds over BINDINGS (money\n * rewriting its own `sum`) while this one is brand-agnostic: any binding that\n * canonicalizes an index key canonicalizes a distinct key, by definition.\n *\n * Returns the spec unchanged when there is nothing to bind, so the common\n * path allocates nothing.\n */\nexport function bindDistinctReducers<Spec>(spec: Spec, via: BucketKeyCanonicalizer | undefined): Spec {\n  if (!via) return spec\n  const entries = Object.entries(spec as Record<string, Reducer<unknown, unknown>>)\n  let changed = false\n  const out: Record<string, unknown> = {}\n  for (const [key, reducer] of entries) {\n    if (reducer?.op === 'countDistinct' && typeof reducer.field === 'string') {\n      out[key] = countDistinct(reducer.field, { canonicalize: via })\n      changed = true\n    } else {\n      out[key] = reducer\n    }\n  }\n  return changed ? (out as Spec) : spec\n}\n\n/**\n * Sum a numeric field across all matching records. Non-number values\n * at the field path are coerced to 0 — consumers who want a different\n * behavior (throw, skip, treat as NaN) should filter upstream via\n * `.where()` or write a custom reducer.\n *\n * KNOWN LIMITATION (type imprecision): the declared result type is `number`,\n * but when `field` is a **money** field the runtime returns a decimal *string*\n * (e.g. `'0.30'`, or `{ EUR: '0.30' }` in multi-currency mode) — money sums are\n * BigInt-exact in scaled space and never collapse to a float. The `number` type\n * is therefore a lie for money fields; narrow the result yourself at the call\n * site. A precise fix requires threading money-field declarations into the type\n * system (tracked separately).\n */\nexport function sum(\n  field: string,\n  opts?: ReducerOptions<number>,\n): Reducer<number> {\n  const _seed = opts?.seed\n  void _seed\n  return {\n    op: 'sum',\n    field,\n    // Money-only metadata, read by `wrapMoneyReducers`. No effect on a\n    // generic numeric sum.\n    ...(opts?.convertTo !== undefined ? { convertTo: opts.convertTo } : {}),\n    ...(opts?.fx !== undefined ? { fx: opts.fx } : {}),\n    init: () => 0,\n    step: (state, record) => state + readNumber(record, field),\n    remove: (state, record) => state - readNumber(record, field),\n    finalize: (state) => state,\n    merge: (a, b) => a + b,\n  }\n}\n\n/**\n * Arithmetic mean of a numeric field across all matching records.\n *\n * Returns `null` for an empty result set (zero records is not a\n * well-defined denominator — returning NaN would poison downstream\n * arithmetic, and throwing would force every consumer to wrap in\n * try/catch just to handle \"no matches\"). Consumers who want an\n * explicit zero should coalesce with `?? 0`.\n *\n * Internal state is `{sum, count}` so the running average can be\n * maintained incrementally — on each delta, both fields update in\n * O(1) and `finalize` divides. Directly storing `avg` as state would\n * not admit incremental removal without also tracking count.\n */\nexport function avg(\n  field: string,\n  opts?: ReducerOptions<{ sum: number; count: number }>,\n): Reducer<number | null, { sum: number; count: number }> {\n  const _seed = opts?.seed\n  void _seed\n  return {\n    op: 'avg',\n    field,\n    init: () => ({ sum: 0, count: 0 }),\n    step: (state, record) => ({\n      sum: state.sum + readNumber(record, field),\n      count: state.count + 1,\n    }),\n    remove: (state, record) => ({\n      sum: state.sum - readNumber(record, field),\n      count: state.count - 1,\n    }),\n    finalize: (state) => (state.count === 0 ? null : state.sum / state.count),\n    merge: (a, b) => ({ sum: a.sum + b.sum, count: a.count + b.count }),\n  }\n}\n\nexport interface MinMaxState {\n  /**\n   * Multiset of contributing field values. Stored as a plain array\n   * because we need to support `remove` and a plain array gives us\n   * O(1) push + O(N) worst-case removal — which matches the\n   * documented min/max removal complexity. A sorted structure would\n   * let us drop the O(N) rescan but adds complexity that doesn't\n   * need; consumers hitting the O(N) ceiling should file an issue.\n   */\n  readonly values: number[]\n}\n\nfunction pushValue(state: MinMaxState, value: number): MinMaxState {\n  return { values: [...state.values, value] }\n}\n\nfunction removeValue(state: MinMaxState, value: number): MinMaxState {\n  // Remove the first matching value — duplicates are fine, we only\n  // need to drop one instance per `remove()` call so the multiset\n  // count stays consistent with the record count.\n  const idx = state.values.indexOf(value)\n  if (idx < 0) return state\n  const next = state.values.slice()\n  next.splice(idx, 1)\n  return { values: next }\n}\n\n/**\n * Smallest numeric value of a field across all matching records.\n * Returns `null` for an empty result set. See `avg()` for the\n * reasoning on `null` vs NaN vs throwing.\n *\n * Incremental complexity: O(1) for `step`, O(N) worst case for\n * `remove` when the current minimum is removed (the state holds the\n * full multiset of contributing values and `finalize` scans for the\n * new minimum). Consumers with very large result sets and frequent\n * removals of the current extremum should either accept the cost or\n * wait for a future optimization.\n */\nexport function min(\n  field: string,\n  opts?: ReducerOptions<number>,\n): Reducer<number | null, MinMaxState> {\n  const _seed = opts?.seed\n  void _seed\n  return {\n    op: 'min',\n    field,\n    init: () => ({ values: [] }),\n    step: (state, record) => pushValue(state, readNumber(record, field)),\n    remove: (state, record) => removeValue(state, readNumber(record, field)),\n    finalize: (state) => {\n      if (state.values.length === 0) return null\n      let out = state.values[0]!\n      for (let i = 1; i < state.values.length; i++) {\n        const v = state.values[i]!\n        if (v < out) out = v\n      }\n      return out\n    },\n    merge: (a, b) => ({ values: [...a.values, ...b.values] }),\n  }\n}\n\n/**\n * Largest numeric value of a field across all matching records.\n * Mirror of `min()` — see that doc for semantics, null-on-empty\n * behavior, and the O(N) removal caveat.\n */\nexport function max(\n  field: string,\n  opts?: ReducerOptions<number>,\n): Reducer<number | null, MinMaxState> {\n  const _seed = opts?.seed\n  void _seed\n  return {\n    op: 'max',\n    field,\n    init: () => ({ values: [] }),\n    step: (state, record) => pushValue(state, readNumber(record, field)),\n    remove: (state, record) => removeValue(state, readNumber(record, field)),\n    finalize: (state) => {\n      if (state.values.length === 0) return null\n      let out = state.values[0]!\n      for (let i = 1; i < state.values.length; i++) {\n        const v = state.values[i]!\n        if (v > out) out = v\n      }\n      return out\n    },\n    merge: (a, b) => ({ values: [...a.values, ...b.values] }),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Statistical reducers (#1353)\n// ---------------------------------------------------------------------------\n\n/**\n * ⚠️ MEMORY, stated once for the whole section.\n *\n * `variance` / `stddev` are **streaming** — three numbers of state regardless\n * of how many records pass through, so they are free in a `.groupBy()` and\n * free as a running window aggregate (#1349).\n *\n * `median`, `percentile` (exact) and `mode` are **O(n) per group**: the first\n * two keep every contributing value, `mode` keeps one entry per distinct value.\n * Multiplied by the `GROUPBY_MAX_CARDINALITY` ceiling (100,000 groups) that is\n * the one place in the reduce vocabulary where a legal query can exhaust\n * memory, so it is not \"free like `sum`\". Two ways out, in order of preference:\n * narrow with `.where()` before grouping, or pass\n * `percentile(field, p, { approx: true })` for the bounded-memory t-digest —\n * O(compression) state per group instead of O(n), at a small, measured error.\n *\n * Unlike `count` / `sum` / `min` / `max`, whose states are copied on every\n * `step`, the reducers in this section MUTATE their state in place and return\n * it (the shape `via/money/money-reducer.ts` already uses). Copy-on-write here\n * would make a median over a group quadratic in the group size, which is a\n * worse bug than the inconsistency. States are built fresh by `init()` on every\n * reduction run and never shared, so the mutation is not observable — except\n * through `merge`, which therefore always returns a NEW state.\n */\n\n/**\n * Welford state behind {@link variance} and {@link stddev}.\n *\n * `m2` is the running sum of squared deviations **from the running mean**, not\n * a sum of squares — that is the entire point. The textbook one-pass identity\n * `(Σx² − (Σx)²/n)` subtracts two enormous nearly-equal numbers, and on an\n * accounting column (invoice totals clustered around a large figure) the\n * cancellation eats every significant digit: four totals just over 1e9 with a\n * true sample variance of 30 come back as **−170.67**, so `stddev` is `NaN`.\n * Welford never forms the large intermediate.\n */\nexport interface WelfordState {\n  /** Number of contributing records. */\n  readonly n: number\n  /** Running arithmetic mean. */\n  readonly mean: number\n  /** Running sum of squared deviations from `mean`. */\n  readonly m2: number\n}\n\n/** Options for {@link variance} / {@link stddev}. */\nexport interface DispersionOptions extends ReducerOptions<WelfordState> {\n  /**\n   * `true` → **population** dispersion (÷ n). Default `false` → **sample**\n   * dispersion (÷ n−1), which is Postgres's `var_samp` / `stddev_samp`, the\n   * unqualified spelling in every SQL dialect this library is measured\n   * against.\n   *\n   * The divisor is not cosmetic and the wrong one is a silently wrong answer,\n   * so the two disagree loudly at n = 1: sample is `null` (n−1 = 0 is not a\n   * denominator), population is `0`.\n   */\n  readonly population?: boolean\n}\n\nfunction welfordReducer(\n  op: 'variance' | 'stddev',\n  field: string,\n  population: boolean,\n): Reducer<number | null, WelfordState> {\n  return {\n    op,\n    field,\n    init: () => ({ n: 0, mean: 0, m2: 0 }),\n    step: (state, record) => {\n      const x = readNumber(record, field)\n      const n = state.n + 1\n      const delta = x - state.mean\n      const mean = state.mean + delta / n\n      // (x - mean) uses the UPDATED mean; delta the previous one. Using the\n      // same mean twice is the naive formula wearing a Welford costume.\n      return { n, mean, m2: state.m2 + delta * (x - mean) }\n    },\n    remove: (state, record) => {\n      const x = readNumber(record, field)\n      const n = state.n - 1\n      if (n <= 0) return { n: 0, mean: 0, m2: 0 }\n      const mean = (state.mean * state.n - x) / n\n      return { n, mean, m2: state.m2 - (x - state.mean) * (x - mean) }\n    },\n    // Chan et al.'s parallel combination — the reason a reduction can be\n    // sharded and rolled up without re-reading the leaves.\n    merge: (a, b) => {\n      if (a.n === 0) return b\n      if (b.n === 0) return a\n      const n = a.n + b.n\n      const delta = b.mean - a.mean\n      return {\n        n,\n        mean: a.mean + (delta * b.n) / n,\n        m2: a.m2 + b.m2 + (delta * delta * a.n * b.n) / n,\n      }\n    },\n    finalize: (state) => {\n      const divisor = population ? state.n : state.n - 1\n      if (divisor <= 0) return null\n      const v = state.m2 / divisor\n      return op === 'stddev' ? Math.sqrt(v) : v\n    },\n  }\n}\n\n/**\n * Variance of a numeric field — **sample (n−1) by default**, `{ population:\n * true }` for the n divisor. See {@link DispersionOptions}.\n *\n * Streaming (Welford): O(1) state, O(1) `step`, O(1) `remove`, associative\n * `merge`. Safe as a running window aggregate.\n *\n * `null` for an empty result set, and `null` for a single record in sample\n * mode (population mode returns `0`) — see `avg()` for why null rather than\n * `NaN` or a throw.\n *\n * ⛔ Not available over a declared money field: dispersion is inherently a\n * float computation, so `wrapMoneyReducers` refuses rather than let\n * `readNumber` read a scaled-integer string as `0`.\n */\nexport function variance(field: string, opts?: DispersionOptions): Reducer<number | null, WelfordState> {\n  const _seed = opts?.seed\n  void _seed\n  return welfordReducer('variance', field, opts?.population === true)\n}\n\n/**\n * Standard deviation of a numeric field — the square root of {@link variance},\n * with the same divisor rule, the same empty/single-element answers, the same\n * streaming Welford state, and the same money refusal.\n */\nexport function stddev(field: string, opts?: DispersionOptions): Reducer<number | null, WelfordState> {\n  const _seed = opts?.seed\n  void _seed\n  return welfordReducer('stddev', field, opts?.population === true)\n}\n\n/**\n * Exact quantile state: every contributing value, unsorted (sorting happens\n * once, in `finalize`, on a copy — so a running window aggregate does not\n * disturb the multiset it is still being appended to).\n */\nexport interface ExactQuantileState {\n  readonly kind: 'exact'\n  readonly values: number[]\n}\n\n/** One t-digest centroid: a weighted summary of `count` nearby values. */\nexport interface Centroid {\n  readonly mean: number\n  readonly count: number\n}\n\n/**\n * t-digest state: compressed centroids plus a small unmerged buffer.\n *\n * Implemented here rather than taken from npm — `hub/src/**` adds no\n * dependency, and this one is ~60 lines.\n */\nexport interface TDigestState {\n  readonly kind: 'tdigest'\n  centroids: Centroid[]\n  buffer: number[]\n  n: number\n}\n\n/** State of {@link median} / {@link percentile}; the arm depends on `approx`. */\nexport type QuantileState = ExactQuantileState | TDigestState\n\n/** Options for {@link percentile}. */\nexport interface PercentileOptions extends ReducerOptions<number> {\n  /**\n   * `true` → bounded-memory t-digest instead of keeping every value. O(1)-ish\n   * state per group, at a small error (under 1% of the value range at every\n   * quantile on a 10k uniform scan, exact at p = 0 and p = 1).\n   *\n   * The trade is real: an approximate reducer cannot `remove()`, so it does\n   * not participate in incremental live maintenance, and it is refused over a\n   * money field.\n   */\n  readonly approx?: boolean\n}\n\nfunction assertProbability(op: string, p: number): void {\n  if (!Number.isFinite(p) || p < 0 || p > 1) {\n    throw new Error(`${op}(): p must be a number between 0 and 1, got ${p}.`)\n  }\n}\n\nfunction asExact(state: QuantileState): ExactQuantileState {\n  if (state.kind !== 'exact') throw new Error('percentile: expected the exact quantile state')\n  return state\n}\n\nfunction asDigest(state: QuantileState): TDigestState {\n  if (state.kind !== 'tdigest') throw new Error('percentile: expected the t-digest state')\n  return state\n}\n\n/**\n * `percentile_cont` over an in-memory multiset — the INTERPOLATING definition.\n *\n * `x = p * (n − 1)`; when `x` lands between two ranks the answer is the linear\n * blend of the two neighbours. So the median of `[1,2,3,4]` is `2.5`, a value\n * that is not in the input. `percentile_disc` would answer `2`. Postgres names\n * both; this library ships only `_cont`, because it is the one `median` has to\n * agree with — a `median` that returned `2` while `percentile(f, 0.5)`\n * returned `2.5` would be the worse surprise.\n */\nfunction quantileOf(values: readonly number[], p: number): number | null {\n  const n = values.length\n  if (n === 0) return null\n  if (n === 1) return values[0]!\n  const sorted = [...values].sort((a, b) => a - b)\n  const x = p * (n - 1)\n  const lo = Math.floor(x)\n  const frac = x - lo\n  if (frac === 0) return sorted[lo]!\n  return sorted[lo]! + (sorted[lo + 1]! - sorted[lo]!) * frac\n}\n\n/** Centroid budget. Larger ⇒ more accurate and more memory; 100 is the usual default. */\nconst TDIGEST_COMPRESSION = 100\n/** Unmerged values tolerated before a compression pass. */\nconst TDIGEST_BUFFER = 256\n\n/**\n * Fold the buffer into the centroid list and compress.\n *\n * The size rule is the standard one: a centroid sitting at estimated quantile\n * `q` may hold at most `4·n·q·(1−q)/compression` values, which is ~0 at the\n * tails and widest in the middle. That is what keeps p = 0 and p = 1 EXACT\n * (the extreme centroids stay singletons) while the middle compresses hard.\n */\nfunction tdigestFlush(state: TDigestState, force = false): void {\n  if (state.buffer.length === 0 && !force) return\n  const all: Centroid[] = state.centroids.concat(state.buffer.map((mean) => ({ mean, count: 1 })))\n  state.buffer = []\n  if (all.length === 0) return\n  all.sort((a, b) => a.mean - b.mean)\n  const total = state.n\n  const out: Centroid[] = []\n  let curMean = all[0]!.mean\n  let curCount = all[0]!.count\n  let before = 0\n  for (let i = 1; i < all.length; i++) {\n    const c = all[i]!\n    const q = (before + curCount + c.count / 2) / total\n    const limit = (4 * total * q * (1 - q)) / TDIGEST_COMPRESSION\n    if (curCount + c.count <= Math.max(limit, 1)) {\n      const count = curCount + c.count\n      curMean = curMean + ((c.mean - curMean) * c.count) / count\n      curCount = count\n    } else {\n      out.push({ mean: curMean, count: curCount })\n      before += curCount\n      curMean = c.mean\n      curCount = c.count\n    }\n  }\n  out.push({ mean: curMean, count: curCount })\n  state.centroids = out\n}\n\n/**\n * Estimate the `p` quantile off the centroids, interpolating between centroid\n * CENTRES so the answer degrades to `quantileOf` exactly when no compression\n * has happened (every centroid a singleton ⇒ its centre is its rank).\n */\nfunction tdigestQuantile(state: TDigestState, p: number): number | null {\n  tdigestFlush(state)\n  const cs = state.centroids\n  if (cs.length === 0) return null\n  if (cs.length === 1) return cs[0]!.mean\n  const centres: number[] = []\n  let acc = 0\n  for (const c of cs) {\n    centres.push(acc + (c.count - 1) / 2)\n    acc += c.count\n  }\n  const target = p * (state.n - 1)\n  const last = cs.length - 1\n  if (target <= centres[0]!) return cs[0]!.mean\n  if (target >= centres[last]!) return cs[last]!.mean\n  for (let i = 0; i < last; i++) {\n    const a = centres[i]!\n    const b = centres[i + 1]!\n    if (target <= b) {\n      const t = b === a ? 0 : (target - a) / (b - a)\n      return cs[i]!.mean + (cs[i + 1]!.mean - cs[i]!.mean) * t\n    }\n  }\n  return cs[last]!.mean\n}\n\nfunction exactQuantileReducer(\n  op: 'median' | 'percentile',\n  field: string,\n  p: number,\n): Reducer<number | null, QuantileState> {\n  return {\n    op,\n    field,\n    p,\n    init: (): QuantileState => ({ kind: 'exact', values: [] }),\n    step: (state, record) => {\n      asExact(state).values.push(readNumber(record, field))\n      return state\n    },\n    remove: (state, record) => {\n      const values = asExact(state).values\n      const idx = values.indexOf(readNumber(record, field))\n      if (idx >= 0) values.splice(idx, 1)\n      return state\n    },\n    merge: (a, b) => ({ kind: 'exact', values: [...asExact(a).values, ...asExact(b).values] }),\n    finalize: (state) => quantileOf(asExact(state).values, p),\n  }\n}\n\nfunction approxQuantileReducer(field: string, p: number): Reducer<number | null, QuantileState> {\n  return {\n    op: 'percentile',\n    field,\n    p,\n    approx: true,\n    init: (): QuantileState => ({ kind: 'tdigest', centroids: [], buffer: [], n: 0 }),\n    step: (state, record) => {\n      const d = asDigest(state)\n      d.buffer.push(readNumber(record, field))\n      d.n += 1\n      if (d.buffer.length >= TDIGEST_BUFFER) tdigestFlush(d)\n      return state\n    },\n    // No `remove`: a centroid has forgotten which values it absorbed, so an\n    // un-fold is not expressible. Deliberate, and asserted by a test.\n    merge: (a, b) => {\n      const A = asDigest(a)\n      const B = asDigest(b)\n      const s: TDigestState = {\n        kind: 'tdigest',\n        centroids: [...A.centroids, ...B.centroids],\n        buffer: [...A.buffer, ...B.buffer],\n        n: A.n + B.n,\n      }\n      tdigestFlush(s, true)\n      return s\n    },\n    finalize: (state) => tdigestQuantile(asDigest(state), p),\n  }\n}\n\n/**\n * Median of a numeric field — exactly `percentile(field, 0.5)`, and therefore\n * **`percentile_cont`**: an even-sized input INTERPOLATES (`[1,2,3,4]` → `2.5`)\n * rather than picking a member. See {@link quantileOf} for why only the\n * interpolating definition ships.\n *\n * `null` on an empty result set. O(n) memory per group — read the memory note\n * at the top of this section before using it under `.groupBy()`.\n *\n * Over a declared money field the reducer is rewritten onto the exact BigInt\n * path; {@link moneyMedian} is the same call with the honest return type.\n */\nexport function median(field: string, opts?: ReducerOptions<number>): Reducer<number | null, QuantileState> {\n  const _seed = opts?.seed\n  void _seed\n  return exactQuantileReducer('median', field, 0.5)\n}\n\n/**\n * The `p` quantile of a numeric field, `p ∈ [0, 1]`, by the **`percentile_cont`\n * (interpolating)** definition — `percentile(f, 0.9)` over `1..10` is `9.1`,\n * not `9`. `p = 0` is the minimum and `p = 1` the maximum, exactly.\n *\n * Throws for a `p` outside `[0, 1]` or a non-finite one, at construction time.\n *\n * Exact by default and O(n) per group; pass `{ approx: true }` for the\n * bounded-memory t-digest (see {@link PercentileOptions}).\n */\nexport function percentile(\n  field: string,\n  p: number,\n  opts?: PercentileOptions,\n): Reducer<number | null, QuantileState> {\n  assertProbability('percentile', p)\n  const _seed = opts?.seed\n  void _seed\n  return opts?.approx === true ? approxQuantileReducer(field, p) : exactQuantileReducer('percentile', field, p)\n}\n\n/** Frequency table behind {@link mode}: value → how many records hold it. */\nexport interface ModeState {\n  readonly counts: Map<number, number>\n}\n\n/**\n * Most frequent value of a numeric field.\n *\n * **Tie rule: the LOWEST value wins.** Two values with equal frequency is the\n * common case on real data, not an edge case, and the alternatives are worse:\n * \"first seen\" makes the answer depend on store iteration order (so the same\n * query answers differently after a compaction, and `merge` stops being\n * commutative), and \"all of them\" changes the result TYPE based on the data.\n * Lowest-wins is total, order-independent, and mergeable.\n *\n * `null` on an empty result set. O(distinct values) memory per group.\n *\n * ⛔ Numeric only, and not available over a declared money field.\n */\nexport function mode(field: string, opts?: ReducerOptions<number>): Reducer<number | null, ModeState> {\n  const _seed = opts?.seed\n  void _seed\n  return {\n    op: 'mode',\n    field,\n    init: () => ({ counts: new Map<number, number>() }),\n    step: (state, record) => {\n      const v = readNumber(record, field)\n      state.counts.set(v, (state.counts.get(v) ?? 0) + 1)\n      return state\n    },\n    remove: (state, record) => {\n      const v = readNumber(record, field)\n      const current = state.counts.get(v)\n      if (current === undefined) return state\n      if (current <= 1) state.counts.delete(v)\n      else state.counts.set(v, current - 1)\n      return state\n    },\n    merge: (a, b) => {\n      const counts = new Map(a.counts)\n      for (const [v, c] of b.counts) counts.set(v, (counts.get(v) ?? 0) + c)\n      return { counts }\n    },\n    finalize: (state) => {\n      let best: number | null = null\n      let bestCount = 0\n      for (const [v, c] of state.counts) {\n        if (c > bestCount || (c === bestCount && best !== null && v < best)) {\n          best = v\n          bestCount = c\n        }\n      }\n      return best\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Money-typed reducer constructors\n// ---------------------------------------------------------------------------\n\n/**\n * `sum()` for a **declared money field**, typed to match the runtime.\n *\n * `sum()` returns `Reducer<number>`, but `wrapMoneyReducers` (applied at\n * `query.aggregate()` time, once `moneyFields` is known) rewrites any\n * `sum`/`min`/`max` over a money field to a money reducer that finalizes to a\n * `MoneyString` decimal — so the `number` type is a lie for money fields and\n * consumers need a cast at every read site. `moneySum` is the same reducer with\n * the correct `Reducer<MoneyString>` return type, so no read-site cast is\n * needed. It is the caller's assertion that `field` is a money field; use plain\n * `sum()` for non-money fields. (For a multi-currency money field WITHOUT\n * `convertTo`, the runtime returns a per-currency `Record<string, MoneyString>`\n * rather than a single `MoneyString` — pass `convertTo` to collapse to one\n * currency, or read the map at the boundary.)\n */\nexport function moneySum(field: string, opts?: ReducerOptions<number>): Reducer<MoneyString> {\n  // The constructed reducer is the plain numeric `sum`; `wrapMoneyReducers`\n  // swaps in the MoneyString-producing money reducer at aggregate() time.\n  return sum(field, opts) as unknown as Reducer<MoneyString>\n}\n\n/**\n * `min()` for a declared money field, typed `Reducer<MoneyString | null>`\n * (null on an empty result set in fixed-currency mode, mirroring `min()`). See\n * {@link moneySum} for the late-binding rewrite. Note: `convertTo`/`fx` on\n * `opts` have no effect on min/max (cross-currency min/max is unsupported — use\n * {@link moneySum} for currency conversion). In multi-currency mode the runtime\n * returns a per-currency map and an empty result is `{}` rather than `null`.\n */\nexport function moneyMin(field: string, opts?: ReducerOptions<number>): Reducer<MoneyString | null> {\n  return min(field, opts) as unknown as Reducer<MoneyString | null>\n}\n\n/**\n * `max()` for a declared money field, typed `Reducer<MoneyString | null>`\n * (null on an empty result set in fixed-currency mode, mirroring `max()`). See\n * {@link moneyMin} for the `convertTo`/`fx` and multi-currency caveats.\n */\nexport function moneyMax(field: string, opts?: ReducerOptions<number>): Reducer<MoneyString | null> {\n  return max(field, opts) as unknown as Reducer<MoneyString | null>\n}\n\n/**\n * `median()` for a **declared money field**, typed `Reducer<MoneyString | null>`.\n *\n * Same late-binding rewrite as {@link moneySum}: `wrapMoneyReducers` swaps in a\n * reducer that keeps the stored scaled integers as `bigint`s and interpolates\n * the two middle values IN SCALED SPACE with half-even rounding — the money\n * module's rounding everywhere else. Nothing round-trips through a float, so\n * the answer is exact past `Number.MAX_SAFE_INTEGER`, where two distinct cent\n * amounts stop being distinct numbers at all.\n *\n * An even-sized input can therefore land on a half unit (`0.10` and `0.15` →\n * `12.5` cents): that is the one place money median rounds, and it rounds\n * half-to-even (`0.12`), never away from zero.\n *\n * In multi-currency mode the runtime returns a per-currency map, as `moneyMin`\n * does; an empty result is `null` in fixed mode and `{}` in multi.\n */\nexport function moneyMedian(field: string, opts?: ReducerOptions<number>): Reducer<MoneyString | null> {\n  return median(field, opts) as unknown as Reducer<MoneyString | null>\n}\n\n/**\n * `percentile()` for a declared money field — see {@link moneyMedian} for the\n * exactness and rounding contract, which is the same code path (`median` is\n * `p = 0.5`). The interpolation weight is taken from `p`'s DECIMAL spelling as\n * an exact rational, so `p = 0.9` is `9/10`, not the float nearest to it.\n *\n * There is deliberately no `approx` here: the t-digest is a float structure and\n * `wrapMoneyReducers` refuses it over a money field.\n */\nexport function moneyPercentile(\n  field: string,\n  p: number,\n  opts?: ReducerOptions<number>,\n): Reducer<MoneyString | null> {\n  return percentile(field, p, opts) as unknown as Reducer<MoneyString | null>\n}\n\n// ---------------------------------------------------------------------------\n// Builder (typed spec-builder for aggregate())\n// ---------------------------------------------------------------------------\n\n/**\n * Typed builder passed to the `aggregate(b => spec)` overload.\n *\n * Each field-taking method narrows `field` to `QueryField<T, S>`, which\n * excludes any field listed in the collection's `sensitive` option at\n * compile time. `count()` carries no field argument and is always allowed.\n *\n * The type parameters match the `Query<T, S>` they come from:\n *   - `T` — the record type of the collection\n *   - `S` — the union of sensitive field keys (defaults to `never`)\n *\n * ONE shared runtime instance (`reducerBuilder`) serves all `T`/`S`\n * combinations — the field narrowing is type-only; the methods delegate\n * directly to the standalone factories.\n */\nexport interface ReducerBuilder<T, S extends keyof T = never, M extends keyof T & string = never> {\n  count(opts?: ReducerOptions<number>): Reducer<number>\n  countDistinct(field: QueryField<T, S>, opts?: ReducerOptions<number>): Reducer<number, CountDistinctState>\n  sum<F extends QueryField<T, S>>(field: F, opts?: ReducerOptions<number>): [F] extends [M] ? Reducer<MoneyString> : Reducer<number>\n  avg(field: QueryField<T, S>, opts?: ReducerOptions<{ sum: number; count: number }>): ReturnType<typeof avg>\n  min<F extends QueryField<T, S>>(field: F, opts?: ReducerOptions<number>): [F] extends [M] ? Reducer<MoneyString | null> : ReturnType<typeof min>\n  max<F extends QueryField<T, S>>(field: F, opts?: ReducerOptions<number>): [F] extends [M] ? Reducer<MoneyString | null> : ReturnType<typeof max>\n  median<F extends QueryField<T, S>>(field: F, opts?: ReducerOptions<number>): [F] extends [M] ? Reducer<MoneyString | null> : ReturnType<typeof median>\n  percentile<F extends QueryField<T, S>>(field: F, p: number, opts?: PercentileOptions): [F] extends [M] ? Reducer<MoneyString | null> : ReturnType<typeof percentile>\n  variance(field: QueryField<T, S>, opts?: DispersionOptions): ReturnType<typeof variance>\n  stddev(field: QueryField<T, S>, opts?: DispersionOptions): ReturnType<typeof stddev>\n  mode(field: QueryField<T, S>, opts?: ReducerOptions<number>): ReturnType<typeof mode>\n  moneySum(field: QueryField<T, S>, opts?: ReducerOptions<number>): Reducer<MoneyString>\n  moneyMin(field: QueryField<T, S>, opts?: ReducerOptions<number>): Reducer<MoneyString | null>\n  moneyMax(field: QueryField<T, S>, opts?: ReducerOptions<number>): Reducer<MoneyString | null>\n  moneyMedian(field: QueryField<T, S>, opts?: ReducerOptions<number>): Reducer<MoneyString | null>\n  moneyPercentile(field: QueryField<T, S>, p: number, opts?: ReducerOptions<number>): Reducer<MoneyString | null>\n}\n\n/**\n * Shared runtime instance for the `aggregate(b => spec)` builder form.\n *\n * The field-narrowing to `QueryField<T, S>` is type-only — each method\n * delegates directly to its standalone factory. A `(field: string) => R`\n * factory is assignable to a `(field: QueryField<T,S>) => R` method by\n * parameter-contravariance, so this single instance works for all `T`/`S`.\n */\nexport const reducerBuilder: ReducerBuilder<Record<string, unknown>> = {\n  count,\n  countDistinct,\n  // The generic F parameter on sum/min/max in the interface is type-only; the\n  // standalone factories are plain `(field: string)` functions. With M=never the\n  // conditional return collapses to the numeric branch, matching the factories'\n  // return type, but TypeScript cannot verify that collapse for a generic method\n  // signature — so each factory is cast directly to the method's type.\n  sum: sum as ReducerBuilder<Record<string, unknown>>['sum'],\n  avg,\n  min: min as ReducerBuilder<Record<string, unknown>>['min'],\n  max: max as ReducerBuilder<Record<string, unknown>>['max'],\n  median: median as ReducerBuilder<Record<string, unknown>>['median'],\n  percentile: percentile as ReducerBuilder<Record<string, unknown>>['percentile'],\n  variance,\n  stddev,\n  mode,\n  moneySum, moneyMin, moneyMax, moneyMedian, moneyPercentile,\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Read a numeric field from a record. Non-number values (null,\n * undefined, strings, objects) coerce to 0 so sum/avg/min/max don't\n * produce NaN on one bad row. Consumers who want strict typing should\n * validate upstream with Standard Schema, which NOYDB already runs on\n * every `put()`.\n */\nfunction readNumber(record: unknown, field: string): number {\n  const value = readPath(record, field)\n  // Defensive: a `{ amount, currency }` value means a multi-currency\n  // money field reached a generic numeric reducer instead of being\n  // rewritten by `wrapMoneyReducers` — that would silently produce a\n  // wrong total. Surface it loudly rather than coercing to 0.\n  if (\n    typeof value === 'object' &&\n    value !== null &&\n    'amount' in value &&\n    'currency' in value\n  ) {\n    throw new Error(\n      `aggregate: field \"${field}\" holds a money value but was not money-aware — ` +\n        `declare it in the collection's moneyFields so sum/min/max stay exact`,\n    )\n  }\n  return typeof value === 'number' && Number.isFinite(value) ? value : 0\n}\n"],"mappings":"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","names":["count"]}

package/dist/{chunk-3BZZJJMQ.js → chunk-MILI22XQ.js}

@@ -1,9 +1,9 @@
 import {
   matchesReferencingValue
-} from "./chunk-R7BX2NB3.js";
+} from "./chunk-244QBK7Z.js";
 import {
   PeriodClosedError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-37EPTBBR.js";
 
 // src/kernel/via/dispatch.ts
 function touchFor(batch, collection) {
@@ -173,4 +173,4 @@ export {
   forgetDerivedFanout,
   selfWriteFieldEqual
 };
-//# sourceMappingURL=chunk-3BZZJJMQ.js.map
+//# sourceMappingURL=chunk-MILI22XQ.js.map