@noy-db/hub 0.4.0-pre.1 → 0.4.0-pre.11

package/dist/with-formula/derivations/stale.d.ts

@@ -2,7 +2,7 @@ import type { Collection } from '../../kernel/collection.js';
 import type { ReadOnlyVaultFacade } from '../../with-audit/guards/types.js';
 import type { TxContext } from '../../with-commit/tx/transaction.js';
 import type { DerivationRegistry } from './registry.js';
-import type { DerivationStrategy } from './types.js';
+import type { DerivationSpec } from './types.js';
 /**
  * Accessor shape passed through from the owning Vault. Provides the
  * registry (used to look up strategies and as the WeakMap key) and a
@@ -29,7 +29,7 @@ export interface DerivationStaleAccessor {
     getActiveTxContext(): TxContext | null;
 }
 /** Mark every output of (strategy, sourceId) as stale. */
-export declare function markStale(registry: DerivationRegistry, strategy: DerivationStrategy<any, any>, sourceId: string): Promise<void>;
+export declare function markStale(registry: DerivationRegistry, strategy: DerivationSpec<any, any>, sourceId: string): Promise<void>;
 /**
  * Called from `Collection.get` on lazy-mode output collections. If the
  * id has a pending stale flag for any strategy producing this output

package/dist/with-formula/derivations/types.d.ts

@@ -119,7 +119,7 @@ export type OutputSpec = RecordOutputSpec | ArrayOutputSpec;
  *   value may be a single record, or — for `shape: 'array'` outputs — an
  *   array of records (the fanout sidecar upserts/deletes each row).
  */
