@noy-db/hub 0.4.0-pre.5 → 0.4.0-pre.6

package/dist/with-lookup/{aggregate → reduce}/groupby.d.ts

@@ -58,7 +58,7 @@
  * groupBy doesn't need its own seam for the moment, because it
  * delegates to the reducer protocol for all per-bucket state.
  */
-import type { AggregateSpec, AggregateResult, AggregationUpstream, LiveAggregation } from './aggregation.js';
+import type { ReduceSpec, ReduceResult, ReductionUpstream, LiveReduction } from './reduction.js';
 import type { ReducerBuilder } from './reducers.js';
 import type { MoneyDescriptor } from '../../via/money/descriptor.js';
 import type { ViaPipeline } from '../../kernel/via/pipeline.js';
@@ -78,7 +78,7 @@ export declare const GROUPBY_MAX_CARDINALITY = 100000;
  */
 export declare function resetGroupByWarnings(): void;
 /**
- * Result row shape for a grouped aggregation. Each row carries the
+ * Result row shape for a grouped reduction. Each row carries the
  * group key value under the grouping field name plus every reducer
  * output from the spec.
  *
@@ -116,7 +116,7 @@ export type GroupedRowN<F extends readonly string[], R> = {
  */
 declare abstract class GroupedQueryBase {
     protected readonly executeRecords: () => readonly unknown[];
-    protected readonly upstreams: readonly AggregationUpstream[];
+    protected readonly upstreams: readonly ReductionUpstream[];
     /**
      * Optional dict label resolver attached by the query builder when
      * the grouping field is a dictKey. Variadic groupings always pass
@@ -137,7 +137,7 @@ declare abstract class GroupedQueryBase {
      * `[field]`.
      */
     protected readonly fields: readonly string[];
-    constructor(executeRecords: () => readonly unknown[], fieldOrFields: string | readonly string[], upstreams: readonly AggregationUpstream[], 
+    constructor(executeRecords: () => readonly unknown[], fieldOrFields: string | readonly string[], upstreams: readonly ReductionUpstream[], 
     /**
      * Optional dict label resolver attached by the query builder when
      * the grouping field is a dictKey. Variadic groupings always pass
@@ -152,21 +152,21 @@ declare abstract class GroupedQueryBase {
      */
     via?: ViaPipeline | undefined);
     /** Apply Via-aware reducer rewriting (e.g. money) when the source declares one. */
-    protected wrapSpec<Spec extends AggregateSpec>(spec: Spec): Spec;
+    protected wrapSpec<Spec extends ReduceSpec>(spec: Spec): Spec;
 }
 /**
  * Chainable wrapper returned by `Query.groupBy(field)`. Terminates
- * with `.aggregate(spec)` which returns a `GroupedAggregation`.
+ * with `.aggregate(spec)` which returns a `GroupedReduction`.
  *
  * Kept minimal — the only operation on a grouped query is
- * aggregation. Ordering, limiting, and further filtering belong on
+ * reduction. Ordering, limiting, and further filtering belong on
  * the underlying `Query` before `.groupBy()` is called; applying
  * them post-group would be a different operation (`having` /
  * `groupOrderBy`), out of scope for.
  */
 export declare class GroupedQuery<T, F extends string, S extends keyof T = never, M extends keyof T & string = never> extends GroupedQueryBase {
     /**
-     * Build a grouped aggregation. Returns a `GroupedAggregation`
+     * Build a grouped reduction. Returns a `GroupedReduction`
      * with `.run()`, `.runAsync()`, and `.live()` terminals — same shape
      * as the non-grouped `.aggregate()` wrapper, just with an array
      * result (one row per bucket) instead of a single reduced object.
@@ -178,8 +178,8 @@ export declare class GroupedQuery<T, F extends string, S extends keyof T = never
      * declared `moneyFields` (`M`) member return a `MoneyString`. The
      * bare-spec overload is preserved for backward compatibility.
      */
-    aggregate<Spec extends AggregateSpec>(spec: Spec): GroupedAggregation<GroupedRow<F, AggregateResult<Spec>>>;
-    aggregate<Spec extends AggregateSpec>(build: (b: ReducerBuilder<T, S, M>) => Spec): GroupedAggregation<GroupedRow<F, AggregateResult<Spec>>>;
+    aggregate<Spec extends ReduceSpec>(spec: Spec): GroupedReduction<GroupedRow<F, ReduceResult<Spec>>>;
+    aggregate<Spec extends ReduceSpec>(build: (b: ReducerBuilder<T, S, M>) => Spec): GroupedReduction<GroupedRow<F, ReduceResult<Spec>>>;
 }
 /**
  * Variadic-keyed sibling of `GroupedQuery<T, F>`. Constructed by the
@@ -187,12 +187,12 @@ export declare class GroupedQuery<T, F extends string, S extends keyof T = never
  * identical — only the type-level result-row narrowing differs.
  */
 export declare class GroupedQueryN<T, F extends readonly string[], S extends keyof T = never, M extends keyof T & string = never> extends GroupedQueryBase {
-    aggregate<Spec extends AggregateSpec>(spec: Spec): GroupedAggregation<GroupedRowN<F, AggregateResult<Spec>>>;
-    aggregate<Spec extends AggregateSpec>(build: (b: ReducerBuilder<T, S, M>) => Spec): GroupedAggregation<GroupedRowN<F, AggregateResult<Spec>>>;
+    aggregate<Spec extends ReduceSpec>(spec: Spec): GroupedReduction<GroupedRowN<F, ReduceResult<Spec>>>;
+    aggregate<Spec extends ReduceSpec>(build: (b: ReducerBuilder<T, S, M>) => Spec): GroupedReduction<GroupedRowN<F, ReduceResult<Spec>>>;
 }
 /**
  * Execute the group-and-reduce pipeline. Pure function over a
- * record array and a spec — shared by `GroupedAggregation.run()`
+ * record array and a spec — shared by `GroupedReduction.run()`
  * and the live-mode refresh path. Exported for tests and for any
  * future `scan().groupBy().aggregate()` reuse.
  *
@@ -201,10 +201,10 @@ export declare class GroupedQueryN<T, F extends readonly string[], S extends key
  * bucket would be created — the consumer doesn't have to wait for
  * the full partition to materialize before the error fires.
  */
-export declare function groupAndReduce<R>(records: readonly unknown[], fieldOrFields: string | readonly string[], spec: AggregateSpec, moneyFields?: Record<string, MoneyDescriptor>): R[];
+export declare function groupAndReduce<R>(records: readonly unknown[], fieldOrFields: string | readonly string[], spec: ReduceSpec, moneyFields?: Record<string, MoneyDescriptor>): R[];
 /**
- * Grouped aggregation wrapper — the `.groupBy(field).aggregate(spec)`
- * terminal. Shape mirrors `Aggregation<R>` from aggregate.ts: two
+ * Grouped reduction wrapper — the `.groupBy(field).aggregate(spec)`
+ * terminal. Shape mirrors `Reduction<R>` from aggregate.ts: two
  * terminals (`.run()` and `.live()`), spec bound at construction
  * time, upstreams collected for live mode.
  *
@@ -212,7 +212,7 @@ export declare function groupAndReduce<R>(records: readonly unknown[], fieldOrFi
  * grouped row), and the terminals return `R[]` — one row per
  * bucket.
  */
-export declare class GroupedAggregation<R> {
+export declare class GroupedReduction<R> {
     private readonly executeRecords;
     private readonly spec;
     private readonly upstreams;
@@ -222,7 +222,7 @@ export declare class GroupedAggregation<R> {
      */
     private readonly dictLabelResolver?;
     private readonly fields;
-    constructor(executeRecords: () => readonly unknown[], fields: string | readonly string[], spec: AggregateSpec, upstreams: readonly AggregationUpstream[], 
+    constructor(executeRecords: () => readonly unknown[], fields: string | readonly string[], spec: ReduceSpec, upstreams: readonly ReductionUpstream[], 
     /**
      * Optional dict label resolver for `<field>Label` projection
      *. Present when the grouping field is a dictKey.
@@ -260,10 +260,10 @@ export declare class GroupedAggregation<R> {
         fallback?: string | readonly string[];
     }): Promise<R[]>;
     /**
-     * Build a reactive `LiveAggregation<R[]>` that re-runs the full
+     * Build a reactive `LiveReduction<R[]>` that re-runs the full
      * group-and-reduce pipeline whenever any upstream source notifies
      * of a change. Same error-isolation and idempotent-stop contract
-     * as `Aggregation.live()` — the implementation delegates to the
+     * as `Reduction.live()` — the implementation delegates to the
      * same `LiveAggregationImpl` class by threading a fresh
      * recompute closure through the existing constructor.
      *
@@ -275,6 +275,6 @@ export declare class GroupedAggregation<R> {
      *
      * Always call `live.stop()` when finished.
      */
-    live(): LiveAggregation<R[]>;
+    live(): LiveReduction<R[]>;
 }
 export {};

package/dist/with-lookup/reduce/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @noy-db/hub/reduce — opt-in reduction + groupBy service.
+ *
+ * @category capability
+ *
+ * Groups every file whose reason-for-existing is record reduction:
+ *   - `reduction` (`Reduction<R>`, `reduceRecords`, `buildLiveReduction`)
+ *   - `groupby` (`GroupedQuery`, `GroupedReduction`, cardinality guards)
+ *   - `reducers` (`count`, `sum`, `avg`, `min`, `max` factories)
+ *
+ * The root barrel (`@noy-db/hub`) and the `@noy-db/hub/query` subpath
+ * continue to re-export the same symbols for backward compatibility
+ * with consumers written before the relocation. New code should
+ * prefer this subpath.
+ */
+export { withReduce } from './active.js';
+export type { ReduceStrategy } from './strategy.js';
+export { Reduction, reduceRecords, buildLiveReduction } from './reduction.js';
+export type { ReduceSpec, ReduceResult, ReductionUpstream, LiveReduction, } from './reduction.js';
+export { GroupedQuery, GroupedQueryN, GroupedReduction, groupAndReduce, resetGroupByWarnings, GROUPBY_WARN_CARDINALITY, GROUPBY_MAX_CARDINALITY, } from './groupby.js';
+export type { GroupedRow, GroupedRowN } from './groupby.js';
+export { count, sum, avg, min, max, moneySum, moneyMin, moneyMax, reducerBuilder } from './reducers.js';
+export type { Reducer, ReducerOptions, ReducerBuilder } from './reducers.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_REDUCE } from './strategy.js';
+/**
+ * Types named by this entry's own signatures (#843a). `min`/`max` return a
+ * `MinMaxState`, and the money reducers speak `MoneyString`; both must be
+ * nameable from the entry that exports the functions, or a caller can invoke
+ * them and cannot annotate the result.
+ */
+export type { MinMaxState } from './reducers.js';
+export type { MoneyString } from '../../via/money/branded.js';
+export type { MoneyDescriptor } from '../../via/money/descriptor.js';

package/dist/with-lookup/{aggregate → reduce}/reducers.d.ts

@@ -1,12 +1,12 @@
 /**
- * Aggregation reducers for the query DSL.
+ * Reduction reducers for the query DSL.
  *
  * the reducer protocol plus five built-in factories
  * (`count`, `sum`, `avg`, `min`, `max`) consumed by `Query.aggregate()`
  * and, in the future, `Scan.aggregate()`. Every factory accepts
  * an optional `{ seed }` parameter that is plumbed through the
  * protocol but unused by the executor — that's the load-bearing
- * half of  constraint #2. When partition-aware aggregation
+ * half of  constraint #2. When partition-aware reduction
  * lands, the seed carries the previous partition's running total into
  * the next partition without requiring a protocol change.
  *
@@ -19,7 +19,7 @@
  * Reducers are pure data — `init` / `step` / `finalize` / optional
  * `remove` are stateless functions that receive and return `S`. This
  * is the shape that admits O(1) incremental maintenance in a future
- * optimization (delta-aware `LiveAggregation` applies `step` or
+ * optimization (delta-aware `LiveReduction` applies `step` or
  * `remove` per delta), without blocking the simpler "full re-run on
  * source change" that ships.
  */
@@ -30,19 +30,19 @@ import type { QueryField } from '../../kernel/types.js';
  * `.aggregate()` spec.
  *
  * Type parameters:
- *   - `R` — user-visible result type (what the aggregation returns
+ *   - `R` — user-visible result type (what the reduction returns
  *     for this slot, e.g. `number` for `sum()`)
  *   - `S` — internal state type, defaults to `R` for simple reducers
  *     that don't need compound bookkeeping
  *
  * A reducer is stateless: every method is pure over `S`. `init()` is
- * called once per aggregation run to build the initial state; `step()`
+ * called once per reduction run to build the initial state; `step()`
  * folds a record into the state; `remove()` (optional) un-folds a
  * record, enabling incremental live maintenance; `finalize()` reads
  * the final answer out of the state at the end of the run.
  */
 export interface Reducer<R, S = R> {
-    /** Build the initial state for a fresh aggregation run. */
+    /** Build the initial state for a fresh reduction run. */
     init(): S;
     /** Fold a record into the state. Returns the new state. */
     step(state: S, record: unknown): S;
@@ -63,7 +63,7 @@ export interface Reducer<R, S = R> {
      * Combine two independent partial states into one (then `finalize` once).
      * Optional. MUST be associative + commutative with `init()` as identity.
      * Never merge finalized results — only states. Enables parallel /
-     * hierarchical aggregation (e.g. cross-shard or advisor→firm rollup).
+     * hierarchical reduction (e.g. cross-shard or advisor→firm rollup).
      */
     merge?(a: S, b: S): S;
     /**
@@ -94,10 +94,10 @@ export interface Reducer<R, S = R> {
  *
  * `seed` — optional initial value for the internal state. **Unused by
  * the executor**, plumbed through the protocol for  constraint
- * #2 (partition-aware aggregation seam). In, partitioned
- * aggregations will pass the previous partition's carry as `seed` so
+ * #2 (partition-aware reduction seam). In, partitioned
+ * reductions will pass the previous partition's carry as `seed` so
  * a long time series can be rolled forward one partition at a time
- * without re-aggregating closed partitions.
+ * without re-reducing closed partitions.
  *
  * always uses `init()` with the factory's zero value, regardless
  * of whether `seed` was passed. Do not remove the parameter — that's

package/dist/with-lookup/{aggregate/aggregation.d.ts → reduce/reduction.d.ts}

@@ -1,13 +1,13 @@
 /**
  * Aggregate execution — the runtime behind `Query.aggregate()`.
  *
- * takes an `AggregateSpec` (a record of named reducers
+ * takes an `ReduceSpec` (a record of named reducers
  * built from `reducers.ts`) and runs every reducer over the records
  * produced by the underlying query. Two terminal surfaces:
  *
  *   - `.run(): R` — synchronous one-shot reduction. Matches the
  *     existing `Query.toArray()` / `.first()` / `.count()` style.
- *   - `.live(): LiveAggregation<R>` — reactive primitive that
+ *   - `.live(): LiveReduction<R>` — reactive primitive that
  *     re-runs the reduction whenever the query's source notifies of
  *     a change. uses naive full re-run; incremental delta
  *     maintenance is admitted by the reducer protocol (`remove()`)
@@ -15,7 +15,7 @@
  *     can switch from full re-run to delta-based without breaking
  *     the public API. Consumers get correct, reactive values today.
  *
- * The `Aggregation<R>` wrapper is deliberately tiny — it exists so
+ * The `Reduction<R>` wrapper is deliberately tiny — it exists so
  * `.aggregate(spec)` can be chained with either `.run()` or `.live()`
  * without the builder needing two separate terminal methods. It
  * holds the closure over the query execution (produces the current
@@ -39,9 +39,9 @@ import type { Reducer } from './reducers.js';
  * }
  * ```
  */
-export type AggregateSpec = Readonly<Record<string, Reducer<unknown, unknown>>>;
+export type ReduceSpec = Readonly<Record<string, Reducer<unknown, unknown>>>;
 /**
- * Map an `AggregateSpec` to its reduced result shape — each key
+ * Map an `ReduceSpec` to its reduced result shape — each key
  * carries the finalized result type from its reducer. A spec built
  * from `{ total: sum('amount'), n: count() }` yields a result of
  * `{ total: number, n: number }`.
@@ -50,26 +50,26 @@ export type AggregateSpec = Readonly<Record<string, Reducer<unknown, unknown>>>;
  * each `Reducer<R, _>`. The `infer` captures the user-visible result
  * type, discarding the internal state type `S`.
  */
-export type AggregateResult<Spec extends AggregateSpec> = {
+export type ReduceResult<Spec extends ReduceSpec> = {
     [K in keyof Spec]: Spec[K] extends Reducer<infer R, unknown> ? R : never;
 };
 /**
  * Pure reduction over a record array. Runs every reducer's
  * `init → step* → finalize` pipeline exactly once over the records.
  *
- * Called by `Aggregation.run()` and by the live-mode refresh path.
+ * Called by `Reduction.run()` and by the live-mode refresh path.
  * Exported for tests and for future `scan().aggregate()` reuse
  * — the streaming path will call the same reducer protocol with a
  * per-page loop instead of a single array.
  */
-export declare function reduceRecords<Spec extends AggregateSpec>(records: readonly unknown[], spec: Spec): AggregateResult<Spec>;
+export declare function reduceRecords<Spec extends ReduceSpec>(records: readonly unknown[], spec: Spec): ReduceResult<Spec>;
 /**
- * A minimal reactive primitive for aggregation results.
+ * A minimal reactive primitive for reduction results.
  *
  * Same spirit as the `LiveQuery` in : frame-agnostic, a plain
  * object with `value` / `error` fields and a `subscribe(cb)`
  * notification channel that Vue / React / Solid adapters wrap in
- * their own primitive. Intentionally NOT a Promise — aggregations
+ * their own primitive. Intentionally NOT a Promise — reductions
  * have a well-defined "current value" at every instant, and the
  * reactive consumer wants to read that value synchronously.
  *
@@ -86,7 +86,7 @@ export declare function reduceRecords<Spec extends AggregateSpec>(records: reado
  * Always call `stop()` when done; Vue's `onUnmounted` is the
  * canonical place. Raw consumers must do it themselves.
  */
-export interface LiveAggregation<R> {
+export interface LiveReduction<R> {
     /** Current reduced value. Undefined only if the first compute threw. */
     readonly value: R | undefined;
     /** Last execution error, if any. Cleared on the next successful run. */
@@ -97,14 +97,14 @@ export interface LiveAggregation<R> {
     stop(): void;
 }
 /**
- * Upstream change-notification hook for live aggregation.
+ * Upstream change-notification hook for live reduction.
  *
  * Matches the shape that `QuerySource.subscribe` already uses — a
  * single method that accepts a callback and returns an unsubscribe
- * function. The `Aggregation` wrapper collects upstreams from the
+ * function. The `Reduction` wrapper collects upstreams from the
  * query's source and wires them into a single re-run trigger.
  */
-export interface AggregationUpstream {
+export interface ReductionUpstream {
     subscribe(cb: () => void): () => void;
 }
 /**
@@ -120,14 +120,14 @@ export interface AggregationUpstream {
  * `.aggregate(spec).live()`. Wrapping lets the spec be named once
  * and reused for either terminal, and keeps the `Query` class
  * from growing a pair of near-duplicate method overloads
- * (`aggregateRun` / `aggregateLive`) that would be harder to
+ * (`reduceRun` / `reduceLive`) that would be harder to
  * discover.
  */
-export declare class Aggregation<R> {
+export declare class Reduction<R> {
     private readonly executeRecords;
     private readonly spec;
     private readonly upstreams;
-    constructor(executeRecords: () => readonly unknown[], spec: AggregateSpec, upstreams: readonly AggregationUpstream[]);
+    constructor(executeRecords: () => readonly unknown[], spec: ReduceSpec, upstreams: readonly ReductionUpstream[]);
     /**
      * Execute the query and reduce the results synchronously.
      * Returns the reduced shape matching the spec — e.g. a spec of
@@ -136,7 +136,7 @@ export declare class Aggregation<R> {
      */
     run(): R;
     /**
-     * Build a reactive `LiveAggregation<R>` that re-runs the reduction
+     * Build a reactive `LiveReduction<R>` that re-runs the reduction
      * whenever any upstream source notifies of a change. The initial
      * value is computed eagerly in the constructor, so consumers can
      * read `live.value` immediately after calling `.live()`.
@@ -153,14 +153,14 @@ export declare class Aggregation<R> {
      * correct, reactive values today; future PRs can switch to
      * delta-based maintenance without changing this API.
      */
-    live(): LiveAggregation<R>;
+    live(): LiveReduction<R>;
 }
 /**
- * Build a `LiveAggregation<V>` from a recompute closure and a list
+ * Build a `LiveReduction<V>` from a recompute closure and a list
  * of upstreams. Exposed so sibling files in the query DSL
  * (currently `groupby.ts`) can reuse the reactive primitive
  * without reaching into `LiveAggregationImpl` directly. This keeps
  * the implementation class private while still allowing planned
  * composition with `.groupBy().aggregate().live()`.
  */
-export declare function buildLiveAggregation<V>(recompute: () => V, upstreams: readonly AggregationUpstream[]): LiveAggregation<V>;
+export declare function buildLiveReduction<V>(recompute: () => V, upstreams: readonly ReductionUpstream[]): LiveReduction<V>;

package/dist/with-lookup/{aggregate → reduce}/strategy.d.ts

@@ -1,18 +1,18 @@
 /**
  * Strategy seam between the core Query / ScanBuilder chain and the
  * optional aggregate / groupBy service. Core imports
- * `AggregateStrategy` as a TYPE-ONLY symbol and `NO_AGGREGATE` as a
+ * `ReduceStrategy` as a TYPE-ONLY symbol and `NO_REDUCE` as a
  * tiny runtime stub.
  *
- * The heavy machinery — `Aggregation`, `GroupedQuery`, the
- * reducer-step logic — is only reachable from `withAggregate()` in
+ * The heavy machinery — `Reduction`, `GroupedQuery`, the
+ * reducer-step logic — is only reachable from `withReduce()` in
  * `./active.ts`, which is only exported through the
- * `@noy-db/hub/aggregate` subpath. Consumers that don't import the
+ * `@noy-db/hub/reduce` subpath. Consumers that don't import the
  * subpath ship none of the ~886 LOC.
  *
  * @internal
  */
-import type { Aggregation, AggregateSpec, AggregateResult, AggregationUpstream } from './aggregation.js';
+import type { Reduction, ReduceSpec, ReduceResult, ReductionUpstream } from './reduction.js';
 import type { GroupedQuery, GroupedQueryN } from './groupby.js';
 import type { ViaPipeline } from '../../kernel/via/pipeline.js';
 /**
@@ -21,39 +21,39 @@ import type { ViaPipeline } from '../../kernel/via/pipeline.js';
  *
  * @internal
  */
-export interface AggregateStrategy {
+export interface ReduceStrategy {
     /**
-     * Build an `Aggregation<R>` for `Query.aggregate(spec)`. `executeRecords`
+     * Build an `Reduction<R>` for `Query.aggregate(spec)`. `executeRecords`
      * is a closure that produces the matching record set when the
-     * aggregation runs. NO_AGGREGATE throws; the active strategy
-     * constructs a real `Aggregation`.
+     * reduction runs. NO_REDUCE throws; the active strategy
+     * constructs a real `Reduction`.
      */
-    aggregate<Spec extends AggregateSpec>(executeRecords: () => readonly unknown[], spec: Spec, upstreams: readonly AggregationUpstream[]): Aggregation<AggregateResult<Spec>>;
+    aggregate<Spec extends ReduceSpec>(executeRecords: () => readonly unknown[], spec: Spec, upstreams: readonly ReductionUpstream[]): Reduction<ReduceResult<Spec>>;
     /**
      * Build a `GroupedQuery<T, F, S>` for `Query.groupBy(field)`. Same
      * closure / upstream inputs as `aggregate` plus the group key field.
      */
-    groupBy<T, F extends string, S extends keyof T = never, M extends keyof T & string = never>(executeRecords: () => readonly unknown[], field: F, upstreams: readonly AggregationUpstream[], dictLabelResolver?: (key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>, via?: ViaPipeline): GroupedQuery<T, F, S, M>;
+    groupBy<T, F extends string, S extends keyof T = never, M extends keyof T & string = never>(executeRecords: () => readonly unknown[], field: F, upstreams: readonly ReductionUpstream[], dictLabelResolver?: (key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>, via?: ViaPipeline): GroupedQuery<T, F, S, M>;
     /**
      * Variadic-keyed sibling — builds a `GroupedQueryN<T, F, S>` for
      * `Query.groupBy(...fields)`. No dictLabelResolver — `<field>Label`
      * projection only applies to single-field groupings, which dispatch
      * through `groupBy` above.
      */
-    groupByN<T, F extends readonly string[], S extends keyof T = never, M extends keyof T & string = never>(executeRecords: () => readonly unknown[], fields: F, upstreams: readonly AggregationUpstream[], via?: ViaPipeline): GroupedQueryN<T, F, S, M>;
+    groupByN<T, F extends readonly string[], S extends keyof T = never, M extends keyof T & string = never>(executeRecords: () => readonly unknown[], fields: F, upstreams: readonly ReductionUpstream[], via?: ViaPipeline): GroupedQueryN<T, F, S, M>;
     /**
      * Terminal streaming aggregator for `ScanBuilder.aggregate(spec)`.
      * Takes an async iterable of decrypted records + the spec and
      * returns the reduced result.
      */
-    scanAggregate<Spec extends AggregateSpec>(iter: AsyncIterable<unknown>, spec: Spec): Promise<AggregateResult<Spec>>;
+    scanAggregate<Spec extends ReduceSpec>(iter: AsyncIterable<unknown>, spec: Spec): Promise<ReduceResult<Spec>>;
 }
 /**
  * No-aggregate stub. Every `.aggregate()` / `.groupBy()` / streaming
  * `scan().aggregate()` call throws with a pointer at the subpath. The
- * real `Aggregation` / `GroupedQuery` classes are never referenced at
+ * real `Reduction` / `GroupedQuery` classes are never referenced at
  * runtime, so the bundler drops the ~886 LOC.
  *
  * @internal
  */
-export declare const NO_AGGREGATE: AggregateStrategy;
+export declare const NO_REDUCE: ReduceStrategy;

package/dist/with-party/session/index.d.ts

@@ -21,3 +21,5 @@ export type { DevUnlockOptions } from './dev-unlock.js';
 export { withSession } from './active.js';
 export type { SessionStrategy } from './strategy.js';
 export { SessionExpiredError, SessionNotFoundError, SessionPolicyError, } from '../../kernel/errors.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_SESSION } from './strategy.js';

package/dist/with-party/sync/index.d.ts

@@ -29,3 +29,5 @@
  */
 export { withSync } from '../team/sync-active.js';
 export type { SyncStrategy } from '../team/sync-strategy.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_SYNC } from '../team/sync-strategy.js';

package/dist/with-party/team/keyring.d.ts

@@ -132,7 +132,26 @@ export declare function updateKeyringIdentity(adapter: NoydbStore, vault: string
  * 2. Re-encrypt all records in affected collections
  * 3. Re-wrap new DEKs for all remaining users
  */
-export declare function rotateKeys(adapter: NoydbStore, vault: string, callerKeyring: UnlockedKeyring, collections: string[]): Promise<void>;
+/**
+ * What a DEK rotation leaves behind (#854).
+ *
+ * A member's DEKs are wrapped under that member's KEK, and a KEK derives only
+ * from that member's secret — so the caller cannot re-wrap a fresh DEK for
+ * anyone else. That is the zero-knowledge property working as designed, but it
+ * means rotation necessarily DROPS the rotated collections from every other
+ * member's keyring rather than re-keying them.
+ *
+ * `needsRegrant` names exactly who lost what, so the caller can re-run
+ * `grant()` instead of discovering the access loss later.
+ */
+export interface RotateResult {
+    /** (member, collection) pairs whose access was dropped by the rotation. */
+    readonly needsRegrant: ReadonlyArray<{
+        readonly userId: string;
+        readonly collection: string;
+    }>;
+}
+export declare function rotateKeys(adapter: NoydbStore, vault: string, callerKeyring: UnlockedKeyring, collections: string[]): Promise<RotateResult>;
 /**
  * Change the user's secret. Re-wraps every DEK under the new KEK.
  *

package/dist/with-party/team/noydb-facade.d.ts

@@ -19,6 +19,7 @@
  * Internal service — reached through `noydb.team.rotateSecret(...)` etc.
  */
 import type { NoydbOptions, NoydbStore, KeyringAuthenticator } from '../../kernel/types.js';
+import type { RotateResult } from './keyring.js';
 import { type RotateSecretInput, type RecoverSecretInput, type RecoverSecretResult, type RotateRecoveryOptions, type RotateRecoveryResult, type EnrollRecoveryResult, type RecoveryEnrollmentInput, type RecoveryProof } from './rotate-recover.js';
 import { type RecoverUserOptions } from './peer-recover.js';
 import { type PaperRecoveryEntry, type ShamirRecoveryEntry } from './recovery.js';
@@ -72,7 +73,7 @@ export declare class TeamFacade {
     /** Gate + run a `revoke` engine. See `Noydb.revoke` for the public contract. */
     runRevoke(engine: (adapter: NoydbStore, vault: string, callerKeyring: UnlockedKeyring, options: RevokeOptions) => Promise<void>, vault: string, options: RevokeOptions, factors?: FactorProofBundle): Promise<void>;
     /** Gate + run a `rotateKeys` engine. See `Noydb.rotate` for the public contract. */
-    runRotate(engine: (adapter: NoydbStore, vault: string, callerKeyring: UnlockedKeyring, collections: string[]) => Promise<void>, vault: string, collections: string[]): Promise<void>;
+    runRotate(engine: (adapter: NoydbStore, vault: string, callerKeyring: UnlockedKeyring, collections: string[]) => Promise<RotateResult>, vault: string, collections: string[]): Promise<RotateResult>;
     /**
      * Add a tier-2 authenticator slot to the calling user's keyring.
      * Each slot independently wraps the SAME KEK under a method-specific

package/dist/{withdraw-accessible-Q2EMATCU.js → withdraw-accessible-GO6KQJVM.js}

@@ -4,18 +4,18 @@ import {
   freezeSnapshotOnly,
   randomId,
   withdrawAccessibleData
-} from "./chunk-K4BWPNJO.js";
-import "./chunk-OMSKGLYA.js";
-import "./chunk-YCAJDK4O.js";
-import "./chunk-YFFEF6HR.js";
-import "./chunk-GEEJPID6.js";
-import "./chunk-SC4JLMZI.js";
+} from "./chunk-MLCTPWSO.js";
+import "./chunk-WWBC4KLB.js";
+import "./chunk-E7FSBI6I.js";
+import "./chunk-ZHZ4PET5.js";
+import "./chunk-MMVQ3SUO.js";
+import "./chunk-KCZAFDP5.js";
 import "./chunk-5WLDZZ6S.js";
 import "./chunk-5HSSTOOG.js";
 import "./chunk-G4MFQXYX.js";
 import "./chunk-LP7BEXCT.js";
 import "./chunk-7U6AB7DZ.js";
-import "./chunk-YTW6ZIPD.js";
+import "./chunk-DOZFU7OZ.js";
 import "./chunk-6SYOHUHM.js";
 import "./chunk-PZ5AY32C.js";
 export {
@@ -25,4 +25,4 @@ export {
   randomId,
   withdrawAccessibleData
 };
-//# sourceMappingURL=withdraw-accessible-Q2EMATCU.js.map
+//# sourceMappingURL=withdraw-accessible-GO6KQJVM.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noy-db/hub",
-  "version": "0.4.0-pre.5",
+  "version": "0.4.0-pre.6",
   "description": "Zero-knowledge, offline-first, encrypted document store — core library with AES-256-GCM, PBKDF2, multi-user keyring, and sync engine",
   "license": "MIT",
   "author": "vLannaAi <vicio@lanna.ai>",
@@ -64,10 +64,6 @@
       "types": "./dist/with-store/lazy/index.d.ts",
       "default": "./dist/lazy/index.js"
     },
-    "./aggregate": {
-      "types": "./dist/with-lookup/aggregate/index.d.ts",
-      "default": "./dist/aggregate/index.js"
-    },
     "./crdt": {
       "types": "./dist/with-commit/crdt/index.d.ts",
       "default": "./dist/crdt/index.js"
@@ -152,33 +148,9 @@
       "types": "./dist/port/to/index.d.ts",
       "default": "./dist/to/index.js"
     },
-    "./with": {
-      "types": "./dist/port/with/index.d.ts",
-      "default": "./dist/with/index.js"
-    },
-    "./ui": {
-      "types": "./dist/port/ui/index.d.ts",
-      "default": "./dist/ui/index.js"
-    },
-    "./by": {
-      "types": "./dist/port/by/index.d.ts",
-      "default": "./dist/by/index.js"
-    },
-    "./on": {
-      "types": "./dist/port/on/index.d.ts",
-      "default": "./dist/on/index.js"
-    },
-    "./at": {
-      "types": "./dist/port/at/index.d.ts",
-      "default": "./dist/at/index.js"
-    },
-    "./in": {
-      "types": "./dist/port/in/index.d.ts",
-      "default": "./dist/in/index.js"
-    },
-    "./as": {
-      "types": "./dist/port/as/index.d.ts",
-      "default": "./dist/as/index.js"
+    "./reduce": {
+      "types": "./dist/with-lookup/reduce/index.d.ts",
+      "default": "./dist/reduce/index.js"
     }
   },
   "module": "./dist/index.js",
@@ -192,14 +164,14 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@noy-db/attestation": "0.4.0-pre.5"
+    "@noy-db/attestation": "0.4.0-pre.6"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "esbuild": "^0.25.0",
     "zod": "^4.0.0",
     "zod-to-json-schema": "^3.25.2",
-    "@noy-db/on-shamir": "0.4.0-pre.5"
+    "@noy-db/on-shamir": "0.4.0-pre.6"
   },
   "peerDependencies": {
     "zod-to-json-schema": "^3.25.0"

package/dist/aggregate/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/with-lookup/aggregate/active.ts"],"sourcesContent":["/**\n * Active aggregate strategy factory. Calling `withAggregate()` returns\n * an `AggregateStrategy` whose methods construct real `Aggregation` /\n * `GroupedQuery` instances and run the streaming reducer protocol.\n *\n * This module is only reachable through the `@noy-db/hub/aggregate`\n * subpath — a consumer that never imports the subpath ships none of\n * this (ESM tree-shaking + hub's `\"sideEffects\": false`).\n */\n\nimport { Aggregation, reduceRecords } from './aggregation.js'\nimport type { AggregateSpec, AggregateResult } from './aggregation.js'\nimport { GroupedQuery, GroupedQueryN } from './groupby.js'\nimport type { AggregateStrategy } from './strategy.js'\n\n/**\n * Build the default aggregate strategy. Pass into\n * `createNoydb({ aggregateStrategy: withAggregate() })` to light up\n * `.aggregate()` and `.groupBy()` on `Query` and `ScanBuilder`.\n *\n * @example\n * ```ts\n * import { createNoydb } from '@noy-db/hub'\n * import { withAggregate, sum, count } from '@noy-db/hub/aggregate'\n *\n * const db = await createNoydb({\n *   store, user, secret,\n *   aggregateStrategy: withAggregate(),\n * })\n *\n * const totals = invoices.query()\n *   .where('status', '==', 'paid')\n *   .groupBy('clientId')\n *   .aggregate({ amount: sum('amount'), n: count() })\n *   .run()\n * ```\n */\nexport function withAggregate(): AggregateStrategy {\n  return {\n    aggregate(executeRecords, spec, upstreams) {\n      return new Aggregation(executeRecords, spec as unknown as AggregateSpec, upstreams) as unknown as Aggregation<AggregateResult<typeof spec>>\n    },\n    groupBy(executeRecords, field, upstreams, dictLabelResolver, via) {\n      return new GroupedQuery(executeRecords, field, upstreams, dictLabelResolver, via)\n    },\n    groupByN(executeRecords, fields, upstreams, via) {\n      return new GroupedQueryN(executeRecords, fields, upstreams, undefined, via)\n    },\n    async scanAggregate(iter, spec) {\n      const collected: unknown[] = []\n      for await (const record of iter) collected.push(record)\n      return reduceRecords(collected, spec as unknown as AggregateSpec) as unknown as AggregateResult<typeof spec>\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCO,SAAS,gBAAmC;AACjD,SAAO;AAAA,IACL,UAAU,gBAAgB,MAAM,WAAW;AACzC,aAAO,IAAI,YAAY,gBAAgB,MAAkC,SAAS;AAAA,IACpF;AAAA,IACA,QAAQ,gBAAgB,OAAO,WAAW,mBAAmB,KAAK;AAChE,aAAO,IAAI,aAAa,gBAAgB,OAAO,WAAW,mBAAmB,GAAG;AAAA,IAClF;AAAA,IACA,SAAS,gBAAgB,QAAQ,WAAW,KAAK;AAC/C,aAAO,IAAI,cAAc,gBAAgB,QAAQ,WAAW,QAAW,GAAG;AAAA,IAC5E;AAAA,IACA,MAAM,cAAc,MAAM,MAAM;AAC9B,YAAM,YAAuB,CAAC;AAC9B,uBAAiB,UAAU,KAAM,WAAU,KAAK,MAAM;AACtD,aAAO,cAAc,WAAW,IAAgC;AAAA,IAClE;AAAA,EACF;AACF;","names":[]}