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

package/dist/chunk-F24ZZTHQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/query/scan-builder.ts"],"sourcesContent":["/**\n * Streaming scan builder with filter + aggregate support.\n *\n * `Collection.scan()` now returns a `ScanBuilder<T>` that\n * implements `AsyncIterable<T>` (for existing `for await … of`\n * consumers) AND exposes chainable `.where()` / `.filter()` clauses\n * plus a `.aggregate(spec)` async terminal that reduces the scan\n * stream through the same reducer protocol as `Query.aggregate()`\n *.\n *\n * **Memory model:** O(reducers), not O(records). The aggregate\n * terminal initializes one state per reducer, iterates through the\n * scan one record at a time via `for await`, applies every reducer's\n * `step` per record, and never collects the stream into an array.\n * This is what makes `scan().aggregate()` suitable for collections\n * that don't fit in memory — the bound is a code-level invariant\n * visible in the function body, not a runtime assertion.\n *\n * **Paginated iteration:** the builder holds a `pageProvider`\n * closure that maps `(cursor, limit) → Promise<page>`, plumbed by\n * `Collection.scan()` to `collection.listPage(...)`. The page\n * iterator walks cursors forward until exhaustion, same as the\n * previous async-generator `scan()` did.\n *\n * **Backward compatibility:** existing `for await (const rec of\n * collection.scan()) { … }` code continues to work because\n * `ScanBuilder` implements `[Symbol.asyncIterator]`. The previous\n * signature returned an `AsyncIterableIterator<T>` (which has both\n * `[Symbol.asyncIterator]` and `.next()`). We verified at grep time\n * that no call sites use `.next()` on the scan result directly, so\n * the narrowed interface is safe.\n *\n * **Immutability:** each `.where()` / `.filter()` call returns a\n * fresh builder sharing the same page provider and page size. This\n * lets a base scan be reused for multiple parallel aggregations:\n *\n * ```ts\n * const scan = invoices.scan()\n * const [open, paid] = await Promise.all([\n *   scan.where('status', '==', 'open').aggregate({ n: count() }),\n *   scan.where('status', '==', 'paid').aggregate({ n: count() }),\n * ])\n * ```\n *\n * Note that each aggregation pays a full scan — there's no shared\n * iteration across the two. When the specs are known together, pass\n * them as an ARRAY (#1340): `.aggregate([specA, specB])` steps every\n * spec's state from the same yielded record, so N specs cost one\n * pass, not N.\n *\n * **Out of scope for (tracked separately):**\n *   - `scan().aggregate().live()` — unbounded scan + change-stream\n *     reconciliation is a design problem, not just a code one, and\n *     #1340 deliberately left it out\n *   - Parallel scan across pages — race-safe page cursor contracts\n *     are not in the adapter API yet\n *   - `scan().join(...)` — tracked under  (streaming join)\n */\n\nimport type { QueryField } from '../types.js'\nimport type { Clause, FieldClause, Operator } from './predicate.js'\nimport { evaluateClause, hasFnClause, normalizeMatches, normalizeSubqueryOperand } from './predicate.js'\nimport type { ReduceSpec, ReduceResult } from '../../with-lookup/reduce/reduction.js'\n// ─── #1458 — Relate is TYPE-ONLY here, same as in `builder.ts` ───────────\n// The streaming iterator has to be able to run a plan that carries legs; it\n// cannot BUILD one. `splitAroundJoins` is the Find-side shim (join-conditional,\n// with the empty answer inline) that `builder.ts` publishes for both builders,\n// so the two cannot drift on what \"pre-join\" means.\nimport type { JoinContext, JoinLeg } from './relate/join.js'\nimport type { ScanJoinResolver } from './relate/scan-methods.js'\nimport { splitAroundJoins } from './builder.js'\nimport { FieldNotQueryableError, QueryExtensionMissingError } from '../errors.js'\nimport type { ViaPipeline } from '../via/pipeline.js'\n\n/**\n * Result of the multi-spec `.aggregate([specA, specB, …])` form (#1340) — a\n * tuple positionally matching the specs, each element the shape that spec's\n * own single-spec `.aggregate()` would have returned.\n */\nexport type MultiReduceResult<Specs extends readonly ReduceSpec[]> = {\n  -readonly [K in keyof Specs]: ReduceResult<Specs[K]>\n}\n\n/**\n * Page provider — the Collection-shaped hook the builder calls to\n * walk cursors forward. Kept as a structural interface so tests can\n * wire up a synthetic provider without pulling in the full\n * Collection class. Collection's `listPage` matches this shape\n * exactly.\n */\nexport interface ScanPageProvider<T> {\n  listPage(opts: {\n    cursor?: string\n    limit?: number\n  }): Promise<{ items: T[]; nextCursor: string | null }>\n}\n\nconst DEFAULT_SCAN_PAGE_SIZE = 100\n\n/**\n * Chainable streaming scan. Implements `AsyncIterable<T>` for\n * drop-in use with `for await … of`; adds `.where()` / `.filter()`\n * chainable clauses and a `.aggregate(spec)` async terminal.\n *\n * The builder is immutable per operation — each chained call\n * returns a fresh `ScanBuilder` sharing the same page provider and\n * page size. The original builder is never mutated, so it's safe\n * to reuse across multiple parallel consumers.\n */\nexport class ScanBuilder<T, S extends keyof T = never, M extends keyof T & string = never> implements AsyncIterable<T> {\n  private readonly pageProvider: ScanPageProvider<T>\n  private readonly pageSize: number\n  private readonly clauses: readonly Clause[]\n  /**\n   * Zero-or-more join legs to apply per record as the stream flows.\n   * Each leg attaches the resolved right-side record (or null) under\n   * its alias. — streaming joins.\n   *\n   * Joins are evaluated AFTER clauses, so a `where()` filtered-out\n   * record never triggers a right-side lookup. This is the same\n   * ordering as `Query.toArray()` (clauses first, joins after) and\n   * keeps the streaming path from doing wasted work.\n   */\n  private readonly joins: readonly JoinLeg[]\n  /**\n   * Join resolution context. Required for `.join()` to translate a\n   * field name into a target collection + ref mode and to resolve\n   * the right-side `JoinableSource`. Optional because tests\n   * construct ScanBuilder directly with synthetic page providers\n   * that don't know about ref() — calling `.join()` without a\n   * context throws with an actionable error.\n   */\n  private readonly joinContext: JoinContext | undefined\n  /**\n   * The backing collection's compiled Via pipeline (money now; more Via\n   * features later). When it declares a result decode, yielded records\n   * are decoded (e.g. money: stored scaled-int → canonical decimal) so\n   * `scan()` agrees with `get()`/`list()`/`query().toArray()`. Decoded\n   * with `'raw'` (canonical decimal, no locale-formatted virtuals) since\n   * the scan stream carries no locale context, mirroring `Query.toArray()`.\n   */\n  private readonly via: ViaPipeline | undefined\n\n  // ─── #1458 — installed by the extension subpaths ────────────────────────\n  //\n  // `ScanBuilder` is split the same way `Query` is: Find here, Reduce and\n  // Relate in `@noy-db/hub/query/{reduce,relate}`. These two are declared\n  // rather than defined because the ITERATOR below calls them, and it stays in\n  // Find — both calls are behind `joins.length === 0`, which only Relate's\n  // `join()` can make false.\n  declare protected buildJoinResolvers: () => ScanJoinResolver[]\n  declare protected applyOneJoinStreaming: (record: unknown, resolver: ScanJoinResolver) => unknown\n\n  constructor(\n    pageProvider: ScanPageProvider<T>,\n    pageSize: number = DEFAULT_SCAN_PAGE_SIZE,\n    clauses: readonly Clause[] = [],\n    joins: readonly JoinLeg[] = [],\n    joinContext?: JoinContext,\n    via?: ViaPipeline,\n  ) {\n    this.pageProvider = pageProvider\n    this.pageSize = pageSize\n    this.clauses = clauses\n    this.joins = joins\n    this.joinContext = joinContext\n    this.via = via\n  }\n\n  /**\n   * Decode this scan's Via-covered fields on a record (e.g. money: stored\n   * scaled-int → canonical decimal). No-op when the Via pipeline declares\n   * no result decode. See {@link via}.\n   */\n  private decodeVia(record: T): T {\n    if (!this.via || !this.via.hasResultDecode) return record\n    return this.via.decodeResults(record) as T\n  }\n\n  /**\n   * Add a field comparison. Runs per record as the scan stream\n   * flows through, so non-matching records are dropped before they\n   * reach `.aggregate()` or the iteration consumer. Multiple\n   * `.where()` calls are AND-combined — same semantics as\n   * `Query.where()`.\n   *\n   * Clauses cannot use the secondary-index fast path here because\n   * the scan sources records from the adapter's paginator, not from\n   * the in-memory cache where indexes live. Index-accelerated scans\n   * are a future optimization — the current implementation\n   * evaluates clauses per record in O(1) per clause.\n   *\n   * Consults the Via pipeline's posture before building a clause (#629\n   * Task 8): a field whose posture is `queryable: 'none'` throws\n   * `FieldNotQueryableError` here, at the call site — same gate as\n   * `Query.where()`.\n   */\n  where(field: QueryField<T, S>, op: Operator, value: unknown): ScanBuilder<T, S, M> {\n    // A Via-covered field (e.g. money) compares in major units, BigInt-exact\n    // in scaled space — same build-time operand rewrite as Query.where().\n    const via = this.via\n    if (via?.postureFor(field as string)?.queryable === 'none') throw new FieldNotQueryableError(field as string)\n    // #1357: a 'matches' operand is refused-or-normalized HERE, at the call\n    // site — an anchored literal prefix lowers to `startsWith` (taking the\n    // sorted index), anything else serializes to `{ source, flags }` so the\n    // pattern folds into an MV's queryHash. Every other operator is identity.\n    // #1351: a SUBQUERY operand of `in`/`!in` resolves to its id array here,\n    // at build time — same normalization order as `Query.where()`, so all\n    // three builders turn the same call into the same clause.\n    const { op: sop, value: sval, subquery } = normalizeSubqueryOperand(op, value)\n    const { op: mop, value: mval } = normalizeMatches(sop, sval)\n    const viaClause = via?.buildClause(field as string, mop, mval)\n    const clause: FieldClause = viaClause\n      ? {\n          type: 'field',\n          field: field as string,\n          op: mop,\n          value: mval,\n          ...(subquery ? { subquery } : {}),\n          via: {\n            brand: viaClause.brand,\n            payload: viaClause.payload,\n            evaluate: (actual: unknown, evalOp: string) => via!.evaluateClause(viaClause, actual, evalOp),\n          },\n        }\n      : { type: 'field', field: field as string, op: mop, value: mval, ...(subquery ? { subquery } : {}) }\n    return new ScanBuilder<T, S, M>(\n      this.pageProvider,\n      this.pageSize,\n      [...this.clauses, clause],\n      this.joins,\n      this.joinContext,\n      this.via,\n    )\n  }\n\n  /**\n   * Escape hatch: add an arbitrary predicate function. Same\n   * non-serializable caveat as `Query.filter()` — filter clauses\n   * don't round-trip through `toPlan()`. Prefer `.where()` when\n   * possible.\n   */\n  filter(fn: (record: T) => boolean): ScanBuilder<T, S, M> {\n    const clause: Clause = {\n      type: 'filter',\n      fn: fn as (record: unknown) => boolean,\n    }\n    return new ScanBuilder<T, S, M>(\n      this.pageProvider,\n      this.pageSize,\n      [...this.clauses, clause],\n      this.joins,\n      this.joinContext,\n      this.via,\n    )\n  }\n\n  async *[Symbol.asyncIterator](): AsyncIterator<T> {\n    // One-time setup: resolve every join leg's right-side source\n    // and pick its strategy (lookupById per row vs hash from\n    // snapshot once). Both are O(left) per record after setup; the\n    // difference is the upfront cost of hashing the right side\n    // when there's no lookupById.\n    //\n    // Hash maps live for the lifetime of the iteration, so memory\n    // for the right side is O(rightRowCount) per leg. Memory for\n    // the left side stays O(pageSize) regardless — that's the\n    // streaming property we're after.\n    const joinResolvers = this.joins.length === 0 ? null : this.buildJoinResolvers()\n    // #1030 — a clause addressing a join alias cannot be evaluated against the\n    // raw record, where the alias does not exist yet. Split once per\n    // iteration, not per record. Streaming pays nothing for this: the\n    // post-join predicate runs on the row already in hand, so the O(pageSize)\n    // memory property is untouched.\n    const { preJoin, postJoin } = splitAroundJoins(this.clauses, this.joins)\n\n    let page = await this.pageProvider.listPage({ limit: this.pageSize })\n    while (true) {\n      for (const record of page.items) {\n        // Filter on the raw stored record (same order as Query.toArray:\n        // clauses first), then decode Via-covered fields (e.g. money, to\n        // the canonical decimal) before yielding so scan() never leaks the\n        // internal stored representation.\n        if (!this.recordMatches(record, preJoin)) continue\n        const decoded = this.decodeVia(record)\n        if (joinResolvers === null) {\n          yield decoded\n        } else {\n          // Apply every join leg in declaration order. Each\n          // leg attaches a field — the result of one leg becomes\n          // the input to the next. Multi-FK chaining is\n          // supported by construction.\n          let attached: unknown = decoded\n          for (const resolver of joinResolvers) {\n            attached = this.applyOneJoinStreaming(attached, resolver)\n          }\n          if (postJoin.length > 0 && !this.recordMatches(attached as T, postJoin)) continue\n          yield attached as T\n        }\n      }\n      if (page.nextCursor === null) return\n      page = await this.pageProvider.listPage({\n        cursor: page.nextCursor,\n        limit: this.pageSize,\n      })\n    }\n  }\n\n  /**\n   * Evaluate the clause list against a single record. Linear in\n   * the clause count; short-circuits on first false. Clauses on a\n   * scan are always re-evaluated per record — no index-accelerated\n   * path, because the stream sources records from the adapter\n   * paginator, not from the in-memory cache where indexes live.\n   */\n  private recordMatches(record: T, clauses: readonly Clause[] = this.clauses): boolean {\n    if (clauses.length === 0) return true\n    // User-callback clauses (filter) see the DECODED view (e.g. money's\n    // canonical decimal); field clauses keep the raw record — their\n    // operands are pre-built into stored space. Decoded at most once per\n    // record, only when a callback clause exists.\n    const fnView =\n      this.via?.hasResultDecode && hasFnClause(clauses)\n        ? this.decodeVia(record)\n        : undefined\n    for (const clause of clauses) {\n      if (!evaluateClause(record, clause, fnView)) return false\n    }\n    return true\n  }\n}\n\n// ─── #1458 — ScanBuilder's extension stubs ────────────────────────────────\n// Same mechanism, and the same reason for not declaring them on the class, as\n// `builder.ts`'s block: the method's TYPE must arrive with its subpath.\nconst SCAN_EXTENSION_METHODS: readonly (readonly [string, string])[] = [\n  ['aggregate', '@noy-db/hub/query/reduce'],\n  ['groupBy', '@noy-db/hub/query/reduce'],\n  ['join', '@noy-db/hub/query/relate'],\n]\n\nfor (const [method, subpath] of SCAN_EXTENSION_METHODS) {\n  Object.defineProperty(ScanBuilder.prototype, method, {\n    value: function scanExtensionMissing(): never {\n      throw new QueryExtensionMissingError(`scan().${method}`, subpath)\n    },\n    writable: true,\n    enumerable: false,\n    configurable: true,\n  })\n}\n\n\n/**\n * ── Grouped streaming reduction over a `scan()` — `#1340` ──────────────────\n *\n * `scan().groupBy(key, { maxGroups }).aggregate(spec)` folds an unbounded,\n * page-by-page scan into one row per group. The distinguishing property\n * against the eager `Query.groupBy()` path is WHAT IS HELD:\n *\n *   - eager (`groupAndReduce` in `with-lookup/reduce/groupby.ts`) partitions\n *     the matched records into `Map<key, records[]>` and reduces each bucket\n *     afterwards — O(matched records) memory;\n *   - this one holds **one reducer state per group and no records at all** —\n *     O(groups × state), with the left side still streaming at O(pageSize).\n *\n * So the two cannot share an implementation, and this deliberately does\n * NOT use `groupAndReduce`: reusing it would mean collecting the stream,\n * which is the exact thing `scan()` exists to avoid. What IS shared is every\n * piece that decides SEMANTICS — the group-key canonicalisation (so `null`\n * and `undefined` bucket apart here exactly as they do there), the reducer\n * protocol, `ViaPipeline.wrapReducers` (money stays BigInt-exact),\n * `bindDistinctReducers` (`countDistinct` dedups on the canonical index key),\n * and `projectDateTruncKeys` (a derived calendar key is stamped onto a\n * shallow copy of the row before bucketing, same as `Query.groupBy()`).\n *\n * ## The memory budget IS the feature\n *\n * `maxGroups` defaults to `GROUPBY_MAX_CARDINALITY` (100_000) — the same\n * ceiling the eager path enforces — and is refused the moment the group that\n * would exceed it is first seen, mid-stream, before its state is allocated.\n * ⛔ It never truncates: a truncated rollup is a WRONG ANSWER that looks like\n * a right one, and the whole point of declaring a budget is to learn that the\n * grouping does not fit. The refusal names the option and the observed count.\n *\n * ⚠️ **Per-group state is NOT constant.** `count`/`sum`/`avg`/`min`/`max` are\n * O(1) per group, but `median`/`percentile` (exact) hold every sampled value\n * — O(n) per group — `mode` holds one entry per distinct value, and\n * `countDistinct` one per distinct value. A grouped scan with an exact\n * `median` is therefore O(matched records) overall no matter what `maxGroups`\n * says, since the values live in the group states. Pair it with\n * `{ approx: true }` (the t-digest, bounded per group) when the scan is\n * genuinely unbounded — that is what makes `maxGroups` a real ceiling rather\n * than an accounting fiction.\n *\n * ## Post-group `having` / `orderBy` / `limit` (#1336) are NOT on this path\n *\n * Those live on `GroupedReduction`, which is built around a SYNCHRONOUS\n * `executeRecords()` closure and the eager pipeline; a scan has neither.\n * Rather than grow a second, subtly different implementation of the same\n * three operations, this terminal returns the row array — bounded by\n * `maxGroups` and already in memory — and the caller filters, sorts and\n * slices it. See the report on #1340; if a consumer wants the chainable\n * shape, the honest fix is to lift the post-group stage out of\n * `GroupedReduction` and share it, not to copy it here.\n *\n * ⚠️ Lives in THIS file rather than its own `scan-groupby.ts` for one\n * mechanical reason: `check-architecture`'s `port-layering` ratchet\n * grandfathers `scan-builder.ts`'s two `with-lookup/reduce/*` imports per\n * specifier, and a NEW kernel file may not statically import a `with-*`\n * service at all. Splitting it out means either a dynamic import on the\n * reducer protocol or a new grandfather entry; neither is worth it for a\n * class that only exists to terminate `ScanBuilder.groupBy()`.\n */\n"],"mappings":";;;;;;;;;;;;;;;AAiGA,IAAM,yBAAyB;AAYxB,IAAM,cAAN,MAAM,aAA0G;AAAA,EACpG;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA;AAAA,EAYjB,YACE,cACA,WAAmB,wBACnB,UAA6B,CAAC,GAC9B,QAA4B,CAAC,GAC7B,aACA,KACA;AACA,SAAK,eAAe;AACpB,SAAK,WAAW;AAChB,SAAK,UAAU;AACf,SAAK,QAAQ;AACb,SAAK,cAAc;AACnB,SAAK,MAAM;AAAA,EACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,UAAU,QAAc;AAC9B,QAAI,CAAC,KAAK,OAAO,CAAC,KAAK,IAAI,gBAAiB,QAAO;AACnD,WAAO,KAAK,IAAI,cAAc,MAAM;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,MAAM,OAAyB,IAAc,OAAsC;AAGjF,UAAM,MAAM,KAAK;AACjB,QAAI,KAAK,WAAW,KAAe,GAAG,cAAc,OAAQ,OAAM,IAAI,uBAAuB,KAAe;AAQ5G,UAAM,EAAE,IAAI,KAAK,OAAO,MAAM,SAAS,IAAI,yBAAyB,IAAI,KAAK;AAC7E,UAAM,EAAE,IAAI,KAAK,OAAO,KAAK,IAAI,iBAAiB,KAAK,IAAI;AAC3D,UAAM,YAAY,KAAK,YAAY,OAAiB,KAAK,IAAI;AAC7D,UAAM,SAAsB,YACxB;AAAA,MACE,MAAM;AAAA,MACN;AAAA,MACA,IAAI;AAAA,MACJ,OAAO;AAAA,MACP,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC;AAAA,MAC/B,KAAK;AAAA,QACH,OAAO,UAAU;AAAA,QACjB,SAAS,UAAU;AAAA,QACnB,UAAU,CAAC,QAAiB,WAAmB,IAAK,eAAe,WAAW,QAAQ,MAAM;AAAA,MAC9F;AAAA,IACF,IACA,EAAE,MAAM,SAAS,OAAwB,IAAI,KAAK,OAAO,MAAM,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC,EAAG;AACrG,WAAO,IAAI;AAAA,MACT,KAAK;AAAA,MACL,KAAK;AAAA,MACL,CAAC,GAAG,KAAK,SAAS,MAAM;AAAA,MACxB,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,IAAkD;AACvD,UAAM,SAAiB;AAAA,MACrB,MAAM;AAAA,MACN;AAAA,IACF;AACA,WAAO,IAAI;AAAA,MACT,KAAK;AAAA,MACL,KAAK;AAAA,MACL,CAAC,GAAG,KAAK,SAAS,MAAM;AAAA,MACxB,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEA,QAAQ,OAAO,aAAa,IAAsB;AAWhD,UAAM,gBAAgB,KAAK,MAAM,WAAW,IAAI,OAAO,KAAK,mBAAmB;AAM/E,UAAM,EAAE,SAAS,SAAS,IAAI,iBAAiB,KAAK,SAAS,KAAK,KAAK;AAEvE,QAAI,OAAO,MAAM,KAAK,aAAa,SAAS,EAAE,OAAO,KAAK,SAAS,CAAC;AACpE,WAAO,MAAM;AACX,iBAAW,UAAU,KAAK,OAAO;AAK/B,YAAI,CAAC,KAAK,cAAc,QAAQ,OAAO,EAAG;AAC1C,cAAM,UAAU,KAAK,UAAU,MAAM;AACrC,YAAI,kBAAkB,MAAM;AAC1B,gBAAM;AAAA,QACR,OAAO;AAKL,cAAI,WAAoB;AACxB,qBAAW,YAAY,eAAe;AACpC,uBAAW,KAAK,sBAAsB,UAAU,QAAQ;AAAA,UAC1D;AACA,cAAI,SAAS,SAAS,KAAK,CAAC,KAAK,cAAc,UAAe,QAAQ,EAAG;AACzE,gBAAM;AAAA,QACR;AAAA,MACF;AACA,UAAI,KAAK,eAAe,KAAM;AAC9B,aAAO,MAAM,KAAK,aAAa,SAAS;AAAA,QACtC,QAAQ,KAAK;AAAA,QACb,OAAO,KAAK;AAAA,MACd,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,cAAc,QAAW,UAA6B,KAAK,SAAkB;AACnF,QAAI,QAAQ,WAAW,EAAG,QAAO;AAKjC,UAAM,SACJ,KAAK,KAAK,mBAAmB,YAAY,OAAO,IAC5C,KAAK,UAAU,MAAM,IACrB;AACN,eAAW,UAAU,SAAS;AAC5B,UAAI,CAAC,eAAe,QAAQ,QAAQ,MAAM,EAAG,QAAO;AAAA,IACtD;AACA,WAAO;AAAA,EACT;AACF;AAKA,IAAM,yBAAiE;AAAA,EACrE,CAAC,aAAa,0BAA0B;AAAA,EACxC,CAAC,WAAW,0BAA0B;AAAA,EACtC,CAAC,QAAQ,0BAA0B;AACrC;AAEA,WAAW,CAAC,QAAQ,OAAO,KAAK,wBAAwB;AACtD,SAAO,eAAe,YAAY,WAAW,QAAQ;AAAA,IACnD,OAAO,SAAS,uBAA8B;AAC5C,YAAM,IAAI,2BAA2B,UAAU,MAAM,IAAI,OAAO;AAAA,IAClE;AAAA,IACA,UAAU;AAAA,IACV,YAAY;AAAA,IACZ,cAAc;AAAA,EAChB,CAAC;AACH;","names":[]}

