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

package/dist/via/money/money-reducer.d.ts

@@ -22,7 +22,7 @@
  * exactly like the generic reducers they replace.
  */
 import type { MoneyDescriptor } from './descriptor.js';
-import type { AggregateSpec } from '../../with-lookup/aggregate/aggregation.js';
+import type { ReduceSpec } from '../../with-lookup/reduce/reduction.js';
 export type FxRates = Record<string, number | string>;
 /**
  * Rewrite any `sum` / `min` / `max` reducer over a declared money field
@@ -30,4 +30,4 @@ export type FxRates = Record<string, number | string>;
  * reducers over non-money fields) pass through unchanged. Returns a new
  * spec; the input is not mutated.
  */
-export declare function wrapMoneyReducers(spec: AggregateSpec, moneyFields: Record<string, MoneyDescriptor>): AggregateSpec;
+export declare function wrapMoneyReducers(spec: ReduceSpec, moneyFields: Record<string, MoneyDescriptor>): ReduceSpec;

package/dist/walk-6OHAWGBS.js

@@ -0,0 +1,21 @@
+import {
+  dumpVaultSchema
+} from "./chunk-ZWBKDKXC.js";
+import "./chunk-VYYM3MEN.js";
+import "./chunk-6ZNSB3H6.js";
+import "./chunk-Y2NBBT6K.js";
+import "./chunk-OBPVWOSQ.js";
+import "./chunk-RZPOZPZU.js";
+import "./chunk-VH6SOCXH.js";
+import "./chunk-35NMVJ7I.js";
+import "./chunk-NFZGZ4AK.js";
+import "./chunk-QJNCB5SK.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-AKKRXT23.js";
+import "./chunk-GZACYEOB.js";
+import "./chunk-QZWTRENR.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  dumpVaultSchema
+};
+//# sourceMappingURL=walk-6OHAWGBS.js.map

package/dist/with-audit/consent/index.d.ts

@@ -12,3 +12,5 @@ export { withConsent } from './active.js';
 export type { ConsentStrategy } from './strategy.js';
 export { CONSENT_AUDIT_COLLECTION, writeConsentEntry, loadConsentEntries, } from './consent.js';
 export type { ConsentContext, ConsentOp, ConsentAuditEntry, ConsentAuditFilter, } from './consent.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_CONSENT } from './strategy.js';

package/dist/with-audit/forget/active.d.ts

@@ -1,5 +1,5 @@
 /**
- * `withForgetCascade` — the active factory for GDPR right-to-erasure via
+ * `withForget` — the active factory for GDPR right-to-erasure via
  * per-record CEK crypto-shred. Mirrors the canonical
  * `strategy.ts` (type + `NO_FORGET` sentinel) / `active.ts` (factory) split
  * used by the other services.
@@ -22,10 +22,10 @@ import type { SubjectDeclaration, ForgetStrategy } from './strategy.js';
  * ```ts
  * createNoydb({
  *   secret, user,
- *   forgetStrategy: withForgetCascade({ subjects: { invoices: 'buyerId' } }),
+ *   forgetStrategy: withForget({ subjects: { invoices: 'buyerId' } }),
  * })
  * const result = await vault.forget('buyer-123')
  * // → { subject, recordsShredded, historyVersionsShredded, collections, … }
  * ```
  */
-export declare function withForgetCascade(opts: SubjectDeclaration): ForgetStrategy;
+export declare function withForget(opts: SubjectDeclaration): ForgetStrategy;

package/dist/with-audit/forget/index.d.ts

