@noy-db/hub 0.4.0-pre.0 → 0.4.0-pre.10

package/dist/with-formula/materialized-views/registry.d.ts

@@ -1,12 +1,12 @@
 import type { ViaGraph, FieldRef, EdgeKind, Grain } from '../../kernel/via/graph.js';
 import type { FieldClause } from '../../kernel/query/predicate.js';
-import type { MaterializedViewStrategy, MVQueryContext } from './types.js';
+import type { MaterializedViewSpec, MVQueryContext } from './types.js';
 /**
  * One registered MV strategy alongside its derived metadata. Stored
  * type-erased on `TRow` so the registry can hold heterogeneous MVs.
  */
 export interface RegisteredMV {
-    readonly spec: MaterializedViewStrategy<any>;
+    readonly spec: MaterializedViewSpec<any>;
     /** Output collection name (`spec.output?.collection ?? spec.name`). */
     readonly outputCollection: string;
     /** Set of source collections; populated at registration via the analyzer. */
@@ -65,7 +65,7 @@ export declare class MaterializedViewRegistry {
      * surfaces a dependency the vault doesn't know about (when a
      * `knownCollections` checker is supplied).
      */
-    register(spec: MaterializedViewStrategy<any>, db: MVQueryContext, options?: {
+    register(spec: MaterializedViewSpec<any>, db: MVQueryContext, options?: {
         knownCollections?: (name: string) => boolean;
     }): Promise<void>;
     /** All MVs that depend on `source`, in registration order. */
@@ -125,4 +125,4 @@ export declare class MaterializedViewRegistry {
  *
  * @internal
  */
-export declare function wrapDbWithPredicates(db: MVQueryContext, predicates: NonNullable<MaterializedViewStrategy<Record<string, unknown>>['predicates']>): MVQueryContext;
+export declare function wrapDbWithPredicates(db: MVQueryContext, predicates: NonNullable<MaterializedViewSpec<Record<string, unknown>>['predicates']>): MVQueryContext;

package/dist/with-formula/materialized-views/types.d.ts

@@ -1,7 +1,7 @@
 import type { Query } from '../../kernel/query/builder.js';
 import type { Collection } from '../../kernel/collection.js';
-import type { AggregateSpec, Aggregation } from '../../with-lookup/aggregate/aggregation.js';
-import type { GroupedAggregation } from '../../with-lookup/aggregate/groupby.js';
+import type { ReduceSpec, Reduction } from '../../with-lookup/reduce/reduction.js';
+import type { GroupedReduction } from '../../with-lookup/reduce/groupby.js';
 import type { JoinStrategy } from '../../kernel/query/join.js';
 import type { MoneyDescriptor } from '../../via/money/descriptor.js';
 import type { I18nTextDescriptor } from '../../via/i18n/core.js';
@@ -97,7 +97,7 @@ export interface UnionSource<TRow extends Record<string, unknown>> {
      * `as` — the same machinery as the query-form `Query.join()`.
      *
      * The right-side collections must be listed in the strategy's
-     * {@link MaterializedViewStrategy.sources} so writes to them trigger
+     * {@link MaterializedViewSpec.sources} so writes to them trigger
      * MV refresh — registration throws `MaterializedViewConfigError`
      * otherwise (the union dependency set comes from arm `collection`s
      * alone, which would not include join targets).
@@ -185,7 +185,7 @@ export type ProjectionJoinLeg = {
  *
  * @typeParam TRow - the materialized row type (the query's result row)
  */
-export interface MaterializedViewStrategy<TRow extends Record<string, unknown>> {
+export interface MaterializedViewSpec<TRow extends Record<string, unknown>> {
     /**
      * Stable identity for this view. Used as the output collection name
      * unless `output.collection` overrides. Must be unique within the vault.
@@ -207,7 +207,7 @@ export interface MaterializedViewStrategy<TRow extends Record<string, unknown>>
      * (multi-source UNION). Registration throws
      * `MaterializedViewConfigError` if both are set or neither is set.
      */
-    query?: (db: MVQueryContext) => Query<TRow> | Aggregation<TRow> | GroupedAggregation<TRow>;
+    query?: (db: MVQueryContext) => Query<TRow> | Reduction<TRow> | GroupedReduction<TRow>;
     /**
      * UNION-form sources: an explicit list of sibling collections
      * that contribute rows to a single MV. Each arm's `map` projects a
@@ -261,14 +261,14 @@ export interface MaterializedViewStrategy<TRow extends Record<string, unknown>>
      */
     groupBy?: string | ReadonlyArray<string>;
     /**
-     * Aggregation spec for UNION mode. Applied per-group after
+     * Reduction spec for UNION mode. Applied per-group after
      * {@link groupBy} buckets the concatenated mapped-row stream from
-     * {@link unionSources}. Same shape as the `AggregateSpec` passed to
+     * {@link unionSources}. Same shape as the `ReduceSpec` passed to
      * `Query.aggregate()`.
      *
      * UNION-mode only. Ignored if {@link query} is set.
      */
-    aggregate?: AggregateSpec;
+    aggregate?: ReduceSpec;
     /**
      * Money descriptors for the UNION-mode aggregate, keyed by the
      * OUTPUT/intermediate field name as it appears in the mapped row and
@@ -325,7 +325,7 @@ export interface MaterializedViewStrategy<TRow extends Record<string, unknown>>
     rowKey: (row: TRow) => string;
     /**
      * Explicit source collections. Required when `query()` returns
-     * an `Aggregation` or `GroupedAggregation` rather than a `Query<T>`
+     * an `Reduction` or `GroupedReduction` rather than a `Query<T>`
      * — the dependency analyzer can't introspect through `groupBy().aggregate()`
      * back to the source. Optional for plain `Query<T>` results — the
      * analyzer extracts dependencies automatically from the query plan.
@@ -393,7 +393,7 @@ export interface MaterializedViewStrategy<TRow extends Record<string, unknown>>
     maxRows?: number;
 }
 /** Returned by `withMaterializedView()` and consumed by `createNoydb`. */
-export interface MaterializedViewStrategyHandle {
+export interface MaterializedViewStrategy {
     readonly __noydb_strategy: 'materialized-view';
-    readonly spec: MaterializedViewStrategy<any>;
+    readonly spec: MaterializedViewSpec<any>;
 }

package/dist/with-formula/materialized-views/with-materialized-view.d.ts

@@ -1,4 +1,4 @@
-import type { MaterializedViewStrategy, MaterializedViewStrategyHandle } from './types.js';
+import type { MaterializedViewSpec, MaterializedViewStrategy } from './types.js';
 /**
  * Register a materialized view: a declared query whose result is
  * persisted as a queryable collection and kept fresh as sources
@@ -25,4 +25,4 @@ import type { MaterializedViewStrategy, MaterializedViewStrategyHandle } from '.
  * docs/superpowers/specs/2026-05-21-dim14-mv-multikey-and-union.md (UNION),
  * and docs/superpowers/specs/2026-07-25-join-projection-mv-design.md (projection).
  */
-export declare function withMaterializedView<TRow extends Record<string, unknown>>(spec: MaterializedViewStrategy<TRow>): MaterializedViewStrategyHandle;
+export declare function withMaterializedView<TRow extends Record<string, unknown>>(spec: MaterializedViewSpec<TRow>): MaterializedViewStrategy;

package/dist/with-formula/overlay-views/index.d.ts

@@ -1,5 +1,5 @@
 export { withOverlayedView } from './with-overlayed-view.js';
 export { OverlayedViewRegistry } from './registry.js';
 export { OverlayedCollection } from './virtual-collection.js';
-export type { OverlayedViewStrategy, OverlayedViewStrategyHandle, OverlayFieldMergeRule, OverlayFieldMergeMode, } from './types.js';
+export type { OverlayedViewSpec, OverlayedViewStrategy, OverlayFieldMergeRule, OverlayFieldMergeMode, } from './types.js';
 export { OverlayBaseIsVirtualError, OverlayCollectionUnavailableError, OverlayNameCollisionError, OverlayIdMismatchError, } from '../../kernel/errors.js';

package/dist/with-formula/overlay-views/registry.d.ts

@@ -1,5 +1,5 @@
 import type { MaterializedViewRegistry } from '../materialized-views/registry.js';
-import type { OverlayedViewStrategy } from './types.js';
+import type { OverlayedViewSpec } from './types.js';
 /**
  * Vault-internal registry of overlay strategies. Resolves the base
  * MV's `rowKey` lazily so virtual-collection writes can derive ids
@@ -15,12 +15,12 @@ export declare class OverlayedViewRegistry {
      * declared without the MV registry context skip cross-registry
      * checks but still validate self-consistency.
      */
-    register(spec: OverlayedViewStrategy, options: {
+    register(spec: OverlayedViewSpec, options: {
         isOverlayName?: (name: string) => boolean;
         isMVOutput?: (name: string) => boolean;
         isKnownCollection?: (name: string) => boolean;
     }): void;
-    byName(name: string): OverlayedViewStrategy | undefined;
+    byName(name: string): OverlayedViewSpec | undefined;
     /** All overlay virtual names. */
     names(): ReadonlySet<string>;
     isOverlay(name: string): boolean;
@@ -31,7 +31,7 @@ export declare class OverlayedViewRegistry {
      *
      * Used by `dumpSchema()` to populate the `overlayViews` map.
      */
-    all(): ReadonlyArray<OverlayedViewStrategy>;
+    all(): ReadonlyArray<OverlayedViewSpec>;
     /**
      * Resolve the `rowKey` function for an overlay's base MV. Returns
      * `undefined` if the base isn't an MV (raw source collection) or

package/dist/with-formula/overlay-views/types.d.ts

@@ -6,7 +6,7 @@
  * v2 ships the read-shadow variant only — arbitrary `mergePolicy`
  * callbacks are deferred to v3.
  */
-export interface OverlayedViewStrategy {
+export interface OverlayedViewSpec {
     /**
      * Virtual collection name. `vault.collection(name)` returns a
      * proxy that merges `base` and `overlay` per the shadow rule.
@@ -91,7 +91,7 @@ export interface OverlayFieldMergeMode {
     readonly rules: readonly OverlayFieldMergeRule[];
 }
 /** Returned by `withOverlayedView()` and consumed by `createNoydb`. */
-export interface OverlayedViewStrategyHandle {
+export interface OverlayedViewStrategy {
     readonly __noydb_strategy: 'overlayed-view';
-    readonly spec: OverlayedViewStrategy;
+    readonly spec: OverlayedViewSpec;
 }

package/dist/with-formula/overlay-views/virtual-collection.d.ts

@@ -1,5 +1,5 @@
 import type { Collection } from '../../kernel/collection.js';
-import type { OverlayedViewStrategy } from './types.js';
+import type { OverlayedViewSpec } from './types.js';
 /**
  * Virtual-collection proxy returned by `vault.collection(overlayName)`
  * when `overlayName` is a registered `withOverlayedView`.
@@ -23,7 +23,7 @@ export declare class OverlayedCollection<T extends Record<string, unknown> = any
     private readonly baseCollection;
     private readonly overlayCollection;
     private readonly baseRowKey;
-    constructor(spec: OverlayedViewStrategy, baseCollection: Collection<T>, overlayCollection: Collection<T>, baseRowKey: ((row: Record<string, unknown>) => string) | undefined);
+    constructor(spec: OverlayedViewSpec, baseCollection: Collection<T>, overlayCollection: Collection<T>, baseRowKey: ((row: Record<string, unknown>) => string) | undefined);
     /**
      * Convenience accessors for advanced callers that need to bypass the
      * virtual layer (bulk imports, direct overlay queries). Mirrors the

package/dist/with-formula/overlay-views/with-overlayed-view.d.ts

@@ -1,4 +1,4 @@
-import type { OverlayedViewStrategy, OverlayedViewStrategyHandle } from './types.js';
+import type { OverlayedViewSpec, OverlayedViewStrategy } from './types.js';
 /**
  * Register a read-shadow overlay: bind an MV-owned base collection to
  * a user-writable overlay so consumers can express operator-editable
@@ -6,4 +6,4 @@ import type { OverlayedViewStrategy, OverlayedViewStrategyHandle } from './types
  *
  * See docs/superpowers/specs/2026-05-20-dim14-mv-v2-design.md.
  */
-export declare function withOverlayedView(spec: OverlayedViewStrategy): OverlayedViewStrategyHandle;
+export declare function withOverlayedView(spec: OverlayedViewSpec): OverlayedViewStrategy;

package/dist/with-lookup/indexing/active.d.ts

@@ -1,6 +1,6 @@
 /**
  * Active indexing strategy factory. Calling `withIndexing()` returns
- * an `IndexStrategy` whose `createState` constructs a real
+ * an `IndexingStrategy` whose `createState` constructs a real
  * `CollectionIndexes` (eager) or `PersistedCollectionIndex` (lazy)
  * per Collection, depending on the collection's `prefetch` mode and
  * its declared `IndexDef[]`.
@@ -9,10 +9,10 @@
  * subpath — a consumer that never imports the subpath ships none of
  * this (ESM tree-shaking + hub's `"sideEffects": false`).
  */
-import type { IndexStrategy } from './strategy.js';
+import type { IndexingStrategy } from './strategy.js';
 /**
  * Build the default indexing strategy. Pass into
- * `createNoydb({ indexStrategy: withIndexing() })` to light up the
+ * `createNoydb({ indexingStrategy: withIndexing() })` to light up the
  * eager-mode `==/in` fast-path on `.query()` and the full lazy-mode
  * `.lazyQuery()` + rebuild / reconcile / auto-reconcile surface.
  *
@@ -23,8 +23,8 @@ import type { IndexStrategy } from './strategy.js';
  *
  * const db = await createNoydb({
  *   store, user, secret,
- *   indexStrategy: withIndexing(),
+ *   indexingStrategy: withIndexing(),
  * })
  * ```
  */
-export declare function withIndexing(): IndexStrategy;
+export declare function withIndexing(): IndexingStrategy;

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

@@ -18,10 +18,12 @@
  * capability boundary is explicit in import statements.
  */
 export { withIndexing } from './active.js';
-export type { IndexStrategy, IndexState } from './strategy.js';
+export type { IndexingStrategy, IndexState } from './strategy.js';
 export { CollectionIndexes } from './eager-indexes.js';
 export type { IndexDef, HashIndex } from './eager-indexes.js';
 export { PersistedCollectionIndex, IDX_PREFIX, COMPOSITE_DELIMITER, encodeIdxId, decodeIdxId, isIdxId, compositeKey, } from './persisted-indexes.js';
 export type { OrderedEntry, IngestRow, PersistedIndexDef, } from './persisted-indexes.js';
 export { LazyQuery } from './lazy-builder.js';
 export type { LazyQuerySource, LazyOrderBy } from './lazy-builder.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_INDEXING } from './strategy.js';

package/dist/with-lookup/indexing/strategy.d.ts

@@ -1,6 +1,6 @@
 /**
  * Strategy seam between core Collection and the optional indexing
- * service. Core imports `IndexStrategy` and `IndexState` as
+ * service. Core imports `IndexingStrategy` and `IndexState` as
  * TYPE-ONLY symbols and `NO_INDEXING` as a tiny runtime stub.
  *
  * The heavy classes — `CollectionIndexes`, `PersistedCollectionIndex`,
@@ -39,7 +39,7 @@ export interface IndexState {
  *
  * @internal
  */
-export interface IndexStrategy {
+export interface IndexingStrategy {
     createState(args: {
         readonly defs: readonly IndexDef[];
         readonly lazy: boolean;
@@ -53,4 +53,4 @@ export interface IndexStrategy {
  *
  * @internal
  */
-export declare const NO_INDEXING: IndexStrategy;
+export declare const NO_INDEXING: IndexingStrategy;

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

@@ -1,26 +1,26 @@
 /**
- * Active aggregate strategy factory. Calling `withAggregate()` returns
- * an `AggregateStrategy` whose methods construct real `Aggregation` /
+ * Active aggregate strategy factory. Calling `withReduce()` returns
+ * an `ReduceStrategy` whose methods construct real `Reduction` /
  * `GroupedQuery` instances and run the streaming reducer protocol.
  *
- * This module is only reachable through the `@noy-db/hub/aggregate`
+ * This module is only reachable through the `@noy-db/hub/reduce`
  * subpath — a consumer that never imports the subpath ships none of
  * this (ESM tree-shaking + hub's `"sideEffects": false`).
  */
-import type { AggregateStrategy } from './strategy.js';
+import type { ReduceStrategy } from './strategy.js';
 /**
  * Build the default aggregate strategy. Pass into
- * `createNoydb({ aggregateStrategy: withAggregate() })` to light up
+ * `createNoydb({ reduceStrategy: withReduce() })` to light up
  * `.aggregate()` and `.groupBy()` on `Query` and `ScanBuilder`.
  *
  * @example
  * ```ts
  * import { createNoydb } from '@noy-db/hub'
- * import { withAggregate, sum, count } from '@noy-db/hub/aggregate'
+ * import { withReduce, sum, count } from '@noy-db/hub/reduce'
  *
  * const db = await createNoydb({
  *   store, user, secret,
- *   aggregateStrategy: withAggregate(),
+ *   reduceStrategy: withReduce(),
  * })
  *
  * const totals = invoices.query()
@@ -30,4 +30,4 @@ import type { AggregateStrategy } from './strategy.js';
  *   .run()
  * ```
  */
-export declare function withAggregate(): AggregateStrategy;
+export declare function withReduce(): ReduceStrategy;

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
@@ -156,7 +156,7 @@ export declare function avg(field: string, opts?: ReducerOptions<{
     sum: number;
     count: number;
 }>;
-interface MinMaxState {
+export interface MinMaxState {
     /**
      * Multiset of contributing field values. Stored as a plain array
      * because we need to support `remove` and a plain array gives us
@@ -254,4 +254,3 @@ export interface ReducerBuilder<T, S extends keyof T = never, M extends keyof T
  * parameter-contravariance, so this single instance works for all `T`/`S`.
  */
 export declare const reducerBuilder: ReducerBuilder<Record<string, unknown>>;
-export {};