package/dist/chunk-F2TDU7MQ.js

@@ -0,0 +1,456 @@
+import {
+  distinctKeyOf
+} from "./chunk-SUZKW6UR.js";
+import {
+  readPath
+} from "./chunk-HLEK5VAN.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-F2TDU7MQ.js.map

package/dist/chunk-F2TDU7MQ.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-F6NCB7KT.js

@@ -0,0 +1,13 @@
+// src/kernel/query/internal/core.ts
+function installMethods(target, mixin) {
+  for (const name of Object.getOwnPropertyNames(mixin.prototype)) {
+    if (name === "constructor") continue;
+    const desc = Object.getOwnPropertyDescriptor(mixin.prototype, name);
+    if (desc) Object.defineProperty(target, name, desc);
+  }
+}
+
+export {
+  installMethods
+};
+//# sourceMappingURL=chunk-F6NCB7KT.js.map

package/dist/chunk-F6NCB7KT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/query/internal/core.ts"],"sourcesContent":["/**\n * #1458 — how an extension group's methods reach `Query.prototype`.\n *\n * Each group defines its half of the builder as a MIXIN CLASS whose method\n * bodies moved out of `builder.ts` unchanged — `this.plan`, `this.source`,\n * `this.joinContext` and the rest still resolve, because TypeScript's\n * `private` is a compile-time construct and a method installed on the\n * prototype reads them like any other property. The mixin declares those\n * fields with `declare`, which emits nothing.\n *\n * ⭐ **Why a mixin CLASS rather than a file of `Query.prototype.x = function`\n * assignments.** The bodies are the point: several are 100+ lines carrying\n * prose that explains a decision, and a mechanical rewrite into assignment\n * form would have touched every one of them. As class methods they moved\n * byte-for-byte, so the diff shows a relocation rather than a rewrite — and an\n * overload set (`join`, `joinOn`, `aggregate`, `groupBy` all have them)\n * survives, which an assignment form cannot express.\n */\n\n/**\n * Copy a mixin's prototype methods onto a target prototype, replacing the Find\n * stubs.\n *\n * `getOwnPropertyNames` rather than `Object.assign`: class methods are\n * non-enumerable prototype properties, so `assign` copies nothing at all —\n * silently, leaving every stub in place. Descriptors are copied whole so a\n * getter stays a getter.\n */\nexport function installMethods(target: object, mixin: { prototype: object }): void {\n  for (const name of Object.getOwnPropertyNames(mixin.prototype)) {\n    if (name === 'constructor') continue\n    const desc = Object.getOwnPropertyDescriptor(mixin.prototype, name)\n    if (desc) Object.defineProperty(target, name, desc)\n  }\n}\n"],"mappings":";AA4BO,SAAS,eAAe,QAAgB,OAAoC;AACjF,aAAW,QAAQ,OAAO,oBAAoB,MAAM,SAAS,GAAG;AAC9D,QAAI,SAAS,cAAe;AAC5B,UAAM,OAAO,OAAO,yBAAyB,MAAM,WAAW,IAAI;AAClE,QAAI,KAAM,QAAO,eAAe,QAAQ,MAAM,IAAI;AAAA,EACpD;AACF;","names":[]}