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

package/dist/chunk-T52GX4SA.js

@@ -0,0 +1,215 @@
+import {
+  buildLiveReduction,
+  compareReduced
+} from "./chunk-CF5UU4S7.js";
+import {
+  canonicalGroupKey
+} from "./chunk-XZHEOSQ2.js";
+import {
+  bindDistinctReducers,
+  moneySum,
+  sum
+} from "./chunk-F2TDU7MQ.js";
+import {
+  isDateTruncKey,
+  projectDateTruncKeys
+} from "./chunk-XBKH4FOC.js";
+import {
+  readPath
+} from "./chunk-HLEK5VAN.js";
+
+// src/with-lookup/reduce/window.ts
+function isWindowFn(v) {
+  return typeof v === "object" && v !== null && v.__window === true;
+}
+function rowNumber() {
+  return {
+    __window: true,
+    op: "rowNumber",
+    evaluate: (rows) => rows.map((_, i) => i + 1)
+  };
+}
+function rank() {
+  return {
+    __window: true,
+    op: "rank",
+    evaluate: (_rows, peerStart) => peerStart.map((start) => start + 1)
+  };
+}
+function assertOffset(op, offset) {
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new Error(`${op}(): offset must be a non-negative integer, got ${offset}.`);
+  }
+}
+function lag(field, offset = 1, defaultValue) {
+  assertOffset("lag", offset);
+  return {
+    __window: true,
+    op: "lag",
+    evaluate: (rows) => rows.map((_, i) => i - offset >= 0 ? readPath(rows[i - offset], field) : defaultValue)
+  };
+}
+function lead(field, offset = 1, defaultValue) {
+  assertOffset("lead", offset);
+  return {
+    __window: true,
+    op: "lead",
+    evaluate: (rows) => rows.map((_, i) => i + offset < rows.length ? readPath(rows[i + offset], field) : defaultValue)
+  };
+}
+function runningSum(field) {
+  return sum(field);
+}
+function runningMoneySum(field) {
+  return moneySum(field);
+}
+function asArray(v) {
+  if (v === void 0) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function normalizeWindow(spec) {
+  const derived = [];
+  const keyOf = (k) => {
+    if (!isDateTruncKey(k)) return k;
+    derived.push(k);
+    return k.as;
+  };
+  const partitionKeys = asArray(spec.partitionBy).map(keyOf);
+  const orderBy = asArray(spec.orderBy).map((entry) => {
+    if (typeof entry === "string" || isDateTruncKey(entry)) {
+      return { key: keyOf(entry), direction: "asc" };
+    }
+    return { key: keyOf(entry.field), direction: entry.direction ?? "asc" };
+  });
+  return { partitionKeys, orderBy, derived };
+}
+function applyWindow(records, spec, select) {
+  const { partitionKeys, orderBy, derived } = normalizeWindow(spec);
+  const n = records.length;
+  if (n === 0) return [];
+  const keyRows = derived.length === 0 ? records : projectDateTruncKeys(records, derived);
+  const partitions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    let dedupKey = "";
+    if (partitionKeys.length > 0) {
+      const keyValues = {};
+      for (const f of partitionKeys) keyValues[f] = readPath(keyRows[i], f);
+      dedupKey = canonicalGroupKey(partitionKeys, keyValues);
+    }
+    const bucket = partitions.get(dedupKey);
+    if (bucket) bucket.push(i);
+    else partitions.set(dedupKey, [i]);
+  }
+  const compareByKeys = (a, b) => {
+    for (const { key, direction } of orderBy) {
+      const cmp = compareReduced(readPath(keyRows[a], key), readPath(keyRows[b], key));
+      if (cmp !== 0) return direction === "asc" ? cmp : -cmp;
+    }
+    return 0;
+  };
+  const slots = Object.entries(select);
+  const out = records.map((r) => ({ ...r }));
+  for (const indices of partitions.values()) {
+    indices.sort(compareByKeys);
+    const ordered = indices.map((i) => records[i]);
+    const peerStart = new Array(indices.length);
+    for (let k = 0; k < indices.length; k++) {
+      peerStart[k] = k === 0 || compareByKeys(indices[k - 1], indices[k]) !== 0 ? k : peerStart[k - 1];
+    }
+    for (const [name, slot] of slots) {
+      if (isWindowFn(slot)) {
+        const values = slot.evaluate(ordered, peerStart);
+        for (let k = 0; k < indices.length; k++) out[indices[k]][name] = values[k];
+        continue;
+      }
+      let state = slot.init();
+      for (let k = 0; k < indices.length; k++) {
+        state = slot.step(state, ordered[k]);
+        out[indices[k]][name] = slot.finalize(state);
+      }
+    }
+  }
+  return out;
+}
+function withWindow() {
+  return (executeRecords, spec, upstreams, via) => new WindowedQuery(executeRecords, spec, upstreams, via);
+}
+var WindowedQuery = class {
+  constructor(executeRecords, spec, upstreams, via) {
+    this.executeRecords = executeRecords;
+    this.spec = spec;
+    this.upstreams = upstreams;
+    this.via = via;
+  }
+  executeRecords;
+  spec;
+  upstreams;
+  via;
+  /**
+   * Attach window outputs to every row. Each slot is either a
+   * {@link WindowFn} (`rowNumber`, `rank`, `lag`, `lead`) or a `Reducer`,
+   * which runs as a running aggregate over `rows unbounded preceding →
+   * current row`.
+   *
+   * Reducers are rewritten through the collection's Via pipeline exactly as
+   * `.aggregate()` rewrites them, so a `sum` over a declared money field
+   * becomes the exact BigInt accumulator and a `countDistinct` dedups on the
+   * canonical index key.
+   */
+  select(spec) {
+    const reducersOnly = {};
+    for (const [k, v] of Object.entries(spec)) {
+      if (!isWindowFn(v)) reducersOnly[k] = v;
+    }
+    const wrapped = bindDistinctReducers(
+      this.via ? this.via.wrapReducers(reducersOnly) : reducersOnly,
+      this.via
+    );
+    const effective = { ...spec };
+    for (const [k, v] of Object.entries(wrapped)) effective[k] = v;
+    return new WindowSelection(
+      this.executeRecords,
+      this.spec,
+      effective,
+      this.upstreams
+    );
+  }
+};
+var WindowSelection = class {
+  constructor(executeRecords, spec, select, upstreams) {
+    this.executeRecords = executeRecords;
+    this.spec = spec;
+    this.select = select;
+    this.upstreams = upstreams;
+  }
+  executeRecords;
+  spec;
+  select;
+  upstreams;
+  /** Execute the query and return every row, widened with the window outputs. */
+  run() {
+    return applyWindow(this.executeRecords(), this.spec, this.select);
+  }
+  /**
+   * Reactive terminal — re-runs the whole window pipeline on every upstream
+   * change, the same naive-recompute contract `GroupedReduction.live()` has.
+   * Always call `live.stop()` when finished.
+   */
+  live() {
+    return buildLiveReduction(() => this.run(), this.upstreams);
+  }
+};
+
+export {
+  rowNumber,
+  rank,
+  lag,
+  lead,
+  runningSum,
+  runningMoneySum,
+  applyWindow,
+  withWindow,
+  WindowedQuery,
+  WindowSelection
+};
+//# sourceMappingURL=chunk-T52GX4SA.js.map