-export interface DerivationStrategy<TSource extends Record<string, unknown>, TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>> {
+export interface DerivationSpec<TSource extends Record<string, unknown>, TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>> {
     /** Source collection name. */
     source: string;
     /**
@@ -242,7 +242,7 @@ export interface DerivationStrategy<TSource extends Record<string, unknown>, TOu
     strict?: boolean;
 }
 /** Returned by `withDerivation()` and consumed by `createNoydb`. */
-export interface DerivationStrategyHandle {
+export interface DerivationStrategy {
     readonly __noydb_strategy: 'derivation';
-    readonly spec: DerivationStrategy<any, any>;
+    readonly spec: DerivationSpec<any, any>;
 }

package/dist/with-formula/derivations/with-derivation.d.ts

@@ -1,4 +1,4 @@
-import type { DerivationStrategy, DerivationStrategyHandle } from './types.js';
+import type { DerivationSpec, DerivationStrategy } from './types.js';
 /**
  * Register a deterministic derivation: one source collection → one or
  * more typed outputs, computed by the user's `derive` function on
@@ -7,4 +7,4 @@ import type { DerivationStrategy, DerivationStrategyHandle } from './types.js';
  *
  * See docs/superpowers/specs/2026-05-01-dim14-derivation-v1-design.md.
  */
-export declare function withDerivation<TSource extends Record<string, unknown>, TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>>(spec: DerivationStrategy<TSource, TOutputs>): DerivationStrategyHandle;
+export declare function withDerivation<TSource extends Record<string, unknown>, TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>>(spec: DerivationSpec<TSource, TOutputs>): DerivationStrategy;

package/dist/with-formula/derivations/with-rollup.d.ts

@@ -1,4 +1,17 @@
-import type { DerivationStrategyHandle } from './types.js';
+import type { DerivationStrategy } from './types.js';
+/** Options for {@link withRollup} (#844b — was an inline literal, so unnameable). */
+export interface WithRollupOptions<TChild extends Record<string, unknown> = Record<string, unknown>, TParent extends Record<string, unknown> = Record<string, unknown>> {
+    /** Child collection — the trigger. */
+    readonly from: string;
+    /** FK field on the child pointing at the parent id. */
+    readonly key: keyof TChild & string;
+    /** Parent collection carrying the maintained summary. */
+    readonly into: string;
+    /** Field on the parent to maintain. */
+    readonly field: keyof TParent & string;
+    /** Reduces the matching children to the value written at `field`. */
+    readonly compute: (children: TChild[]) => unknown;
+}
 /**
  * `withRollup` — aggregate many child records onto a single field of their
  * parent. The reverse of a join: instead of reading children
@@ -25,10 +38,4 @@ import type { DerivationStrategyHandle } from './types.js';
  * Desugars to a `withDerivation` strategy carrying a `rollup` marker; dispatch
  * handles it without invoking the executor. Eager-only in this slice.
  */
-export declare function withRollup<TChild extends Record<string, unknown> = Record<string, unknown>, TParent extends Record<string, unknown> = Record<string, unknown>>(config: {
-    from: string;
-    key: keyof TChild & string;
-    into: string;
-    field: keyof TParent & string;
-    compute: (children: TChild[]) => unknown;
-}): DerivationStrategyHandle;
+export declare function withRollup<TChild extends Record<string, unknown> = Record<string, unknown>, TParent extends Record<string, unknown> = Record<string, unknown>>(opts: WithRollupOptions<TChild, TParent>): DerivationStrategy;

package/dist/with-formula/materialized-views/dependency-analyzer.d.ts

@@ -1,5 +1,5 @@
 import type { Query } from '../../kernel/query/builder.js';
-import type { MaterializedViewStrategy } from './types.js';
+import type { MaterializedViewSpec } from './types.js';
 /**
  * Walks a `Query<T>` plan and returns the set of source collection
  * names that any source-write should trigger a refresh on.
@@ -55,7 +55,7 @@ export declare function summarizeQueryPlan(query: Query<any>): string;
  * the MV's `name` (or rely on application-level cache busting) when
  * `map` semantics change non-equivalently.
  */
-export declare function summarizeUnionPlan<T extends Record<string, unknown>>(spec: MaterializedViewStrategy<T>): string;
+export declare function summarizeUnionPlan<T extends Record<string, unknown>>(spec: MaterializedViewSpec<T>): string;
 /**
  * Canonical string description of a projection MV's plan (#810), used
  * as input to `computeQueryHash`.
@@ -70,4 +70,4 @@ export declare function summarizeUnionPlan<T extends Record<string, unknown>>(sp
  * the UNION arm `map`); consumers must bump the MV's `name` when
  * `map` semantics change non-equivalently.
  */
-export declare function summarizeProjectionPlan<T extends Record<string, unknown>>(spec: MaterializedViewStrategy<T>): string;
+export declare function summarizeProjectionPlan<T extends Record<string, unknown>>(spec: MaterializedViewSpec<T>): string;

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

@@ -0,0 +1,75 @@
+/**
+ * Materialized-view dispatch, lifted out of the kernel spine (#842 part b).
+ *
+ * Reached from `Collection` by dynamic `import()` only — `port-layering`
+ * forbids a static spine→`with-*` import, and rejects a type-only one too
+ * (it scans import statements, not their erasure). See
+ * `with-formula/derivations/dispatch.ts` for the same note.
+ *
+ * The `Collection` reference below is TYPE-ONLY and points inward
+ * (service → kernel), so it is both allowed and erased at build.
+ *
+ * @internal
+ */
+import type { TxContext } from '../../with-commit/tx/transaction.js';
+import type { Collection } from '../../kernel/collection.js';
+import type { ledgerAuditHook, WaveContext } from '../../kernel/via/dispatch.js';
+import type { MaterializedViewRegistry } from './registry.js';
+import type { MVQueryContext } from './types.js';
+/** The per-write dispatch context the MV executor threads through. */
+interface DispatchCtx {
+    emit: (e: string, p: unknown) => void;
+    source: {
+        readonly collection: string;
+        readonly id: string;
+    };
+    audit: ReturnType<typeof ledgerAuditHook>;
+}
+/** What the MV dispatchers need from the collection that owns them. */
+export interface MvDispatchCtx {
+    readonly materializedViewSource: {
+        registry(): MaterializedViewRegistry;
+        getCollection(name: string): Collection<any>;
+        getActiveTxContext(): TxContext | null;
+        getQueryContext(): MVQueryContext;
+    };
+    /** The collection the delete happened in. */
+    readonly collectionName: string;
+    /** Builds the per-write dispatch context the executor threads through. */
+    readonly dispatchCtx: (source: {
+        readonly collection: string;
+        readonly id: string;
+    }) => DispatchCtx;
+}
+/**
+ * Fire every MV whose dependency set includes this collection, on write.
+ *
+ * Skips entirely when the record being written is itself an MV-emitted row
+ * (it carries `_materializedFrom`) — a defensive guard against missed cycle
+ * detection.
+ *
+ * @param wave #638 Task 4 — the sync/cutover/restore dispatch wave. An eager
+ *   MV already refreshed in this wave is skipped, deduped per target on the
+ *   spec name.
+ */
+export declare function dispatchMaterializedViews(ctx: MvDispatchCtx, id: string, record: Record<string, unknown>, wave?: WaveContext): Promise<void>;
+/**
+ * Mirror of {@link dispatchMaterializedViews} for the delete/forget path. There is
+ * no `_materializedFrom` skip — the record is gone — and the `internal` gate
+ * at `_doDelete` is the recursion guard.
+ *
+ * @returns rows TOMBSTONED across every MV sourced here (#638 T6). Eager and
+ *   lazy/manual `invalidateMVAtRest` purges both contribute (#761 item 1,
+ *   previously eager-only): lazy persists a stale mark for cold-session
+ *   recompute, manual serves empty until `refreshView()`.
+ *   `residueUndecodable` / `residueDeclined` (#776/#785) carry
+ *   `outputCollection:id` entries whose ownership stamp `invalidateMVAtRest`
+ *   could not decode, respectively decoded and stamp-matched but declined to
+ *   erase — surfaced, not erased.
+ */
+export declare function dispatchMaterializedViewsOnDelete(ctx: MvDispatchCtx, id: string): Promise<{
+    deleted: number;
+    residueUndecodable: string[];
+    residueDeclined: string[];
+}>;
+export {};

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

@@ -5,7 +5,8 @@ export { analyzeDependencies, summarizeQueryPlan } from './dependency-analyzer.j
 export { computeQueryHash, canonicalizeQueryPlan } from './query-hash.js';
 export { markMVStale, resolveStaleMVOnRead, isMVStale, clearMVStale } from './stale.js';
 export type { MVStaleAccessor } from './stale.js';
-export type { MaterializedViewStrategy, MaterializedViewStrategyHandle, MaterializedViewOutput, MaterializedFromMeta, UnionSource, UnionArmJoin, ProjectionSpec, ProjectionJoinLeg, } from './types.js';
+export type { MaterializedViewSpec, MaterializedViewStrategy, MaterializedViewOutput, MaterializedFromMeta, UnionSource, UnionArmJoin, ProjectionSpec, ProjectionJoinLeg, } from './types.js';
 export type { RegisteredMV } from './registry.js';
 export type { MVExecutorAccessor, RefreshResult } from './executor.js';
 export { MaterializedViewCycleError, MaterializedViewConfigError, MaterializedViewSourceUnknownError, MaterializedViewTooLargeError, } from '../../kernel/errors.js';
+export type { PutDerivedOutputCtx } from '../../kernel/via/dispatch.js';

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;