@@ -1,15 +1,15 @@
 /**
  * `@noy-db/hub/forget` — GDPR right-to-erasure via per-record CEK crypto-shred.
- * Import `withForgetCascade` and pass it to `createNoydb`:
+ * Import `withForget` and pass it to `createNoydb`:
  *
  * ```ts
  * import { createNoydb } from '@noy-db/hub'
- * import { withForgetCascade } from '@noy-db/hub/forget'
+ * import { withForget } from '@noy-db/hub/forget'
  *
  * const db = createNoydb({
  *   secret, user,
  *   historyStrategy: withHistory(),               // ledger for the erasure proof
- *   forgetStrategy: withForgetCascade({ subjects: { invoices: 'buyerId' } }),
+ *   forgetStrategy: withForget({ subjects: { invoices: 'buyerId' } }),
  * })
  * const vault = await db.openVault('main')
  * const result = await vault.forget('buyer-123')
@@ -22,7 +22,7 @@
  *
  * @module
  */
-export { withForgetCascade } from './active.js';
+export { withForget } from './active.js';
 export { NO_FORGET } from './strategy.js';
 export type { SubjectDeclaration, ForgetStrategy, ForgetResult, ScopedPurgeResidueNotice, } from './strategy.js';
 export type { SubjectRef } from './subject-index.js';

package/dist/with-audit/forget/strategy.d.ts

@@ -1,5 +1,5 @@
 /**
- * `withForgetCascade` — declaration surface for GDPR right-to-erasure via
+ * `withForget` — declaration surface for GDPR right-to-erasure via
  * per-record CEK crypto-shred.
  *
  * This file holds only the *declaration* shape and the disabled sentinel.
@@ -18,12 +18,12 @@
  */
 import type { LedgerEntry } from '../../with-commit/history/ledger/entry.js';
 /**
- * User-supplied declaration passed to {@link withForgetCascade}. Maps a
+ * User-supplied declaration passed to {@link withForget}. Maps a
  * collection name to the record field (dotted path supported, e.g.
  * `'billing.buyerId'`) that identifies the data subject for erasure.
  *
  * ```ts
- * withForgetCascade({ subjects: { invoices: 'buyerId', contacts: 'id' } })
+ * withForget({ subjects: { invoices: 'buyerId', contacts: 'id' } })
  * ```
  */
 export interface SubjectDeclaration {

package/dist/with-audit/guards/executor.d.ts

@@ -1,6 +1,6 @@
-import type { GuardStrategy, GuardContext, GuardChange } from './types.js';
+import type { GuardSpec, GuardContext, GuardChange } from './types.js';
 /**
- * Pure functions that execute the work declared by a `GuardStrategy`.
+ * Pure functions that execute the work declared by a `GuardSpec`.
  * Stateless — `GuardRegistry` decides when to call these.
  *
  * @internal
@@ -17,10 +17,10 @@ export declare const GuardExecutor: {
      *   `existing[field]` vs `incoming[field]` would always look like a
      *   change even when the computed result is unchanged.
      */
-    checkFrozenFields<T extends Record<string, unknown>>(guard: GuardStrategy<T>, id: string, existing: T | null, incoming: T, skipFields?: ReadonlySet<string>): Promise<void>;
+    checkFrozenFields<T extends Record<string, unknown>>(guard: GuardSpec<T>, id: string, existing: T | null, incoming: T, skipFields?: ReadonlySet<string>): Promise<void>;
     /**
      * Run a single guard's invariant over its slice of the change-set.
      * Any throw is converted to `InvariantError` unless it already is one.
      */
-    runInvariant<T extends Record<string, unknown>>(guard: GuardStrategy<T>, changes: ReadonlyArray<GuardChange<T>>, ctx: GuardContext<T>): Promise<void>;
+    runInvariant<T extends Record<string, unknown>>(guard: GuardSpec<T>, changes: ReadonlyArray<GuardChange<T>>, ctx: GuardContext<T>): Promise<void>;
 };

package/dist/with-audit/guards/immutable-guard.d.ts

@@ -25,7 +25,7 @@
  * ledgered by the guard amendment mechanism). `appendOnly: true` is
  * shorthand for `after: () => true` — immutable from creation.
  */