package/dist/chunk-T52GX4SA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-lookup/reduce/window.ts"],"sourcesContent":["/**\n * Query DSL `.window()` — SQL window functions over the query's result rows\n * (#1349).\n *\n * ```ts\n * invoices.query()\n *   .where('status', '==', 'open')\n *   .window({ partitionBy: 'clientId', orderBy: 'date' })\n *   .select({ balance: runningSum('amount'), prev: lag('amount', 1), n: rowNumber() })\n *   .run()\n * ```\n *\n * Pure in-hub post-processing: the store holds ciphertext, so this runs after\n * decryption like every other query stage. No index is consulted — see\n * \"Complexity\" below for why the sorted-index fast path is deliberately not\n * taken in v1.\n *\n * ## What it is, precisely\n *\n * A window function adds COLUMNS to a row; it never adds, removes or reorders\n * rows. `.select()` therefore returns the query's own rows, in the query's own\n * order, each widened with the window outputs. `orderBy` inside `.window()`\n * decides how a PARTITION is walked; `Query.orderBy()` decides how the RESULT\n * is presented. That is SQL's split and both are honoured independently.\n *\n * ⭐ Distinguished from `.groupBy()` by ARITY: `.groupBy().aggregate()` emits\n * one row per bucket and drops the source rows; `.window().select()` keeps\n * every source row and attaches per-row values computed over its partition.\n *\n * ## The frame — `rows unbounded preceding → current row`, and only that\n *\n * A running aggregate at position `i` of its partition sees exactly rows\n * `0..i`. There is no `RANGE`, no `n preceding`, no `following`, and no\n * `frame` option to pass — explicit frames are a separate feature, and a\n * half-built frame surface is worse than none. `lag`/`lead` are navigation,\n * not aggregation, so they are unaffected by the frame.\n *\n * ## Ordering inside a partition is TOTAL\n *\n * Rows are sorted by the `orderBy` keys and, where those compare equal, by\n * their UPSTREAM POSITION — the sort is a stable sort over an ascending index\n * array, so equal keys keep the order the query produced them in. Without that\n * final key, `lag`/`lead` over equal keys would be a coin flip between runs.\n *\n * The value comparator is {@link compareReduced}, shared with the post-group\n * ordering of #1336 rather than reinvented, and for the same reason: a money\n * value reaches this stage DECODED, as an exact decimal string, and lexical\n * order gets `'9882.00'` vs `'10004.00'` backwards. (The pre-group row\n * pipeline asks `ViaPipeline.compareForOrder` instead — that reads the STORED\n * scaled-integer form, which is not what a decoded row holds, so it cannot\n * serve here.)\n *\n * PEER-ship for `rank` is decided by the `orderBy` keys ALONE, never by the\n * upstream tie-break — otherwise no two rows would ever be peers and `rank`\n * would collapse into `rowNumber`.\n *\n * ## Complexity, and the index question\n *\n * O(n log n): one partition pass, then a sort per partition. #1344's sorted\n * indexes could in principle make the sort a merge, but the input here is the\n * query's already-materialised, already-DECODED result rows — the index is\n * over stored (encoded) values on the collection, and it has no way to express\n * \"sorted within each partition of `clientId`\". Taking a fast path would mean\n * proving identical output including the upstream tie-break, which the index\n * cannot witness. So v1 sorts. This is the correct path, not a placeholder.\n *\n * ## Opting in — and why there is a second opt-in at all\n *\n * `withReduce()` alone does NOT light this up: `.window()` throws until the\n * strategy is built as `withReduce({ window: withWindow() })`. That is not\n * ceremony for its own sake — it is the SAME no-op-stub-until-opted-in rule\n * that keeps `Reduction`/`GroupedQuery` out of the floor bundle, applied one\n * level down. `withReduce()`'s returned object is a live value the bundler\n * cannot prove unused, so a `window()` method that named {@link WindowedQuery}\n * directly made this whole engine reachable from `withReduce` and charged it\n * to every consumer who opted into ordinary aggregation and will never call\n * `.window()`. Measured: the `analytics` bundle scenario went 960 → 1,845\n * gzipped bytes, +92%. Passing the factory in means the engine is reachable\n * only from a consumer that names `withWindow`.\n * ⛔ Do not \"simplify\" this back into `withReduce()` — `check-bundle.mjs`'s\n * `analytics` scenario carries a `WindowedQuery` eager-import canary that will\n * fail if you do.\n *\n * ## Not in `explain()`\n *\n * Same shape as #1336's post-group ops: `explain()` is a terminal on `Query`,\n * and `.window()` leaves `Query` for `WindowedQuery`, so there is no\n * `explain()` in the chain past this point to add a node to. The window stage\n * also has nothing to choose — one dispatch, over rows already in memory.\n */\n\nimport { readPath } from '../../kernel/query/predicate.js'\nimport { canonicalGroupKey } from './canonical-key.js'\nimport { compareReduced } from './groupby.js'\nimport type { Reducer } from './reducers.js'\nimport { bindDistinctReducers, sum, moneySum } from './reducers.js'\nimport type { ReductionUpstream, LiveReduction } from './reduction.js'\nimport { buildLiveReduction } from './reduction.js'\nimport type { DateTruncKey } from '../../kernel/query/reduce/date-trunc.js'\nimport { isDateTruncKey, projectDateTruncKeys } from '../../kernel/query/reduce/date-trunc.js'\nimport type { MoneyString } from '../../via/money/branded.js'\nimport type { ViaPipeline } from '../../kernel/via/pipeline.js'\n\n// ---------------------------------------------------------------------------\n// Spec surface\n// ---------------------------------------------------------------------------\n\n/** One ordering key inside a window: a field name, a `dateTrunc()` key, or either with a direction. */\nexport type WindowOrderInput<F extends string = string> =\n  | F\n  | DateTruncKey\n  | { readonly field: F | DateTruncKey; readonly direction?: 'asc' | 'desc' }\n\n/**\n * The window definition passed to `.window()`.\n *\n * Both members are optional and mean what SQL's omissions mean: no\n * `partitionBy` is one partition holding the whole relation; no `orderBy`\n * makes every row in a partition a peer (so `rank()` is 1 throughout and a\n * running aggregate sees the rows in upstream order).\n */\nexport interface WindowSpec<F extends string = string> {\n  /** Field name(s) and/or `dateTrunc()` key(s) to partition on. */\n  readonly partitionBy?: F | DateTruncKey | readonly (F | DateTruncKey)[]\n  /** How each partition is walked. Successive keys are tie-breakers. */\n  readonly orderBy?: WindowOrderInput<F> | readonly WindowOrderInput<F>[]\n}\n\n/**\n * A non-aggregating window function (ranking or navigation). Built by the\n * factories below — the shape is opaque to consumers.\n */\nexport interface WindowFn<R = unknown> {\n  readonly __window: true\n  readonly op: 'rowNumber' | 'rank' | 'lag' | 'lead'\n  /**\n   * Compute one value per row of an ORDERED partition.\n   * `peerStart[i]` is the index of the first row that compares equal to row\n   * `i` under the window's `orderBy` keys.\n   */\n  evaluate(rows: readonly unknown[], peerStart: readonly number[]): R[]\n}\n\n/**\n * A `.select()` slot: either a window function or an ordinary {@link Reducer},\n * which runs as a RUNNING aggregate under the v1 frame. Any reducer works —\n * `count()`, `sum()`, `countDistinct()`, a custom one — so `runningSum` and\n * `runningMoneySum` below are named conveniences, not a separate mechanism.\n */\nexport type WindowSelectSpec = Readonly<Record<string, WindowFn<unknown> | Reducer<unknown, unknown>>>\n\n/** Result type of one `.select()` slot. */\ntype WindowSlotResult<V> =\n  V extends WindowFn<infer R> ? R : V extends Reducer<infer R, unknown> ? R : unknown\n\n/** A window result row: the source record widened with the selected outputs. */\nexport type WindowRow<T, Spec extends WindowSelectSpec> = T & {\n  [K in keyof Spec]: WindowSlotResult<Spec[K]>\n}\n\nfunction isWindowFn(v: unknown): v is WindowFn<unknown> {\n  return typeof v === 'object' && v !== null && (v as { __window?: unknown }).__window === true\n}\n\n// ---------------------------------------------------------------------------\n// Window function factories\n// ---------------------------------------------------------------------------\n\n/**\n * Sequential position of the row within its partition, starting at 1. NEVER\n * repeats — two rows that tie under `orderBy` still get distinct numbers,\n * resolved by the upstream tie-break. Use {@link rank} when ties should share\n * a number.\n */\nexport function rowNumber(): WindowFn<number> {\n  return {\n    __window: true,\n    op: 'rowNumber',\n    evaluate: (rows) => rows.map((_, i) => i + 1),\n  }\n}\n\n/**\n * Competition rank within the partition, starting at 1. Rows that compare\n * EQUAL under the window's `orderBy` keys share a rank, and the next distinct\n * value SKIPS the ranks they consumed — `1, 2, 2, 4`. This is the only place\n * `rank` and {@link rowNumber} differ, so a fixture without ties cannot tell\n * them apart.\n *\n * With no `orderBy` every row is a peer and every rank is 1.\n */\nexport function rank(): WindowFn<number> {\n  return {\n    __window: true,\n    op: 'rank',\n    evaluate: (_rows, peerStart) => peerStart.map((start) => start + 1),\n  }\n}\n\nfunction assertOffset(op: 'lag' | 'lead', offset: number): void {\n  if (!Number.isInteger(offset) || offset < 0) {\n    throw new Error(`${op}(): offset must be a non-negative integer, got ${offset}.`)\n  }\n}\n\n/**\n * Value of `field` from the row `offset` positions EARLIER in the partition.\n * Returns `defaultValue` (default `undefined`) for the first `offset` rows.\n */\nexport function lag<R = unknown>(field: string, offset = 1, defaultValue?: R): WindowFn<R | undefined> {\n  assertOffset('lag', offset)\n  return {\n    __window: true,\n    op: 'lag',\n    evaluate: (rows) =>\n      rows.map((_, i) => (i - offset >= 0 ? (readPath(rows[i - offset], field) as R) : defaultValue)),\n  }\n}\n\n/**\n * Value of `field` from the row `offset` positions LATER in the partition.\n * Returns `defaultValue` (default `undefined`) for the last `offset` rows.\n */\nexport function lead<R = unknown>(field: string, offset = 1, defaultValue?: R): WindowFn<R | undefined> {\n  assertOffset('lead', offset)\n  return {\n    __window: true,\n    op: 'lead',\n    evaluate: (rows) =>\n      rows.map((_, i) => (i + offset < rows.length ? (readPath(rows[i + offset], field) as R) : defaultValue)),\n  }\n}\n\n/**\n * Running total of a numeric `field` over `rows unbounded preceding → current\n * row`. Identical to passing `sum(field)` — named for the reading.\n *\n * ⚠️ For a declared money field use {@link runningMoneySum}: it is the same\n * reducer, but typed `MoneyString` to match what the exact BigInt rewrite\n * actually returns.\n */\nexport function runningSum(field: string): Reducer<number> {\n  return sum(field)\n}\n\n/**\n * Running total of a **declared money field**, exact at any magnitude.\n *\n * The reducer is the ordinary money `sum`, and it is rewritten by\n * `ViaPipeline.wrapReducers` into `via/money/money-reducer.ts`'s BigInt\n * accumulator at `.select()` time — the SAME rewrite `.aggregate()` and\n * `.groupBy()` get, so a running balance and a grand total cannot disagree.\n * Nothing here touches a float: values accumulate as scaled `bigint`s and each\n * row's value is `formatScaledInt`'d out of the state at that point.\n */\nexport function runningMoneySum(field: string): Reducer<MoneyString> {\n  return moneySum(field)\n}\n\n// ---------------------------------------------------------------------------\n// Engine\n// ---------------------------------------------------------------------------\n\ninterface NormalizedOrder {\n  /** Output key to read (a derived key's `as`, or the plain field name). */\n  readonly key: string\n  readonly direction: 'asc' | 'desc'\n}\n\ninterface NormalizedWindow {\n  readonly partitionKeys: readonly string[]\n  readonly orderBy: readonly NormalizedOrder[]\n  readonly derived: readonly DateTruncKey[]\n}\n\nfunction asArray<V>(v: V | readonly V[] | undefined): readonly V[] {\n  if (v === undefined) return []\n  return Array.isArray(v) ? (v as readonly V[]) : [v as V]\n}\n\n/**\n * Resolve the spec into flat key lists plus the derived calendar keys that\n * must be projected before any of them can be read.\n *\n * NOT exported: `NormalizedWindow` is an implementation shape, and exporting\n * the function without it trips `check:types` (a subpath must be able to name\n * every type its own signatures mention).\n */\nfunction normalizeWindow(spec: WindowSpec): NormalizedWindow {\n  const derived: DateTruncKey[] = []\n  const keyOf = (k: string | DateTruncKey): string => {\n    if (!isDateTruncKey(k)) return k\n    derived.push(k)\n    return k.as\n  }\n  const partitionKeys = asArray<string | DateTruncKey>(spec.partitionBy).map(keyOf)\n  const orderBy = asArray<WindowOrderInput>(spec.orderBy).map((entry): NormalizedOrder => {\n    if (typeof entry === 'string' || isDateTruncKey(entry)) {\n      return { key: keyOf(entry), direction: 'asc' }\n    }\n    return { key: keyOf(entry.field), direction: entry.direction ?? 'asc' }\n  })\n  return { partitionKeys, orderBy, derived }\n}\n\n/**\n * Execute the window stage. Pure function over a row array — exported for\n * tests and for any future `scan().window()` reuse.\n *\n * Rows are returned in INPUT order, each a shallow copy widened with the\n * selected outputs. A `dateTrunc()` partition key is read off an internal\n * projection and is deliberately NOT stamped on the output row — unlike\n * `.groupBy()`, where the derived key IS the result key.\n */\nexport function applyWindow<R>(\n  records: readonly unknown[],\n  spec: WindowSpec,\n  select: WindowSelectSpec,\n): R[] {\n  const { partitionKeys, orderBy, derived } = normalizeWindow(spec)\n  const n = records.length\n  if (n === 0) return []\n\n  // Keys are read off a projected copy so a derived calendar bucket looks like\n  // an ordinary field; the OUTPUT is built from the untouched original.\n  const keyRows: readonly unknown[] =\n    derived.length === 0 ? records : projectDateTruncKeys(records, derived)\n\n  // Partition. Indices, not rows, so the upstream position survives as the\n  // final ordering key. Map preserves insertion order (irrelevant to output\n  // ordering here, but it keeps the walk deterministic).\n  const partitions = new Map<string, number[]>()\n  for (let i = 0; i < n; i++) {\n    let dedupKey = ''\n    if (partitionKeys.length > 0) {\n      const keyValues: Record<string, unknown> = {}\n      for (const f of partitionKeys) keyValues[f] = readPath(keyRows[i], f)\n      dedupKey = canonicalGroupKey(partitionKeys, keyValues)\n    }\n    const bucket = partitions.get(dedupKey)\n    if (bucket) bucket.push(i)\n    else partitions.set(dedupKey, [i])\n  }\n\n  // Compare two rows by the orderBy keys ONLY — peer-ship for `rank` is\n  // decided here, so the upstream tie-break must not participate.\n  const compareByKeys = (a: number, b: number): number => {\n    for (const { key, direction } of orderBy) {\n      const cmp = compareReduced(readPath(keyRows[a], key), readPath(keyRows[b], key))\n      if (cmp !== 0) return direction === 'asc' ? cmp : -cmp\n    }\n    return 0\n  }\n\n  const slots = Object.entries(select)\n  const out: Record<string, unknown>[] = records.map((r) => ({ ...(r as Record<string, unknown>) }))\n\n  for (const indices of partitions.values()) {\n    // Stable sort over an ascending index array ⇒ equal keys keep upstream\n    // order, which is what makes the ordering total.\n    indices.sort(compareByKeys)\n    const ordered = indices.map((i) => records[i])\n\n    // peerStart[k] = index of the first row of k's tie-group under `orderBy`.\n    const peerStart: number[] = new Array<number>(indices.length)\n    for (let k = 0; k < indices.length; k++) {\n      peerStart[k] = k === 0 || compareByKeys(indices[k - 1]!, indices[k]!) !== 0 ? k : peerStart[k - 1]!\n    }\n\n    for (const [name, slot] of slots) {\n      if (isWindowFn(slot)) {\n        const values = slot.evaluate(ordered, peerStart)\n        for (let k = 0; k < indices.length; k++) out[indices[k]!]![name] = values[k]\n        continue\n      }\n      // Running aggregate under the v1 frame: step, then finalize, per row.\n      let state = slot.init()\n      for (let k = 0; k < indices.length; k++) {\n        state = slot.step(state, ordered[k])\n        out[indices[k]!]![name] = slot.finalize(state)\n      }\n    }\n  }\n\n  return out as R[]\n}\n\n// ---------------------------------------------------------------------------\n// Chainable wrappers\n// ---------------------------------------------------------------------------\n\n/**\n * What `withWindow()` hands to `withReduce()`. Named as a type so\n * `strategy.ts` / `active.ts` can speak it in a TYPE-ONLY import and never\n * pull this module into their runtime graph.\n */\nexport type WindowFactory = <T>(\n  executeRecords: () => readonly unknown[],\n  spec: WindowSpec,\n  upstreams: readonly ReductionUpstream[],\n  via?: ViaPipeline,\n) => WindowedQuery<T>\n\n/**\n * Light up `.window()` on `Query`.\n *\n * ```ts\n * import { withReduce, withWindow } from '@noy-db/hub/reduce'\n * createNoydb({ store, user, secret, reduceStrategy: withReduce({ window: withWindow() }) })\n * ```\n *\n * The only reference to {@link WindowedQuery} outside this module's own\n * consumers — see \"Opting in\" in the module docs for why that matters.\n */\nexport function withWindow(): WindowFactory {\n  return <T>(\n    executeRecords: () => readonly unknown[],\n    spec: WindowSpec,\n    upstreams: readonly ReductionUpstream[],\n    via?: ViaPipeline,\n  ): WindowedQuery<T> => new WindowedQuery<T>(executeRecords, spec, upstreams, via)\n}\n\n/**\n * Chainable wrapper returned by `Query.window(spec)`. Terminates with\n * `.select(spec)`, which is the only operation on it — a window with nothing\n * selected computes nothing.\n */\nexport class WindowedQuery<T> {\n  constructor(\n    private readonly executeRecords: () => readonly unknown[],\n    private readonly spec: WindowSpec,\n    private readonly upstreams: readonly ReductionUpstream[],\n    private readonly via?: ViaPipeline,\n  ) {\n    // T is phantom on the wrapper so a consumer still sees the row type on\n    // hover. Reference it to keep lint quiet.\n    void undefined as T | undefined\n  }\n\n  /**\n   * Attach window outputs to every row. Each slot is either a\n   * {@link WindowFn} (`rowNumber`, `rank`, `lag`, `lead`) or a `Reducer`,\n   * which runs as a running aggregate over `rows unbounded preceding →\n   * current row`.\n   *\n   * Reducers are rewritten through the collection's Via pipeline exactly as\n   * `.aggregate()` rewrites them, so a `sum` over a declared money field\n   * becomes the exact BigInt accumulator and a `countDistinct` dedups on the\n   * canonical index key.\n   */\n  select<Spec extends WindowSelectSpec>(spec: Spec): WindowSelection<WindowRow<T, Spec>> {\n    const reducersOnly: Record<string, Reducer<unknown, unknown>> = {}\n    for (const [k, v] of Object.entries(spec)) {\n      if (!isWindowFn(v)) reducersOnly[k] = v\n    }\n    const wrapped = bindDistinctReducers(\n      this.via ? this.via.wrapReducers(reducersOnly) : reducersOnly,\n      this.via,\n    )\n    const effective: Record<string, WindowFn<unknown> | Reducer<unknown, unknown>> = { ...spec }\n    for (const [k, v] of Object.entries(wrapped)) effective[k] = v\n    return new WindowSelection<WindowRow<T, Spec>>(\n      this.executeRecords,\n      this.spec,\n      effective,\n      this.upstreams,\n    )\n  }\n}\n\n/**\n * The `.window(...).select(...)` terminal. Mirrors `GroupedReduction`'s shape\n * — `.run()` and `.live()` — minus the post-group stage: ordering and limiting\n * of window OUTPUT rows belong on the underlying `Query`, before `.window()`,\n * because a window never changes the row set.\n */\nexport class WindowSelection<R> {\n  constructor(\n    private readonly executeRecords: () => readonly unknown[],\n    private readonly spec: WindowSpec,\n    private readonly select: WindowSelectSpec,\n    private readonly upstreams: readonly ReductionUpstream[],\n  ) {}\n\n  /** Execute the query and return every row, widened with the window outputs. */\n  run(): R[] {\n    return applyWindow<R>(this.executeRecords(), this.spec, this.select)\n  }\n\n  /**\n   * Reactive terminal — re-runs the whole window pipeline on every upstream\n   * change, the same naive-recompute contract `GroupedReduction.live()` has.\n   * Always call `live.stop()` when finished.\n   */\n  live(): LiveReduction<R[]> {\n    return buildLiveReduction<R[]>(() => this.run(), this.upstreams)\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-MVMXZYXT.js → chunk-TKUOEU2F.js}

