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

package/dist/chunk-VHM7HCKB.js

@@ -0,0 +1,220 @@
+// src/kernel/query/live/incremental.ts
+var EMPTY_KEY = [];
+var REBUILT = { kind: "rebuilt" };
+function canMaintainIncrementally(plan, indexes) {
+  if (plan.joins.length > 0) return false;
+  if (plan.orderBy.some((o) => o.by === "label")) return false;
+  if (!clausesMaintainable(plan.clauses)) return false;
+  if (isIndexDriven(plan.clauses, indexes)) return false;
+  if (servedByOrderedIndex(plan, indexes)) return false;
+  return true;
+}
+function servedByOrderedIndex(plan, indexes) {
+  if (!indexes) return false;
+  if (plan.limit === void 0) return false;
+  if (plan.clauses.length > 0 || plan.orderBy.length !== 1) return false;
+  const order = plan.orderBy[0];
+  return order.by !== "label" && indexes.sorted(order.field);
+}
+function clausesMaintainable(clauses) {
+  for (const clause of clauses) {
+    if (clause.type === "crossJoin" || clause.type === "filter") return false;
+    if (clause.type === "group" && !clausesMaintainable(clause.clauses)) return false;
+  }
+  return true;
+}
+function isIndexDriven(clauses, indexes) {
+  if (!indexes) return false;
+  for (const clause of clauses) {
+    if (clause.type !== "field") continue;
+    if (!indexes.covers(clause.field) && !indexes.sorted(clause.field)) continue;
+    if (clause.via === void 0 && RANGE_OPS.has(clause.op)) return indexes.sorted(clause.field);
+    if (clause.via && clause.via.indexValue === void 0) continue;
+    const probe = clause.via ? clause.via.indexValue : clause.value;
+    if (clause.op === "==") return true;
+    if (clause.op === "in" && Array.isArray(probe)) return true;
+  }
+  return false;
+}
+var RANGE_OPS = /* @__PURE__ */ new Set(["<", "<=", ">", ">=", "between", "startsWith"]);
+var LiveMaintainer = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  entries = [];
+  memberById = /* @__PURE__ */ new Map();
+  seqById = /* @__PURE__ */ new Map();
+  maxSeq = -1;
+  /** Maintained state is stale — the next `rows()` rebuilds from the snapshot. */
+  stale = true;
+  /** True once a subscription is driving `apply()`. */
+  attached = false;
+  /**
+   * Start accepting deltas. Every read before this rebuilds from the snapshot,
+   * so a detached maintainer is just an eager executor.
+   *
+   * ⚠️ Call this in the SAME synchronous turn as a read — either immediately
+   * before the first `rows()` (the `.live()` path) or immediately after the
+   * initial one (the `.aggregate().live()` path, where the reduction computes
+   * before it subscribes). Attaching in a turn of its own would let a mutation
+   * slip past unrecorded: it arrives with no subscription to `apply()` it, and
+   * the maintained state would then be trusted while already behind.
+   */
+  attach() {
+    this.attached = true;
+  }
+  /**
+   * Stop accepting deltas — the subscription feeding them has gone. Every
+   * later read rebuilds, because nothing is keeping the state current any
+   * more. Without this, a `Reduction` whose `.live()` was stopped would keep
+   * serving its last maintained value from `.run()`.
+   */
+  detach() {
+    this.attached = false;
+  }
+  /** Force the next read to rebuild — the caller saw something it can't patch. */
+  invalidate() {
+    this.stale = true;
+  }
+  /**
+   * Fold one upstream change into the maintained set. A change with no
+   * payload (the source could not say which record moved) invalidates
+   * instead — the next read pays for a full rebuild.
+   */
+  apply(change) {
+    if (!this.attached || this.stale) return REBUILT;
+    if (!change) {
+      this.stale = true;
+      return REBUILT;
+    }
+    try {
+      return this.patch(change);
+    } catch (err) {
+      this.stale = true;
+      throw err;
+    }
+  }
+  /** The current result window — a fresh array on every call. */
+  rows() {
+    if (!this.attached || this.stale) this.rebuild();
+    const { offset, limit } = this.cfg;
+    const end = limit === void 0 ? this.entries.length : offset + limit;
+    const window = [];
+    for (let i = offset; i < end && i < this.entries.length; i++) {
+      window.push(this.entries[i].record);
+    }
+    return this.cfg.decode ? this.cfg.decode(window) : window;
+  }
+  /**
+   * The whole maintained set — every matching record, in maintained order,
+   * paired with its id and snapshot sequence. Ignores `offset`/`limit`/
+   * `decode` on purpose: this is the input a DERIVED maintainer rebuilds from,
+   * and grouped aggregation reduces the full match set, never a window.
+   *
+   * Rebuilds first when detached or stale, exactly as `rows()` does, so a
+   * caller can read it at any time.
+   */
+  maintainedEntries() {
+    if (!this.attached || this.stale) this.rebuild();
+    return this.entries;
+  }
+  /**
+   * Full recompute from the source snapshot. Equivalent to the eager path by
+   * construction: filter in snapshot order, then sort with snapshot sequence
+   * as the tiebreak — which is what a stable sort of the same input does.
+   */
+  rebuild() {
+    const snapshot = this.cfg.snapshotEntries();
+    this.entries = [];
+    this.memberById.clear();
+    this.seqById = /* @__PURE__ */ new Map();
+    for (let i = 0; i < snapshot.length; i++) {
+      const { id, record } = snapshot[i];
+      this.seqById.set(id, i);
+      if (this.cfg.matches(record)) {
+        const entry = { id, seq: i, record, key: this.keyOf(record) };
+        this.entries.push(entry);
+        this.memberById.set(id, entry);
+      }
+    }
+    this.maxSeq = snapshot.length - 1;
+    this.entries.sort((a, b) => this.compareEntries(a, b));
+    this.stale = false;
+  }
+  patch(change) {
+    const { id } = change;
+    const previous = this.memberById.get(id);
+    const record = change.action === "delete" ? void 0 : this.cfg.lookupById(id);
+    if (record === void 0) {
+      this.seqById.delete(id);
+      if (previous) this.removeEntry(previous);
+      return previous ? { kind: "patched", id, removed: { seq: previous.seq, record: previous.record } } : { kind: "patched", id };
+    }
+    let seq = this.seqById.get(id);
+    if (seq === void 0) {
+      seq = ++this.maxSeq;
+      this.seqById.set(id, seq);
+    }
+    const matches = this.cfg.matches(record);
+    if (previous) this.removeEntry(previous);
+    const removed = previous ? { seq: previous.seq, record: previous.record } : void 0;
+    if (!matches) {
+      return removed ? { kind: "patched", id, removed } : { kind: "patched", id };
+    }
+    const entry = { id, seq, record, key: this.keyOf(record) };
+    this.entries.splice(this.lowerBound(entry), 0, entry);
+    this.memberById.set(id, entry);
+    const inserted = { seq, record };
+    return removed ? { kind: "patched", id, removed, inserted } : { kind: "patched", id, inserted };
+  }
+  removeEntry(entry) {
+    const at = this.lowerBound(entry);
+    const index = this.entries[at] === entry ? at : this.entries.indexOf(entry);
+    if (index >= 0) this.entries.splice(index, 1);
+    this.memberById.delete(entry.id);
+  }
+  /** First index whose entry does not sort before `probe`. */
+  lowerBound(probe) {
+    let lo = 0;
+    let hi = this.entries.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (this.compareEntries(this.entries[mid], probe) < 0) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  }
+  keyOf(record) {
+    return this.cfg.order ? this.cfg.order.keyOf(record) : EMPTY_KEY;
+  }
+  /**
+   * The eager path's ordering, made total.
+   *
+   * `order.compare` is the query's own `compareOrderKeys`, the identical
+   * function `sortRecords` sorts with, so sort keys cannot be read or ranked
+   * differently here. It returns 0 for equal keys — it can do nothing else,
+   * having been handed the keys rather than the records — and the eager sort
+   * then leaves those in the order they arrived, which is candidate order,
+   * which is snapshot order given `canMaintainIncrementally` has refused every
+   * plan whose candidates arrive in index order. The sequence number below is
+   * that same resolution, made explicit so a binary search has an exact
+   * position to find. ⚠️ If the eager path ever grows a tiebreak of its own
+   * (an id, say), this stops agreeing with it — which is what
+   * `__tests__/query-incremental.test.ts`'s "inherits an order key plan that
+   * leaves equal keys to the tiebreak" is there to catch.
+   */
+  compareEntries(a, b) {
+    if (this.cfg.order) {
+      const cmp = this.cfg.order.compare(a.key, b.key);
+      if (cmp !== 0) return cmp;
+    }
+    return a.seq - b.seq;
+  }
+};
+
+export {
+  canMaintainIncrementally,
+  LiveMaintainer
+};
+//# sourceMappingURL=chunk-VHM7HCKB.js.map