-import type { GuardStrategyHandle, GuardContext, GuardChange } from './types.js';
+import type { GuardStrategy, GuardContext, GuardChange } from './types.js';
 export interface ImmutableGuardConfig<T extends Record<string, unknown>> {
     /** The collection to make WORM. */
     collection: string;
@@ -42,7 +42,7 @@ export interface ImmutableGuardConfig<T extends Record<string, unknown>> {
     amendmentRoles?: ReadonlyArray<'admin' | 'owner'>;
     /**
      * Optional set-level invariant run over the amendment change-set after
-     * the writes execute. Signature matches `GuardStrategy.amendment.invariant`
+     * the writes execute. Signature matches `GuardSpec.amendment.invariant`
      * exactly: it receives every {before, after} pair touching this
      * collection in the amendment plus the guard context; throwing reverts
      * the whole amendment and surfaces as `InvariantError`.
@@ -60,4 +60,4 @@ export interface ImmutableGuardConfig<T extends Record<string, unknown>> {
  * Build an immutability guard. Pass the returned handle to
  * `createNoydb({ guardStrategies: [...] })`.
  */
-export declare function immutableGuard<T extends Record<string, unknown>>(config: ImmutableGuardConfig<T>): GuardStrategyHandle<T>;
+export declare function immutableGuard<T extends Record<string, unknown>>(config: ImmutableGuardConfig<T>): GuardStrategy<T>;

package/dist/with-audit/guards/index.d.ts

@@ -6,5 +6,5 @@ export type { TransitionGuardConfig } from './transition-guard.js';
 export { GuardRegistry } from './registry.js';
 export { GuardExecutor } from './executor.js';
 export { ReadOnlyVaultFacade } from './read-only-facade.js';
-export type { GuardStrategy, GuardStrategyHandle, GuardContext, GuardChange, } from './types.js';
+export type { GuardSpec, GuardStrategy, GuardContext, GuardChange, } from './types.js';
 export { RecordLockedError, FieldFrozenError, IllegalTransitionError, InvariantError, AmendmentForbiddenError, } from '../../kernel/errors.js';

package/dist/with-audit/guards/registry.d.ts

@@ -1,4 +1,4 @@
-import type { GuardStrategy, GuardContext, GuardChange } from './types.js';
+import type { GuardSpec, GuardContext, GuardChange } from './types.js';
 /**
  * Per-record metadata attached to every entry in an amendment's
  * change-set. Carried in a parallel map alongside `_amendmentChanges`
@@ -20,14 +20,14 @@ export interface AmendmentChangeMeta {
  *
  * @internal
  */
-type AnyGuard = GuardStrategy<Record<string, unknown>>;
+type AnyGuard = GuardSpec<Record<string, unknown>>;
 type AnyChange = GuardChange<Record<string, unknown>>;
 export declare class GuardRegistry {
     private readonly _byCollection;
     private _amendmentChanges;
     private _amendmentMeta;
     /** Register a guard. Multiple guards per collection are allowed. */
-    register<T extends Record<string, unknown>>(spec: GuardStrategy<T>): void;
+    register<T extends Record<string, unknown>>(spec: GuardSpec<T>): void;
     /** All guards registered against `collection` in registration order. */
     guardsFor(collection: string): ReadonlyArray<AnyGuard>;
     /** Per-collection guard counts, for introspection. */

package/dist/with-audit/guards/transition-guard.d.ts

@@ -42,7 +42,7 @@
  *
  * The status graph is caller-supplied data — no UI, no domain logic.
  */
-import type { GuardStrategyHandle, GuardContext, GuardChange } from './types.js';
+import type { GuardStrategy, GuardContext, GuardChange } from './types.js';
 export interface TransitionGuardConfig<T extends Record<string, unknown>> {
     /** The collection whose state field is governed. */
     collection: string;
@@ -68,7 +68,7 @@ export interface TransitionGuardConfig<T extends Record<string, unknown>> {
     amendmentRoles?: ReadonlyArray<'admin' | 'owner'>;
     /**
      * Optional set-level invariant run over the amendment change-set after
-     * the writes execute. Signature matches `GuardStrategy.amendment.invariant`
+     * the writes execute. Signature matches `GuardSpec.amendment.invariant`
      * exactly. When omitted the amendment is unconditionally allowed (the
      * amendment itself is the sanctioned, ledgered override) — the
      * backward-compatible default. Mirrors {@link immutableGuard}.
@@ -79,4 +79,4 @@ export interface TransitionGuardConfig<T extends Record<string, unknown>> {
  * Build a state-machine transition guard. Pass the returned handle to
  * `createNoydb({ guardStrategies: [...] })`.
  */
-export declare function transitionGuard<T extends Record<string, unknown>>(config: TransitionGuardConfig<T>): GuardStrategyHandle<T>;
+export declare function transitionGuard<T extends Record<string, unknown>>(config: TransitionGuardConfig<T>): GuardStrategy<T>;

package/dist/with-audit/guards/types.d.ts

@@ -36,16 +36,16 @@ export interface GuardChange<T> {
     after: T;
 }
 /** @internal — output of {@link withGuard}. */
-export interface GuardStrategyHandle<T extends Record<string, unknown>> {
+export interface GuardStrategy<T extends Record<string, unknown>> {
     readonly __noydb_strategy: 'guard';
-    readonly spec: GuardStrategy<T>;
+    readonly spec: GuardSpec<T>;
 }
 /**
- * Existential erasure of `GuardStrategyHandle<T>` — used as the
+ * Existential erasure of `GuardStrategy<T>` — used as the
  * element type of `ReadonlyArray<>` fields where the per-handle T
  * differs (e.g. `guardStrategies: [invoiceGuard, disbursementGuard]`).
  *
- * Background: `GuardStrategyHandle<T>` is INVARIANT in T because T
+ * Background: `GuardStrategy<T>` is INVARIANT in T because T
  * appears in callback positions on the spec (`check(incoming: T, ctx)`,
  * `invariant(changes: ReadonlyArray<GuardChange<T>>, ctx)`). So
  * `Handle<Invoice>` is not assignable to `Handle<Record<string, unknown>>`.
@@ -55,9 +55,9 @@ export interface GuardStrategyHandle<T extends Record<string, unknown>> {
  * interface that ERASES T from both the discriminant and the spec.
  *
  * Consumers continue to construct typed handles via `withGuard<T>(...)`
- * which returns `GuardStrategyHandle<T>`. Both `Handle<Invoice>` and
- * `Handle<Disbursement>` structurally assign to `GuardStrategyHandleAny`,
- * so an array of them is `GuardStrategyHandleAny[]`.
+ * which returns `GuardStrategy<T>`. Both `Handle<Invoice>` and
+ * `Handle<Disbursement>` structurally assign to `GuardStrategyAny`,
+ * so an array of them is `GuardStrategyAny[]`.
  *
  * Internal code that needs T re-narrows via the runtime discriminant
  * (`__noydb_strategy === 'guard'`) plus per-handle type information
@@ -69,12 +69,12 @@ export interface GuardStrategyHandle<T extends Record<string, unknown>> {
  *
  * @internal
  */
-export interface GuardStrategyHandleAny {
+export interface GuardStrategyAny {
     readonly __noydb_strategy: 'guard';
-    readonly spec: GuardStrategy<any>;
+    readonly spec: GuardSpec<any>;
 }
 /** Public registration shape. See `withGuard()`. */
-export interface GuardStrategy<T extends Record<string, unknown>> {
+export interface GuardSpec<T extends Record<string, unknown>> {
     collection: string;
     /**
      * Fires on `Collection.put` (insert + update). The `incoming` argument

package/dist/with-audit/guards/with-guard.d.ts

@@ -1,4 +1,4 @@
-import type { GuardStrategy, GuardStrategyHandle } from './types.js';
+import type { GuardSpec, GuardStrategy } from './types.js';
 /**
  * Register a guard for a collection. Guards run on every `put()` /
  * `delete()` for the named collection (after permissions, before
@@ -12,4 +12,4 @@ import type { GuardStrategy, GuardStrategyHandle } from './types.js';
  *
  * @see docs/superpowers/specs/2026-05-18-guards-design.md
  */
-export declare function withGuard<T extends Record<string, unknown>>(strategy: GuardStrategy<T>): GuardStrategyHandle<T>;
+export declare function withGuard<T extends Record<string, unknown>>(strategy: GuardSpec<T>): GuardStrategy<T>;

package/dist/with-audit/periods/index.d.ts

@@ -16,3 +16,5 @@ export { withPeriods } from './active.js';
 export type { PeriodsStrategy } from './strategy.js';
 export { PERIODS_COLLECTION, PERIOD_FREEZES_COLLECTION, PERIOD_ARCHIVES_COLLECTION, PERIOD_TARGET_PURGES_COLLECTION, periodExclusiveUpperBound, loadPeriods, chainAnchor, assertTsWritable, validatePeriodName, appendPeriodLedgerEntry, } from './periods.js';
 export type { PeriodRecord, PeriodFreezeRecord, PeriodArchiveRecord, PeriodTargetPurgeRecord, TargetPurgeCount, ClosePeriodOptions, OpenPeriodOptions, CarryForwardContext, ReadOnlyCollection, } from './periods.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_PERIODS } from './strategy.js';

package/dist/with-cargo/floor.d.ts

@@ -10,8 +10,8 @@
  * @packageDocumentation
  */
 export { readPath } from '../kernel/query/predicate.js';
-export { reduceRecords } from '../with-lookup/aggregate/aggregation.js';
-export { groupAndReduce } from '../with-lookup/aggregate/groupby.js';
+export { reduceRecords } from '../with-lookup/reduce/reduction.js';
+export { groupAndReduce } from '../with-lookup/reduce/groupby.js';
 export { generateULID } from '../with-pod/ulid.js';
 export { sha256Hex } from '../kernel/enclave/index.js';
 export { isQuorum, runDrainBarrier } from '../port/by/index.js';
@@ -26,7 +26,7 @@ export type { Operator } from '../kernel/query/predicate.js';
 export type { Query } from '../kernel/query/builder.js';
 export type { JoinStrategy } from '../kernel/query/join.js';
 export type { LiveQuery } from '../kernel/query/live.js';
-export type { AggregateResult, AggregateSpec, LiveAggregation, } from '../with-lookup/aggregate/aggregation.js';
+export type { ReduceResult, ReduceSpec, LiveReduction, } from '../with-lookup/reduce/reduction.js';
 export type { IndexDef } from '../with-lookup/indexing/eager-indexes.js';
 export type { FuseOptions } from '../with-lookup/search/fuse.js';
 export type { RetrieveHit, RetrieveOptions } from '../with-lookup/search/retrieve-types.js';

package/dist/with-commit/crdt/index.d.ts

@@ -14,3 +14,5 @@ export { withCrdt } from './active.js';
 export type { CrdtStrategy } from './strategy.js';
 export { resolveCrdtSnapshot, mergeCrdtStates, buildLwwMapState, buildRgaState, } from './crdt.js';
 export type { CrdtMode, CrdtState, LwwMapState, RgaState, YjsState, } from './crdt.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_CRDT } from './strategy.js';

package/dist/with-commit/history/index.d.ts

@@ -28,3 +28,5 @@ export { computePatch, applyPatch } from './ledger/patch.js';
 export type { JsonPatch, JsonPatchOp } from './ledger/patch.js';
 export { VaultInstant, CollectionInstant } from './time-machine.js';
 export type { VaultEngine } from './time-machine.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_HISTORY } from './strategy.js';

package/dist/with-commit/numbering/descriptor.d.ts

@@ -18,10 +18,20 @@ export interface DeferredNumberingConfig {
      */
     readonly settleWindowMs: number;
 }
+/**
+ * Options for {@link withDeferredNumbering} (#844b — was an inline literal, so
+ * unnameable). Same shape as {@link DeferredNumberingConfig} except
+ * `settleWindowMs` is optional; the factory defaults it to 0.
+ */
+export interface WithDeferredNumberingOptions {
+    /** Series name — the key passed to `vault.sequence(series)`. */
+    readonly series: string;
+    /** Collection holding the records to number. */
+    readonly collection: string;
+    /** Field on each record where the assigned serial is written. */
+    readonly field: string;
+    /** See {@link DeferredNumberingConfig.settleWindowMs}. Default 0. */
+    readonly settleWindowMs?: number;
+}
 /** Declare a deferred-numbering series. Pass the result in `createNoydb({ numbering: [...] })`. */
-export declare function withDeferredNumbering(config: {
-    series: string;
-    collection: string;
-    field: string;
-    settleWindowMs?: number;
-}): DeferredNumberingConfig;
+export declare function withDeferredNumbering(opts: WithDeferredNumberingOptions): DeferredNumberingConfig;

package/dist/with-commit/tx/active.d.ts

@@ -1,13 +1,13 @@
 /**
- * Active transactions strategy. Only reachable via `@noy-db/hub/tx`.
+ * Active transactions strategy. Only reachable via `@noy-db/hub/transactions`.
  */
-import type { TxStrategy } from './strategy.js';
+import type { TransactionsStrategy } from './strategy.js';
 import type { TransactionInvariant } from './invariants.js';
 /**
  * Options for {@link withTransactions}. Currently only commit-time
  * changeset `invariants` (see {@link TransactionInvariant}).
  */
-export interface TransactionStrategyOptions {
+export interface WithTransactionsOptions {
     /**
      * Commit-time set-level invariants run over the changeset on every
      * commit (ordinary AND amendment). See {@link TransactionInvariant}.
@@ -16,7 +16,7 @@ export interface TransactionStrategyOptions {
 }
 /**
  * Build the default transactions strategy. Pass into
- * `createNoydb({ txStrategy: withTransactions() })` to enable
+ * `createNoydb({ transactionsStrategy: withTransactions() })` to enable
  * `db.transaction(fn)` (and `db.transaction({ dryRun: true }, fn)`).
  *
  * Supply `{ invariants }` to register commit-time changeset invariants —
@@ -24,4 +24,4 @@ export interface TransactionStrategyOptions {
  * transaction on a throw. Unlike `amendment.invariant`, these run for
  * ordinary `db.transaction(fn)` calls (and amendments) with no role gate.
  */
-export declare function withTransactions(opts?: TransactionStrategyOptions): TxStrategy;
+export declare function withTransactions(opts?: WithTransactionsOptions): TransactionsStrategy;

package/dist/with-commit/tx/index.d.ts

@@ -6,8 +6,8 @@
  * code.
  */
 export { withTransactions } from './active.js';
-export type { TransactionStrategyOptions } from './active.js';
-export type { TxStrategy } from './strategy.js';
+export type { WithTransactionsOptions } from './active.js';
+export type { TransactionsStrategy } from './strategy.js';
 export type { TransactionInvariant } from './invariants.js';
 export { TxContext, TxVault, TxCollection, runTransaction } from './transaction.js';
 export type { AmendmentTxOptions } from './transaction.js';

package/dist/with-commit/tx/invariants.d.ts

@@ -30,7 +30,7 @@
  *   `InvariantError` thrown by the check passes through unwrapped).
  *
  * ```ts
- * createNoydb({ txStrategy: withTransactions({
+ * createNoydb({ transactionsStrategy: withTransactions({
  *   invariants: [{
  *     scope: 'payments',
  *     check(changes) {

package/dist/with-commit/tx/strategy.d.ts

@@ -1,7 +1,7 @@
 /**
  * Strategy seam for the optional multi-record transaction service.
  * `runTransaction` is only reachable through `withTransactions()`
- * exported from `@noy-db/hub/tx`. Consumers who don't use
+ * exported from `@noy-db/hub/transactions`. Consumers who don't use
  * `db.transaction(fn)` ship none of the ~288 LOC.
  *
  * @internal
@@ -13,11 +13,11 @@ import type { TransactionInvariant } from './invariants.js';
 /**
  * @internal
  */
-export interface TxStrategy {
+export interface TransactionsStrategy {
     runTransaction<T>(db: Noydb, fn: (tx: TxContext) => Promise<T> | T, options?: AmendmentTxOptions, txInvariants?: ReadonlyArray<TransactionInvariant>): Promise<T>;
     runDryRun(db: Noydb, fn: (tx: TxContext) => unknown): Promise<DryRunResult>;
 }
 /**
  * @internal
  */
-export declare const NO_TX: TxStrategy;
+export declare const NO_TRANSACTIONS: TransactionsStrategy;

package/dist/with-fork/shadow/index.d.ts

@@ -12,3 +12,5 @@
 export { withShadow } from './active.js';
 export type { ShadowStrategy } from './strategy.js';
 export { VaultFrame, CollectionFrame } from './vault-frame.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_SHADOW } from './strategy.js';

package/dist/with-fork/snapshots/active.d.ts

@@ -1,4 +1,4 @@
-import type { SnapshotStrategy, RetentionPolicy } from './strategy.js';
+import type { SnapshotsStrategy, RetentionPolicy } from './strategy.js';
 import type { SnapshotPolicy } from './policy.js';
 import type { NoydbPodStore } from '../../kernel/types.js';
 export interface WithSnapshotsOptions {
@@ -17,4 +17,4 @@ export interface WithSnapshotsOptions {
      */
     snapshotPolicy?: SnapshotPolicy;
 }
-export declare function withSnapshots(opts: WithSnapshotsOptions): SnapshotStrategy;
+export declare function withSnapshots(opts: WithSnapshotsOptions): SnapshotsStrategy;

package/dist/with-fork/snapshots/index.d.ts

@@ -1,5 +1,7 @@
 export { withSnapshots } from './active.js';
 export type { WithSnapshotsOptions } from './active.js';
-export type { SnapshotStrategy, SnapshotMeta, RetentionPolicy } from './strategy.js';
+export type { SnapshotsStrategy, SnapshotMeta, RetentionPolicy } from './strategy.js';
 export type { SnapshotPolicy, SnapshotMode } from './policy.js';
 export { SnapshotNotFoundError } from '../../kernel/errors.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_SNAPSHOTS } from './strategy.js';

package/dist/with-fork/snapshots/noydb-facade.d.ts

@@ -9,13 +9,13 @@
  *
  * Internal service — reached through `noydb.snapshot(...)` etc.
  */
-import { NO_SNAPSHOTS, type SnapshotStrategy, type SnapshotMeta } from './strategy.js';
+import { NO_SNAPSHOTS, type SnapshotsStrategy, type SnapshotMeta } from './strategy.js';
 import type { Vault } from '../../kernel/vault.js';
 import type { WriteHook, Unsubscribe } from '../../port/with/write-hooks.js';
 /** Everything the moving snapshot methods touched on the Noydb instance's `this.*`. */
 export interface NoydbSnapshotsDeps {
     /** Resolved snapshot strategy (NO_SNAPSHOTS when not configured). */
-    readonly strategy: SnapshotStrategy;
+    readonly strategy: SnapshotsStrategy;
     /** Acting user id, used as the snapshot `by`. */
     readonly user: string;
     /** Whether the owning instance has been closed. */
@@ -32,7 +32,7 @@ export declare class NoydbSnapshots {
     constructor(deps: NoydbSnapshotsDeps);
     /**
      * Take an on-demand checkpoint of the given vault.
-     * Requires `snapshotStrategy: withSnapshots({ store })` in `createNoydb`.
+     * Requires `snapshotsStrategy: withSnapshots({ store })` in `createNoydb`.
      * @throws ValidationError when the vault is not open
      */
     snapshot(vault: string, opts?: {

package/dist/with-fork/snapshots/strategy.d.ts

@@ -29,7 +29,7 @@ export interface SnapshotIndex {
     auto?: SnapshotMeta;
 }
 /** @internal */
-export interface SnapshotStrategy {
+export interface SnapshotsStrategy {
     snapshot(vault: unknown, by: string, opts?: {
         label?: string;
         note?: string;
@@ -45,4 +45,4 @@ export interface SnapshotStrategy {
     readonly policy?: SnapshotPolicy;
 }
 /** No-op stub. @internal */
-export declare const NO_SNAPSHOTS: SnapshotStrategy;
+export declare const NO_SNAPSHOTS: SnapshotsStrategy;

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

@@ -1,4 +1,4 @@
-import type { DerivationContext, DerivationStrategy } from './types.js';
+import type { DerivationContext, DerivationSpec } from './types.js';
 export interface RunResult {
     outputs: Record<string, OutputResult>;
     failed: boolean;
@@ -55,7 +55,7 @@ export declare const DerivationExecutor: {
      * `_derivedFrom` onto every output. Returns per-output success or
      * failure; throws only for shape mismatches (a contract violation).
      */
-    run<TSource extends Record<string, unknown>, TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>>(strategy: DerivationStrategy<TSource, TOutputs>, source: TSource & {
+    run<TSource extends Record<string, unknown>, TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>>(strategy: DerivationSpec<TSource, TOutputs>, source: TSource & {
         id: string;
     }, sourceVersion: number, strategyHash: string, ctx: DerivationContext): Promise<RunResult>;
 };

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

@@ -1,8 +1,9 @@
 export { withDerivation } from './with-derivation.js';
 export { withRollup } from './with-rollup.js';
+export type { WithRollupOptions } from './with-rollup.js';
 export { DerivationRegistry } from './registry.js';
 export { DerivationExecutor } from './executor.js';
-export type { DerivationStrategy, DerivationStrategyHandle, DerivedFromMeta, OutputSpec, RecordOutputSpec, ArrayOutputSpec, } from './types.js';
+export type { DerivationSpec, DerivationStrategy, DerivedFromMeta, OutputSpec, RecordOutputSpec, ArrayOutputSpec, } from './types.js';
 export { DerivationCycleError, DerivationDepthError, DerivationOutputUnknownError, DerivationOutputShapeError, DerivationCapExceededError, } from '../../kernel/errors.js';
 export type { DerivationContext } from './types.js';
 export type { RunResult } from './executor.js';

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

@@ -1,7 +1,7 @@
 import { ViaGraph, type FieldRef, type EdgeKind, type Grain } from '../../kernel/via/graph.js';
-import type { DerivationStrategy } from './types.js';
+import type { DerivationSpec } from './types.js';
 interface RegisteredStrategy {
-    spec: DerivationStrategy<any, any>;
+    spec: DerivationSpec<any, any>;
     strategyHash: string;
 }
 /**
@@ -13,7 +13,7 @@ interface RegisteredStrategy {
 export declare class DerivationRegistry {
     private readonly _bySource;
     private readonly _byOutput;
-    register(spec: DerivationStrategy<any, any>): Promise<void>;
+    register(spec: DerivationSpec<any, any>): Promise<void>;
     strategiesForSource(source: string): ReadonlyArray<RegisteredStrategy>;
     strategiesProducingOutput(collection: string): ReadonlyArray<RegisteredStrategy>;
     /**

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;