@@ -1,6 +1,6 @@
 import {
   linkI18nVia
-} from "./chunk-TRGTKX5E.js";
+} from "./chunk-GHLTDZRS.js";
 
 // src/via/i18n/dictionary.ts
 function dictKey(name, keysOrMap, opts) {
@@ -71,4 +71,4 @@ export {
   dictKey,
   staticDict
 };
-//# sourceMappingURL=chunk-MVMXZYXT.js.map
+//# sourceMappingURL=chunk-TKUOEU2F.js.map

package/dist/chunk-TOPYQ6GA.js

@@ -0,0 +1,31 @@
+import {
+  installLive
+} from "./chunk-FQ54DWUQ.js";
+import {
+  installReduce
+} from "./chunk-FXQBGFOX.js";
+import {
+  installRelate
+} from "./chunk-ZSX4S5XB.js";
+import {
+  ScanBuilder
+} from "./chunk-F24ZZTHQ.js";
+import {
+  Query,
+  executePlan
+} from "./chunk-7JE7BDYJ.js";
+
+// src/kernel/query/all.ts
+installRelate();
+installReduce();
+installLive();
+var Query2 = Query;
+var ScanBuilder2 = ScanBuilder;
+var executePlan2 = executePlan;
+
+export {
+  Query2 as Query,
+  ScanBuilder2 as ScanBuilder,
+  executePlan2 as executePlan
+};
+//# sourceMappingURL=chunk-TOPYQ6GA.js.map

package/dist/chunk-TOPYQ6GA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/query/all.ts"],"sourcesContent":["/**\n * `Query` with every group attached — the root barrel's view of the DSL (#1458).\n *\n * ⭐ **THE FILE EXISTS TO GET THE INSTALL'S LIFETIME RIGHT, and the two obvious\n * alternatives are both wrong in a way that was measured rather than argued:**\n *\n *   - **Installing from `src/index.ts`'s own body** makes the three groups\n *     unconditionally reachable from `createNoydb`. The `floor` scenario —\n *     `import { createNoydb }` and nothing else — went from 554 to 11,330\n *     gzipped bytes, because a consumer who never writes a query now carries\n *     the whole DSL. That is a 20× regression on the package's smallest\n *     documented consumer.\n *   - **Re-exporting the group barrels and relying on the bare import** lets a\n *     bundler drop the import as side-effect-free when the re-exported values\n *     are unused — so `collection.query().join()` throws\n *     `QueryExtensionMissingError` in a production build, for a consumer who\n *     never opted out of anything.\n *\n * This module resolves both: it EXPORTS `Query`, and it INSTALLS as a top-level\n * side effect. A bundler may drop the module when nothing uses its exports (the\n * floor consumer never names `Query`, so nothing is paid), and the moment\n * anything does use `Query`, the module is retained and the installs run with\n * it. The dependency the install needs — \"attached whenever Query is reachable\"\n * — is exactly the dependency an export creates.\n *\n * ⚠️ Do not add this file to `package.json`'s `sideEffects` array. Being\n * DROPPABLE is the mechanism; listing it would pin the whole DSL into every\n * bundle and restore the first failure above.\n */\nimport { installRelate } from './relate/install.js'\nimport { installReduce } from './reduce/install.js'\nimport { installLive } from './live/install.js'\n\ninstallRelate()\ninstallReduce()\ninstallLive()\n\n// ⛔ RE-BOUND, not re-exported, and the difference decides whether any of this\n// works. `export { Query } from './builder.js'` is a pure re-export, so\n// esbuild resolves the binding straight to `builder.js` and this module's\n// chunk is left imported for its side effect ALONE — which `sideEffects:\n// false` then licenses the consumer's bundler to drop. Measured: it did, with\n// the warning `Ignoring this import because \"dist/chunk-….js\" was marked as\n// having no side effects`, and the root-barrel scenario came back with no join\n// code at all. Binding through a `const` gives `dist/index.js` a real named\n// import from this chunk, so the chunk is retained exactly when `Query` is\n// used — and dropped, with the installs, when it is not.\nimport { Query as FindQuery, executePlan as findExecutePlan } from './builder.js'\nimport { ScanBuilder as FindScanBuilder } from './scan-builder.js'\n\nexport const Query = FindQuery\nexport const ScanBuilder = FindScanBuilder\nexport const executePlan = findExecutePlan\n\n// The value above is the class; these keep the TYPE spelling `Query<Invoice>`\n// working for a consumer importing from the root barrel, and they resolve to\n// the same declaration the group augmentations merge into.\nexport type Query<\n  T,\n  S extends keyof T = never,\n  Q extends keyof T & string = never,\n  M extends keyof T & string = never,\n> = FindQuery<T, S, Q, M>\nexport type ScanBuilder<T, S extends keyof T = never, M extends keyof T & string = never> =\n  FindScanBuilder<T, S, M>\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiCA,cAAc;AACd,cAAc;AACd,YAAY;AAeL,IAAMA,SAAQ;AACd,IAAMC,eAAc;AACpB,IAAMC,eAAc;","names":["Query","ScanBuilder","executePlan"]}

package/dist/{chunk-SMH6SRX7.js → chunk-TROR3ALR.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-5D2ALSM5.js";
 
 // src/with-formula/derivations/stale.ts
-var loadDerivationExecutor = lazy(() => import("./executor-5NIMLSKZ.js"));
+var loadDerivationExecutor = lazy(() => import("./executor-RBKM5W5K.js"));
 var _staleByRegistry = /* @__PURE__ */ new WeakMap();
 var keyFor = (source, sourceId) => `${source}/${sourceId}`;
 async function markStale(registry, strategy, sourceId) {
@@ -84,4 +84,4 @@ export {
   markStale,
   resolveStaleOnRead
 };
-//# sourceMappingURL=chunk-SMH6SRX7.js.map
+//# sourceMappingURL=chunk-TROR3ALR.js.map