package/dist/chunk-VHM7HCKB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/query/live/incremental.ts"],"sourcesContent":["/**\n * Incremental (delta) maintenance for `.live()` — #1341.\n *\n * A live query used to re-run its whole plan on every change event: scan\n * every record in the collection, re-evaluate every clause, re-sort, re-slice.\n * That is O(N log N) per keystroke-sized mutation and is what makes a reactive\n * list unusable at 10k+ rows.\n *\n * This module maintains the match set instead. Given a change event\n * `{ id, action }` it re-evaluates the predicate for **that record only** and\n * splices it into (or out of) a sorted array, so the per-change cost is\n * O(log k) comparisons + one array splice, where k is the number of MATCHING\n * records rather than N.\n *\n * ## The correctness contract\n *\n * The maintained array must be **identical** — same records, same order — to\n * what a full re-run would produce, at every step. Two things buy that:\n *\n *   1. **Membership is delegated.** The caller passes the very `matches()`\n *      closure the full pipeline uses (`filterRecords` over the plan's\n *      clauses), so a maintained membership decision cannot drift from an\n *      eagerly-computed one. This module never re-implements a predicate.\n *\n *   2. **The ordering is delegated too, and then made total.** The sort keys\n *      are read and ranked by the query's own order key plan — the same\n *      `buildOrderKeyPlan`/`orderKeyOf`/`compareOrderKeys` trio `sortRecords`\n *      sorts with and the keyset cursor compares against (#1346), so there is\n *      one definition of \"what order is this query in\" rather than two that\n *      drift. What that trio does NOT decide is equal keys: `compareOrderKeys`\n *      is handed two KEY TUPLES, not two records, so with equal keys its\n *      inputs are indistinguishable and 0 is the only answer it can give —\n *      structurally, not by convention. (#1346 breaks its own ties one level\n *      up, at the `page()` call site, never inside the comparator.) The eager\n *      path lets its stable sort resolve those, leaving them in candidate =\n *      snapshot order; we append each record's snapshot position as a final\n *      key, which is the same resolution stated explicitly — and being\n *      explicit is what lets a binary search land on an exact index.\n *\n *      ⚠️ That rests on one property of the backing cache: **snapshot order is\n *      `Map` insertion order.** `Map.set` on an existing key keeps its slot\n *      (so an update never moves a record), a new key appends (so a new record\n *      sorts last among ties), and `delete` removes without reordering the\n *      rest. `Collection`'s eager cache is a `Map`, so this holds. A source\n *      whose snapshot order is not insertion-stable must not be maintained —\n *      it would produce a correct SET in a wrong ORDER among ties.\n *\n * Anything not provably patchable falls back to a full rebuild: an unknown\n * (payload-less) change event, an error thrown mid-patch, or a plan shape\n * `canMaintainIncrementally()` refuses. **The fallback is the default** —\n * `canMaintainIncrementally` is a whitelist, not a blacklist.\n *\n * ## Stacking on top of it\n *\n * `apply()` reports what it did as a `PatchOutcome`, and `maintainedEntries()`\n * exposes the set with its snapshot sequence numbers. Together those let a\n * DERIVED maintainer mirror this one without forking its membership logic —\n * which is exactly what per-group maintenance for\n * `groupBy().aggregate().live()` does (`with-lookup/reduce/incremental-group.ts`).\n * A layer built that way inherits the whitelist and the fallback rather than\n * re-deciding them, so there is one answer to \"can this plan be maintained\"\n * rather than two that drift.\n */\n\nimport type { Clause } from '../predicate.js'\nimport type { OrderBy } from '../builder.js'\n\n/**\n * The delta a source hands to its `subscribe` callback: which record changed\n * and whether it was written or removed. Deliberately the same shape as the\n * hub-level `ChangeEvent` minus the vault/collection routing fields, which\n * the source has already filtered on.\n *\n * A source that cannot say WHICH record changed simply calls its callback with\n * no argument — every consumer treats that as \"rebuild from scratch\", which is\n * exactly the pre-#1341 behaviour.\n */\nexport interface SourceChange {\n  readonly id: string\n  readonly action: 'put' | 'delete'\n}\n\n/**\n * One side of a patch: a record that entered or left the maintained set, with\n * the snapshot sequence number it occupies. `seq` is what makes a patch\n * composable — a layer built ON TOP of the match set (grouped aggregation,\n * #1341's second half) can place the record in its own ordering without\n * re-deriving snapshot position, and sequence numbers are stable across an\n * update because `Map.set` on an existing key keeps its slot.\n */\nexport interface PatchDelta {\n  readonly seq: number\n  readonly record: unknown\n}\n\n/**\n * What `apply()` did, so a layer stacked on the maintained set can mirror it.\n *\n * `'rebuilt'` is the honest answer for everything that is NOT a clean patch —\n * a payload-less event, a detached maintainer, an already-stale one. A\n * consumer reading it must invalidate its own derived state; it must never\n * read `'rebuilt'` as \"nothing happened\".\n *\n * A `'patched'` outcome with neither `removed` nor `inserted` DID happen: a\n * non-member changed and stayed a non-member. That is a no-op for every\n * derived layer, which is exactly why it is reported as a patch rather than a\n * rebuild.\n */\nexport type PatchOutcome =\n  | { readonly kind: 'rebuilt' }\n  | {\n      readonly kind: 'patched'\n      readonly id: string\n      readonly removed?: PatchDelta\n      readonly inserted?: PatchDelta\n    }\n\n/** An id-paired member of the maintained set, in maintained order. */\nexport interface MaintainedEntry {\n  readonly id: string\n  readonly seq: number\n  readonly record: unknown\n}\n\n/**\n * The subset of a query source a DERIVED maintainer needs (#1341, grouped\n * half). Deliberately a kernel type even though its only consumer today is\n * the reduce service: everything in it is a kernel concept, and declaring it\n * here is what lets `kernel/query/builder.ts` hand one to the service without\n * a new spine to service import specifier.\n */\nexport interface GroupMaintenanceSource {\n  /**\n   * Id-paired snapshot, in snapshot (Map insertion) order.\n   *\n   * ⚠️ Declared as function-typed PROPERTIES, not methods: every member here\n   * is a standalone closure the query builder binds before handing it over,\n   * and property syntax says so — a method declaration would invite a `this`\n   * these closures do not have.\n   */\n  readonly snapshotEntries: () => readonly { id: string; record: unknown }[]\n  /** O(1) current-state lookup for the AFTER state of a change. */\n  readonly lookupById: (id: string) => unknown\n  /** The plan's membership test — the same one the eager path runs. */\n  readonly matches: (record: unknown) => boolean\n  /**\n   * Per-record projection the eager grouping pipeline applies AFTER filtering\n   * and before bucketing — today only `projectDateTruncKeys` (#1350). Applied\n   * per record here because the eager path applies it per record too; a\n   * projection that read across records could not be maintained and must not\n   * be plumbed through this hook.\n   */\n  readonly project?: (record: unknown) => unknown\n}\n\n/** Everything the maintainer needs, supplied by the query builder. */\nexport interface MaintainerConfig {\n  /** Id-paired snapshot, in snapshot (Map insertion) order. */\n  snapshotEntries(): readonly { id: string; record: unknown }[]\n  /** O(1) current-state lookup, used to read the AFTER state of a change. */\n  lookupById(id: string): unknown\n  /** The plan's membership test — the same one the eager path runs. */\n  matches(record: unknown): boolean\n  /**\n   * The plan's ordering, in the same key-plan shape `sortRecords` and the\n   * keyset cursor use (#1346): read a record's sort-key tuple, and compare two\n   * of those tuples. `undefined` when the plan has no `orderBy` — result order\n   * is then snapshot order alone.\n   *\n   * `compare` need not be a total order: it returns 0 for equal sort keys,\n   * exactly as it does for the eager sort, and the maintainer resolves those\n   * ties by snapshot sequence.\n   */\n  order?: {\n    keyOf(record: unknown): unknown[]\n    compare(a: readonly unknown[], b: readonly unknown[]): number\n  }\n  /** Plan offset (0 when unset). */\n  offset: number\n  /** Plan limit, or undefined for \"all matching rows\". */\n  limit: number | undefined\n  /**\n   * Post-slice projection the eager path applies to the emitted window (Via\n   * result decoding). Applied to the window, never to the maintained records,\n   * mirroring `toArray()` which decodes AFTER filter/sort/slice.\n   */\n  decode?: (rows: readonly unknown[]) => unknown[]\n}\n\nconst EMPTY_KEY: readonly unknown[] = []\n\n/** Shared 'you cannot patch from this' answer — allocation-free on the hot path. */\nconst REBUILT: PatchOutcome = { kind: 'rebuilt' }\n\ninterface Entry {\n  readonly id: string\n  readonly seq: number\n  readonly record: unknown\n  /**\n   * The record's sort-key tuple, computed once when the entry is built. Every\n   * write to a record re-enters it, so a cached key is never stale — and the\n   * binary search then compares tuples instead of re-reading fields at every\n   * probe.\n   */\n  readonly key: readonly unknown[]\n}\n\n/**\n * Reject any plan whose result set cannot be provably patched from a single\n * record's delta. Everything this refuses still works — it just re-runs in\n * full, as it did before #1341.\n *\n * Refused, and why:\n *   - **joins / crossJoin** — a row's membership depends on other collections'\n *     records, so a left-side delta does not determine the new result.\n *   - **`.filter(fn)`** — an arbitrary consumer closure with no determinism\n *     guarantee. `r => r.due < Date.now()` changes its verdict for records that\n *     never changed, which a full re-run observes and a patch cannot.\n *     (`.wherePredicate()` is admitted: it is DECLARED deterministic and\n *     carries a body hash saying so.)\n *   - **`orderBy(..., { by: 'label' })`** — the label maps are built eagerly\n *     from a dictionary collection's snapshot, so the comparator would be\n *     captured at subscribe time and go stale when that dictionary changes.\n *   - **an index-driven plan** — the rows then reach the pipeline in INDEX\n *     order rather than snapshot order, so snapshot sequence is the wrong\n *     tiebreak among equal sort keys. Three shapes qualify, and all three are\n *     refused: an `==`/`in` clause on any indexed field, a range clause on a\n *     SORTED-indexed field, and #1344's `orderedIndexRows()` page, which\n *     serves `orderBy(f).limit(n)` straight off a sorted index with no\n *     predicate at all. Little is lost: each of those re-runs is already\n *     proportional to the page or the match set, not to the collection.\n */\nexport function canMaintainIncrementally(\n  plan: {\n    readonly clauses: readonly Clause[]\n    readonly orderBy: readonly OrderBy[]\n    readonly limit?: number | undefined\n    readonly joins: readonly unknown[]\n  },\n  indexes: IndexProbe | null,\n): boolean {\n  if (plan.joins.length > 0) return false\n  if (plan.orderBy.some(o => o.by === 'label')) return false\n  if (!clausesMaintainable(plan.clauses)) return false\n  if (isIndexDriven(plan.clauses, indexes)) return false\n  if (servedByOrderedIndex(plan, indexes)) return false\n  return true\n}\n\n/**\n * What the maintainer needs to know about the source's indexes: which fields\n * carry ANY index, and which carry a SORTED one. Both matter — the sorted\n * index feeds two paths (#1344) the hash index does not.\n */\nexport interface IndexProbe {\n  covers(field: string): boolean\n  sorted(field: string): boolean\n}\n\n/**\n * Would #1344's `orderedIndexRows()` serve this plan off a sorted index?\n *\n * Mirrors the cheap half of its preconditions and deliberately stops there:\n * the remaining ones (full index coverage of the snapshot, no Via ordering)\n * cost a snapshot walk to check, and answering \"maybe\" here only ever costs a\n * fallback. The page it would serve is in stored-key order, and among records\n * with EQUAL keys that order is the index's, not the cache's — which is\n * precisely the tie resolution the maintainer would get wrong.\n */\nfunction servedByOrderedIndex(\n  plan: {\n    readonly clauses: readonly Clause[]\n    readonly orderBy: readonly OrderBy[]\n    readonly limit?: number | undefined\n  },\n  indexes: IndexProbe | null,\n): boolean {\n  if (!indexes) return false\n  if (plan.limit === undefined) return false\n  if (plan.clauses.length > 0 || plan.orderBy.length !== 1) return false\n  const order = plan.orderBy[0]!\n  return order.by !== 'label' && indexes.sorted(order.field)\n}\n\nfunction clausesMaintainable(clauses: readonly Clause[]): boolean {\n  for (const clause of clauses) {\n    if (clause.type === 'crossJoin' || clause.type === 'filter') return false\n    if (clause.type === 'group' && !clausesMaintainable(clause.clauses)) return false\n  }\n  return true\n}\n\n/**\n * Would `candidateRecords()` take the index fast path for this plan?\n *\n * Deliberately more eager to say \"yes\" than `candidateRecords` itself (which\n * additionally requires the index probe to return a hit set) — erring that way\n * costs a fallback, never a wrong answer.\n */\nfunction isIndexDriven(clauses: readonly Clause[], indexes: IndexProbe | null): boolean {\n  if (!indexes) return false\n  for (const clause of clauses) {\n    if (clause.type !== 'field') continue\n    if (!indexes.covers(clause.field) && !indexes.sorted(clause.field)) continue\n    // #1344: a range probe reads the SORTED index, and only for a clause the\n    // Via layer has not claimed — mirroring `candidateRecords`'s own branch.\n    // On a hash-only field `lookupRange` returns null and the plan scans, so\n    // that case is left maintainable.\n    if (clause.via === undefined && RANGE_OPS.has(clause.op)) return indexes.sorted(clause.field)\n    if (clause.via && clause.via.indexValue === undefined) continue\n    const probe = clause.via ? clause.via.indexValue : clause.value\n    if (clause.op === '==') return true\n    if (clause.op === 'in' && Array.isArray(probe)) return true\n  }\n  return false\n}\n\n/** The operators #1344's `lookupRange` serves off a sorted index. */\nconst RANGE_OPS: ReadonlySet<string> = new Set(['<', '<=', '>', '>=', 'between', 'startsWith'])\n\n/**\n * The maintained result set behind one live query.\n *\n * Lifecycle: `attach()` when a subscription opens, `apply(change)` per upstream\n * event, `rows()` to read the current window. Before `attach()` (and after any\n * fallback) `rows()` recomputes from the snapshot, so a detached maintainer is\n * simply an eager executor and is safe to read at any time.\n */\nexport class LiveMaintainer {\n  private entries: Entry[] = []\n  private readonly memberById = new Map<string, Entry>()\n  private seqById = new Map<string, number>()\n  private maxSeq = -1\n  /** Maintained state is stale — the next `rows()` rebuilds from the snapshot. */\n  private stale = true\n  /** True once a subscription is driving `apply()`. */\n  private attached = false\n\n  constructor(private readonly cfg: MaintainerConfig) {}\n\n  /**\n   * Start accepting deltas. Every read before this rebuilds from the snapshot,\n   * so a detached maintainer is just an eager executor.\n   *\n   * ⚠️ Call this in the SAME synchronous turn as a read — either immediately\n   * before the first `rows()` (the `.live()` path) or immediately after the\n   * initial one (the `.aggregate().live()` path, where the reduction computes\n   * before it subscribes). Attaching in a turn of its own would let a mutation\n   * slip past unrecorded: it arrives with no subscription to `apply()` it, and\n   * the maintained state would then be trusted while already behind.\n   */\n  attach(): void {\n    this.attached = true\n  }\n\n  /**\n   * Stop accepting deltas — the subscription feeding them has gone. Every\n   * later read rebuilds, because nothing is keeping the state current any\n   * more. Without this, a `Reduction` whose `.live()` was stopped would keep\n   * serving its last maintained value from `.run()`.\n   */\n  detach(): void {\n    this.attached = false\n  }\n\n  /** Force the next read to rebuild — the caller saw something it can't patch. */\n  invalidate(): void {\n    this.stale = true\n  }\n\n  /**\n   * Fold one upstream change into the maintained set. A change with no\n   * payload (the source could not say which record moved) invalidates\n   * instead — the next read pays for a full rebuild.\n   */\n  apply(change: SourceChange | undefined): PatchOutcome {\n    if (!this.attached || this.stale) return REBUILT\n    if (!change) {\n      this.stale = true\n      return REBUILT\n    }\n    try {\n      return this.patch(change)\n    } catch (err) {\n      // A predicate threw mid-patch: the maintained set may be half-updated,\n      // so drop it rather than serve a set we can no longer vouch for. The\n      // error still reaches the consumer — the rebuild on the next read runs\n      // the same predicate and throws the same way.\n      this.stale = true\n      throw err\n    }\n  }\n\n  /** The current result window — a fresh array on every call. */\n  rows(): unknown[] {\n    if (!this.attached || this.stale) this.rebuild()\n    const { offset, limit } = this.cfg\n    const end = limit === undefined ? this.entries.length : offset + limit\n    const window: unknown[] = []\n    for (let i = offset; i < end && i < this.entries.length; i++) {\n      window.push(this.entries[i]!.record)\n    }\n    return this.cfg.decode ? this.cfg.decode(window) : window\n  }\n\n  /**\n   * The whole maintained set — every matching record, in maintained order,\n   * paired with its id and snapshot sequence. Ignores `offset`/`limit`/\n   * `decode` on purpose: this is the input a DERIVED maintainer rebuilds from,\n   * and grouped aggregation reduces the full match set, never a window.\n   *\n   * Rebuilds first when detached or stale, exactly as `rows()` does, so a\n   * caller can read it at any time.\n   */\n  maintainedEntries(): readonly MaintainedEntry[] {\n    if (!this.attached || this.stale) this.rebuild()\n    return this.entries\n  }\n\n  /**\n   * Full recompute from the source snapshot. Equivalent to the eager path by\n   * construction: filter in snapshot order, then sort with snapshot sequence\n   * as the tiebreak — which is what a stable sort of the same input does.\n   */\n  private rebuild(): void {\n    const snapshot = this.cfg.snapshotEntries()\n    this.entries = []\n    this.memberById.clear()\n    this.seqById = new Map()\n    for (let i = 0; i < snapshot.length; i++) {\n      const { id, record } = snapshot[i]!\n      this.seqById.set(id, i)\n      if (this.cfg.matches(record)) {\n        const entry: Entry = { id, seq: i, record, key: this.keyOf(record) }\n        this.entries.push(entry)\n        this.memberById.set(id, entry)\n      }\n    }\n    this.maxSeq = snapshot.length - 1\n    this.entries.sort((a, b) => this.compareEntries(a, b))\n    this.stale = false\n  }\n\n  private patch(change: SourceChange): PatchOutcome {\n    const { id } = change\n    const previous = this.memberById.get(id)\n    const record = change.action === 'delete' ? undefined : this.cfg.lookupById(id)\n\n    if (record === undefined) {\n      // Gone. Its snapshot slot is released too: a later re-add of the same id\n      // appends to the cache's Map, so it must earn a fresh sequence number.\n      this.seqById.delete(id)\n      if (previous) this.removeEntry(previous)\n      return previous\n        ? { kind: 'patched', id, removed: { seq: previous.seq, record: previous.record } }\n        : { kind: 'patched', id }\n    }\n\n    let seq = this.seqById.get(id)\n    if (seq === undefined) {\n      // A key the snapshot did not carry — `Map.set` appended it, so it sorts\n      // after every record we have seen.\n      seq = ++this.maxSeq\n      this.seqById.set(id, seq)\n    }\n\n    const matches = this.cfg.matches(record)\n    if (previous) this.removeEntry(previous)\n    const removed = previous ? { seq: previous.seq, record: previous.record } : undefined\n    if (!matches) {\n      return removed ? { kind: 'patched', id, removed } : { kind: 'patched', id }\n    }\n\n    const entry: Entry = { id, seq, record, key: this.keyOf(record) }\n    this.entries.splice(this.lowerBound(entry), 0, entry)\n    this.memberById.set(id, entry)\n    const inserted = { seq, record }\n    return removed ? { kind: 'patched', id, removed, inserted } : { kind: 'patched', id, inserted }\n  }\n\n  private removeEntry(entry: Entry): void {\n    // The comparator is a total order (sequence numbers are unique), so the\n    // binary search lands exactly on the entry. The linear scan is a belt-and-\n    // braces fallback for a source that broke the ordering assumption.\n    const at = this.lowerBound(entry)\n    const index = this.entries[at] === entry ? at : this.entries.indexOf(entry)\n    if (index >= 0) this.entries.splice(index, 1)\n    this.memberById.delete(entry.id)\n  }\n\n  /** First index whose entry does not sort before `probe`. */\n  private lowerBound(probe: Entry): number {\n    let lo = 0\n    let hi = this.entries.length\n    while (lo < hi) {\n      const mid = (lo + hi) >>> 1\n      if (this.compareEntries(this.entries[mid]!, probe) < 0) lo = mid + 1\n      else hi = mid\n    }\n    return lo\n  }\n\n  private keyOf(record: unknown): readonly unknown[] {\n    return this.cfg.order ? this.cfg.order.keyOf(record) : EMPTY_KEY\n  }\n\n  /**\n   * The eager path's ordering, made total.\n   *\n   * `order.compare` is the query's own `compareOrderKeys`, the identical\n   * function `sortRecords` sorts with, so sort keys cannot be read or ranked\n   * differently here. It returns 0 for equal keys — it can do nothing else,\n   * having been handed the keys rather than the records — and the eager sort\n   * then leaves those in the order they arrived, which is candidate order,\n   * which is snapshot order given `canMaintainIncrementally` has refused every\n   * plan whose candidates arrive in index order. The sequence number below is\n   * that same resolution, made explicit so a binary search has an exact\n   * position to find. ⚠️ If the eager path ever grows a tiebreak of its own\n   * (an id, say), this stops agreeing with it — which is what\n   * `__tests__/query-incremental.test.ts`'s \"inherits an order key plan that\n   * leaves equal keys to the tiebreak\" is there to catch.\n   */\n  private compareEntries(a: Entry, b: Entry): number {\n    if (this.cfg.order) {\n      const cmp = this.cfg.order.compare(a.key, b.key)\n      if (cmp !== 0) return cmp\n    }\n    return a.seq - b.seq\n  }\n}\n"],"mappings":";AA6LA,IAAM,YAAgC,CAAC;AAGvC,IAAM,UAAwB,EAAE,MAAM,UAAU;AAwCzC,SAAS,yBACd,MAMA,SACS;AACT,MAAI,KAAK,MAAM,SAAS,EAAG,QAAO;AAClC,MAAI,KAAK,QAAQ,KAAK,OAAK,EAAE,OAAO,OAAO,EAAG,QAAO;AACrD,MAAI,CAAC,oBAAoB,KAAK,OAAO,EAAG,QAAO;AAC/C,MAAI,cAAc,KAAK,SAAS,OAAO,EAAG,QAAO;AACjD,MAAI,qBAAqB,MAAM,OAAO,EAAG,QAAO;AAChD,SAAO;AACT;AAsBA,SAAS,qBACP,MAKA,SACS;AACT,MAAI,CAAC,QAAS,QAAO;AACrB,MAAI,KAAK,UAAU,OAAW,QAAO;AACrC,MAAI,KAAK,QAAQ,SAAS,KAAK,KAAK,QAAQ,WAAW,EAAG,QAAO;AACjE,QAAM,QAAQ,KAAK,QAAQ,CAAC;AAC5B,SAAO,MAAM,OAAO,WAAW,QAAQ,OAAO,MAAM,KAAK;AAC3D;AAEA,SAAS,oBAAoB,SAAqC;AAChE,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,SAAS,eAAe,OAAO,SAAS,SAAU,QAAO;AACpE,QAAI,OAAO,SAAS,WAAW,CAAC,oBAAoB,OAAO,OAAO,EAAG,QAAO;AAAA,EAC9E;AACA,SAAO;AACT;AASA,SAAS,cAAc,SAA4B,SAAqC;AACtF,MAAI,CAAC,QAAS,QAAO;AACrB,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,SAAS,QAAS;AAC7B,QAAI,CAAC,QAAQ,OAAO,OAAO,KAAK,KAAK,CAAC,QAAQ,OAAO,OAAO,KAAK,EAAG;AAKpE,QAAI,OAAO,QAAQ,UAAa,UAAU,IAAI,OAAO,EAAE,EAAG,QAAO,QAAQ,OAAO,OAAO,KAAK;AAC5F,QAAI,OAAO,OAAO,OAAO,IAAI,eAAe,OAAW;AACvD,UAAM,QAAQ,OAAO,MAAM,OAAO,IAAI,aAAa,OAAO;AAC1D,QAAI,OAAO,OAAO,KAAM,QAAO;AAC/B,QAAI,OAAO,OAAO,QAAQ,MAAM,QAAQ,KAAK,EAAG,QAAO;AAAA,EACzD;AACA,SAAO;AACT;AAGA,IAAM,YAAiC,oBAAI,IAAI,CAAC,KAAK,MAAM,KAAK,MAAM,WAAW,YAAY,CAAC;AAUvF,IAAM,iBAAN,MAAqB;AAAA,EAU1B,YAA6B,KAAuB;AAAvB;AAAA,EAAwB;AAAA,EAAxB;AAAA,EATrB,UAAmB,CAAC;AAAA,EACX,aAAa,oBAAI,IAAmB;AAAA,EAC7C,UAAU,oBAAI,IAAoB;AAAA,EAClC,SAAS;AAAA;AAAA,EAET,QAAQ;AAAA;AAAA,EAER,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAenB,SAAe;AACb,SAAK,WAAW;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,SAAe;AACb,SAAK,WAAW;AAAA,EAClB;AAAA;AAAA,EAGA,aAAmB;AACjB,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,QAAgD;AACpD,QAAI,CAAC,KAAK,YAAY,KAAK,MAAO,QAAO;AACzC,QAAI,CAAC,QAAQ;AACX,WAAK,QAAQ;AACb,aAAO;AAAA,IACT;AACA,QAAI;AACF,aAAO,KAAK,MAAM,MAAM;AAAA,IAC1B,SAAS,KAAK;AAKZ,WAAK,QAAQ;AACb,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA,EAGA,OAAkB;AAChB,QAAI,CAAC,KAAK,YAAY,KAAK,MAAO,MAAK,QAAQ;AAC/C,UAAM,EAAE,QAAQ,MAAM,IAAI,KAAK;AAC/B,UAAM,MAAM,UAAU,SAAY,KAAK,QAAQ,SAAS,SAAS;AACjE,UAAM,SAAoB,CAAC;AAC3B,aAAS,IAAI,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ,QAAQ,KAAK;AAC5D,aAAO,KAAK,KAAK,QAAQ,CAAC,EAAG,MAAM;AAAA,IACrC;AACA,WAAO,KAAK,IAAI,SAAS,KAAK,IAAI,OAAO,MAAM,IAAI;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,oBAAgD;AAC9C,QAAI,CAAC,KAAK,YAAY,KAAK,MAAO,MAAK,QAAQ;AAC/C,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,UAAgB;AACtB,UAAM,WAAW,KAAK,IAAI,gBAAgB;AAC1C,SAAK,UAAU,CAAC;AAChB,SAAK,WAAW,MAAM;AACtB,SAAK,UAAU,oBAAI,IAAI;AACvB,aAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,YAAM,EAAE,IAAI,OAAO,IAAI,SAAS,CAAC;AACjC,WAAK,QAAQ,IAAI,IAAI,CAAC;AACtB,UAAI,KAAK,IAAI,QAAQ,MAAM,GAAG;AAC5B,cAAM,QAAe,EAAE,IAAI,KAAK,GAAG,QAAQ,KAAK,KAAK,MAAM,MAAM,EAAE;AACnE,aAAK,QAAQ,KAAK,KAAK;AACvB,aAAK,WAAW,IAAI,IAAI,KAAK;AAAA,MAC/B;AAAA,IACF;AACA,SAAK,SAAS,SAAS,SAAS;AAChC,SAAK,QAAQ,KAAK,CAAC,GAAG,MAAM,KAAK,eAAe,GAAG,CAAC,CAAC;AACrD,SAAK,QAAQ;AAAA,EACf;AAAA,EAEQ,MAAM,QAAoC;AAChD,UAAM,EAAE,GAAG,IAAI;AACf,UAAM,WAAW,KAAK,WAAW,IAAI,EAAE;AACvC,UAAM,SAAS,OAAO,WAAW,WAAW,SAAY,KAAK,IAAI,WAAW,EAAE;AAE9E,QAAI,WAAW,QAAW;AAGxB,WAAK,QAAQ,OAAO,EAAE;AACtB,UAAI,SAAU,MAAK,YAAY,QAAQ;AACvC,aAAO,WACH,EAAE,MAAM,WAAW,IAAI,SAAS,EAAE,KAAK,SAAS,KAAK,QAAQ,SAAS,OAAO,EAAE,IAC/E,EAAE,MAAM,WAAW,GAAG;AAAA,IAC5B;AAEA,QAAI,MAAM,KAAK,QAAQ,IAAI,EAAE;AAC7B,QAAI,QAAQ,QAAW;AAGrB,YAAM,EAAE,KAAK;AACb,WAAK,QAAQ,IAAI,IAAI,GAAG;AAAA,IAC1B;AAEA,UAAM,UAAU,KAAK,IAAI,QAAQ,MAAM;AACvC,QAAI,SAAU,MAAK,YAAY,QAAQ;AACvC,UAAM,UAAU,WAAW,EAAE,KAAK,SAAS,KAAK,QAAQ,SAAS,OAAO,IAAI;AAC5E,QAAI,CAAC,SAAS;AACZ,aAAO,UAAU,EAAE,MAAM,WAAW,IAAI,QAAQ,IAAI,EAAE,MAAM,WAAW,GAAG;AAAA,IAC5E;AAEA,UAAM,QAAe,EAAE,IAAI,KAAK,QAAQ,KAAK,KAAK,MAAM,MAAM,EAAE;AAChE,SAAK,QAAQ,OAAO,KAAK,WAAW,KAAK,GAAG,GAAG,KAAK;AACpD,SAAK,WAAW,IAAI,IAAI,KAAK;AAC7B,UAAM,WAAW,EAAE,KAAK,OAAO;AAC/B,WAAO,UAAU,EAAE,MAAM,WAAW,IAAI,SAAS,SAAS,IAAI,EAAE,MAAM,WAAW,IAAI,SAAS;AAAA,EAChG;AAAA,EAEQ,YAAY,OAAoB;AAItC,UAAM,KAAK,KAAK,WAAW,KAAK;AAChC,UAAM,QAAQ,KAAK,QAAQ,EAAE,MAAM,QAAQ,KAAK,KAAK,QAAQ,QAAQ,KAAK;AAC1E,QAAI,SAAS,EAAG,MAAK,QAAQ,OAAO,OAAO,CAAC;AAC5C,SAAK,WAAW,OAAO,MAAM,EAAE;AAAA,EACjC;AAAA;AAAA,EAGQ,WAAW,OAAsB;AACvC,QAAI,KAAK;AACT,QAAI,KAAK,KAAK,QAAQ;AACtB,WAAO,KAAK,IAAI;AACd,YAAM,MAAO,KAAK,OAAQ;AAC1B,UAAI,KAAK,eAAe,KAAK,QAAQ,GAAG,GAAI,KAAK,IAAI,EAAG,MAAK,MAAM;AAAA,UAC9D,MAAK;AAAA,IACZ;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,MAAM,QAAqC;AACjD,WAAO,KAAK,IAAI,QAAQ,KAAK,IAAI,MAAM,MAAM,MAAM,IAAI;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBQ,eAAe,GAAU,GAAkB;AACjD,QAAI,KAAK,IAAI,OAAO;AAClB,YAAM,MAAM,KAAK,IAAI,MAAM,QAAQ,EAAE,KAAK,EAAE,GAAG;AAC/C,UAAI,QAAQ,EAAG,QAAO;AAAA,IACxB;AACA,WAAO,EAAE,MAAM,EAAE;AAAA,EACnB;AACF;","names":[]}

package/dist/{chunk-DGOZ4UZD.js → chunk-VNNRUGMM.js}

@@ -1,6 +1,6 @@
 import {
   DuplicateBehaviorNameError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
 
 // src/with-audit/guards/registry.ts
 var GuardRegistry = class {
@@ -141,4 +141,4 @@ var GuardRegistry = class {
 export {
   GuardRegistry
 };
-//# sourceMappingURL=chunk-DGOZ4UZD.js.map
+//# sourceMappingURL=chunk-VNNRUGMM.js.map

package/dist/{chunk-HDOU6I2Y.js → chunk-VNPEWFPD.js}

@@ -6,15 +6,15 @@ import {
   ViaGraph,
   matchTargetFieldNames,
   schemaFieldKeys
-} from "./chunk-2C3AQB46.js";
+} from "./chunk-UD5EVGZ7.js";
 import {
   sha256Hex
-} from "./chunk-SL3JAAKN.js";
+} from "./chunk-UYB234ZR.js";
 import {
   DerivationCycleError,
   DuplicateBehaviorNameError,
   ValidationError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
 
 // src/with-formula/derivations/strategy-hash.ts
 async function computeStrategyHash(source, outputKeys, derive, sources) {
@@ -244,4 +244,4 @@ var DerivationRegistry = class {
 export {
   DerivationRegistry
 };
-//# sourceMappingURL=chunk-HDOU6I2Y.js.map
+//# sourceMappingURL=chunk-VNPEWFPD.js.map

package/dist/{chunk-L7CIOOBW.js → chunk-WNJ4AVGE.js}

@@ -1,6 +1,6 @@
 import {
   writePod
-} from "./chunk-5WDXHNSW.js";
+} from "./chunk-HBPPGWUM.js";
 
 // src/with-audit/portability/export-accessible.ts
 function resolveAccessibleCollections(keyring, scope, writableOnly = false) {
@@ -42,4 +42,4 @@ export {
   buildAccessibleBundle,
   exportAccessibleData
 };
-//# sourceMappingURL=chunk-L7CIOOBW.js.map
+//# sourceMappingURL=chunk-WNJ4AVGE.js.map

package/dist/{chunk-FMZY5Q6L.js → chunk-WX5ADGTZ.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-5D2ALSM5.js";
 import {
   RecordCodec
-} from "./chunk-77K4PG6P.js";
+} from "./chunk-KJFW62P4.js";
 
 // src/with-formula/materialized-views/stale.ts
-var loadMVExecutor = lazy(() => import("./executor-PUAO6AKJ.js"));
+var loadMVExecutor = lazy(() => import("./executor-B6SRO2QS.js"));
 var _staleByRegistry = /* @__PURE__ */ new WeakMap();
 function markMVStale(registry, mvName) {
   let set = _staleByRegistry.get(registry);
@@ -134,4 +134,4 @@ export {
   clearMVStale,
   clearMVStaleFully
 };
-//# sourceMappingURL=chunk-FMZY5Q6L.js.map
+//# sourceMappingURL=chunk-WX5ADGTZ.js.map

package/dist/{chunk-VXANTWBJ.js → chunk-WY2XXTET.js}

@@ -1,13 +1,13 @@
 import {
   readPath
-} from "./chunk-NSITFOCJ.js";
+} from "./chunk-HLEK5VAN.js";
 import {
   installViaBinder
-} from "./chunk-UXVWEX5L.js";
+} from "./chunk-Z5HTYMMQ.js";
 import {
   NoydbError,
   ValidationError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
 
 // src/via/money/iso4217.ts
 var MINOR_UNITS = {
@@ -816,18 +816,100 @@ function moneyMinMaxReducer(op, field, desc) {
     }
   };
 }
+function parseProbability(p) {
+  const { int, scale } = parseRate(p);
+  return { num: int, den: 10n ** BigInt(scale) };
+}
+function quantileScaled(sorted, p) {
+  const n = sorted.length;
+  if (n === 1) return sorted[0];
+  const { num, den } = parseProbability(p);
+  const xNum = num * BigInt(n - 1);
+  const lo = xNum / den;
+  const rem = xNum - lo * den;
+  const i = Number(lo);
+  if (rem === 0n) return sorted[i];
+  const a = sorted[i];
+  const b = sorted[i + 1];
+  return a + divRoundHalfEven((b - a) * rem, den);
+}
+function moneyQuantileReducer(op, field, desc, p) {
+  const quantile = (arr) => {
+    const sorted = [...arr].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
+    return quantileScaled(sorted, p);
+  };
+  return {
+    op,
+    field,
+    p,
+    init: () => /* @__PURE__ */ new Map(),
+    step: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) arr.push(m.value);
+        else state.set(m.currency, [m.value]);
+      }
+      return state;
+    },
+    remove: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) {
+          const idx = arr.indexOf(m.value);
+          if (idx >= 0) arr.splice(idx, 1);
+        }
+      }
+      return state;
+    },
+    finalize: (state) => {
+      if (desc.mode === "fixed") {
+        const cur = desc.fixedCurrency;
+        const arr = state.get(cur);
+        if (!arr || arr.length === 0) return null;
+        return formatScaledInt(quantile(arr), desc.scaleFor(cur));
+      }
+      const out = {};
+      for (const [cur, arr] of state) {
+        if (arr.length > 0) out[cur] = formatScaledInt(quantile(arr), desc.scaleFor(cur));
+      }
+      return out;
+    }
+  };
+}
+var MONEY_REFUSALS = {
+  avg: 'avg() is not supported on money field "%s" in v1 \u2014 use sum() and count() and divide at the boundary.',
+  variance: 'variance() is not supported on money field "%s" \u2014 a variance of currency is not a currency amount, and the exact BigInt path cannot express it. Read the scaled integers out and compute at the boundary.',
+  stddev: 'stddev() is not supported on money field "%s" \u2014 a square root is not a decimal, so there is no exact answer to return. Read the scaled integers out and compute at the boundary.',
+  mode: 'mode() is not implemented for money field "%s" (#1353) \u2014 it is exactly computable, but the generic reducer would read the stored scaled integer as 0, so it refuses rather than answer wrongly.'
+};
 function wrapMoneyReducers(spec, moneyFields) {
   let changed = false;
   const out = {};
   for (const [key, reducer] of Object.entries(spec)) {
     const field = reducer.field;
     const desc = field ? moneyFields[field] : void 0;
-    if (desc && reducer.op === "avg") {
+    const refusal = desc && reducer.op ? MONEY_REFUSALS[reducer.op] : void 0;
+    if (refusal !== void 0) {
+      throw new MoneyUnsupportedError(field, refusal.replace("%s", field));
+    }
+    if (desc && reducer.op === "percentile" && reducer.approx === true) {
       throw new MoneyUnsupportedError(
         field,
-        `avg() is not supported on money field "${field}" in v1 \u2014 use sum() and count() and divide at the boundary.`
+        `percentile({ approx: true }) is not supported on money field "${field}" \u2014 a t-digest summarises values as floating-point centroids. Drop \`approx\` for the exact BigInt path (O(n) memory per group).`
       );
     }
+    if (desc && (reducer.op === "median" || reducer.op === "percentile")) {
+      changed = true;
+      out[key] = moneyQuantileReducer(
+        reducer.op,
+        field,
+        desc,
+        reducer.op === "median" ? 0.5 : reducer.p ?? 0.5
+      );
+      continue;
+    }
     if (desc && (reducer.op === "sum" || reducer.op === "min" || reducer.op === "max")) {
       changed = true;
       out[key] = reducer.op === "sum" ? moneySumReducer(field, desc, reducer.convertTo, reducer.fx) : moneyMinMaxReducer(reducer.op, field, desc);
@@ -845,8 +927,12 @@ function moneyVia(moneyFields, virtualMoneyFields) {
   const ordinaryPresentFields = hasVirtualMoney ? Object.fromEntries(Object.entries(moneyFields).filter(([f]) => !virtualMoneyFields.has(f))) : moneyFields;
   return {
     brand: "money",
+    presentIsSync: true,
+    // #1416 — decodeMoneyFields / presentVirtualMoneyFields are plain functions
     posture: { encryptedAtRest: "envelope", queryable: "ordered", exportable: true, forgettable: true },
     covers: (field) => field in moneyFields,
+    coveredFields: Object.keys(moneyFields),
+    // #1447
     ingest: (r) => canonicalizeIncomingMoney(r, moneyFields),
     canonicalizeStored: (r) => canonicalizeStoredMoney(r, moneyFields),
     encodeWrite: (r) => quantizeMoneyFields(r, moneyFields),
@@ -1044,4 +1130,4 @@ export {
   decodeMoneyFields,
   exactMath
 };
-//# sourceMappingURL=chunk-VXANTWBJ.js.map
+//# sourceMappingURL=chunk-WY2XXTET.js.map