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

package/dist/{legacy/kernel.d.ts → with-cargo/floor.d.ts}

@@ -2,7 +2,7 @@
  * The `@noy-db/hub/kernel` published subpath has been retired (coordinated
  * removal; consumers migrated to `@noy-db/hub/cargo`). This file survives
  * unpublished as `/cargo`'s internal re-export floor — `with-cargo/index.ts`
- * does `export * from '../legacy/kernel.js'` to consolidate this runtime-helper
+ * does `export * from './floor.js'` to consolidate this runtime-helper
  * / error-class / type surface into the cargo seam, and
  * `cargo-surface-golden.test.ts` reads this file directly as part of that
  * union. Do not reintroduce it as a tsup entry or package.json export.
@@ -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-cargo/index.d.ts

@@ -12,22 +12,35 @@
  *
  * @packageDocumentation
  */
-export * from '../legacy/kernel.js';
+export * from './floor.js';
 export { CustodyApi } from '../with-party/custody/index.js';
 export type { GrantCustodianOptions } from '../with-party/custody/index.js';
 export { liberateVault } from '../with-party/custody/liberate.js';
 export type { LiberateOptions, LiberateResult } from '../with-party/custody/liberate.js';
 export { createDeedOwner, loadDeedMarker, isDeedVault } from '../with-party/team/deed.js';
 export type { DeedMarker } from '../with-party/team/deed.js';
-export type { SealingKeyProvider } from '../with-party/team/managed-passphrase.js';
+export type { SealingKeyProvider } from '../with-party/team/managed-secret.js';
 export { diffVault } from './vault-diff.js';
 export { STATE_VAULT_NAME } from '../kernel/constants.js';
 export { withCargo } from './active.js';
 export { NO_CARGO } from './strategy.js';
 export type { CargoStrategy } from './strategy.js';
 export { CargoNotEnabledError } from '../kernel/errors.js';
+export { extractPartition } from './extract-partition.js';
+export { walkClosure } from './walk-closure.js';
+export { describeExtraction } from './describe-extraction.js';
+export { decryptExtractedPartition } from './decrypt-partition.js';
+export type { ExtractionPreview } from './describe-extraction.js';
+export type { DecryptedRecord } from './decrypt-partition.js';
+export type { WalkClosureOptions, ClosureResult, DanglingRefNotice } from './walk-closure.js';
+export type { ExtractPartitionResult } from './extract-partition.js';
+export { adoptPartition, unsealDeks, createOwnerOnAdoptedPartition } from './adopt-partition.js';
+export type { AdoptPartitionOptions, AdoptPartitionResult, CreateOwnerResult, CreateOwnerOptions, CreateOwnerStandardOptions, CreateOwnerManagedOptions, } from './adopt-partition.js';
+export { TransferSealError, AdoptionStateError, PartitionExtractionError } from '../kernel/errors.js';
 export type { WriteHook } from '../port/with/write-hooks.js';
 export type { WriteQueue } from '../kernel/write-queue.js';
 export type { WriteConflict } from '../kernel/types.js';
 export type { AccessibleVault } from '../kernel/types.js';
 export type { Unsubscribe } from '../kernel/types.js';
+export type { ExtractPartitionOptions } from './extract-partition.js';
+export type { TransferSealPayload } from '../with-pod/bundle.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/history/time-machine.d.ts

@@ -5,7 +5,7 @@
  * ## Usage
  *
  * ```ts
- * const vault = await db.openVault('acme', { passphrase })
+ * const vault = await db.openVault('acme', { secret })
  * const q1End = vault.at('2026-03-31T23:59:59Z')
  * const invoice = await q1End.collection<Invoice>('invoices').get('inv-001')
  * // → the record as it stood at the close of Q1 2026
@@ -64,7 +64,7 @@ export interface VaultEngine {
     /** Vault name (the compartment). */
     readonly name: string;
     /**
-     * `true` when the vault was opened with a passphrase (the normal
+     * `true` when the vault was opened with a secret (the normal
      * case). `false` in plaintext-mode vaults (`encrypt: false`) — in
      * that case `envelope._data` is raw JSON and we skip the DEK lookup.
      */

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/dispatch.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Derivation dispatch, lifted out of the kernel spine (#842 part b).
+ *
+ * `Collection` carried ~380 lines of dispatch logic that belongs to the
+ * derivation service, not to the always-on kernel. These are free functions
+ * taking an explicit context so the spine keeps only a thin delegator.
+ *
+ * ## How the spine reaches this module
+ *
+ * By dynamic `import()`, never a static one. `check-architecture.mjs`'s
+ * `port-layering` check forbids the spine from statically importing a
+ * `with-*` service; `collection.ts` is grandfathered for ten
+ * `with-formula/*` specifiers, but that list is frozen per file and a new
+ * one is a violation. A dynamic import is the sanctioned S4 gate recipe, and
+ * it keeps this chunk out of the floor bundle for consumers who never fire a
+ * derivation.
+ *
+ * The `Collection` type reference below points back at the spine. That is
+ * inward (service → kernel) and so allowed, and it is TYPE-ONLY — erased at
+ * build, so no runtime cycle exists.
+ *
+ * @internal
+ */
+import type { NoydbStore } from '../../kernel/types.js';
+import type { TxContext } from '../../with-commit/tx/transaction.js';
+import type { DerivationRegistry } from './registry.js';
+import type { ReadOnlyVaultFacade } from '../../with-audit/guards/types.js';
+import type { Collection } from '../../kernel/collection.js';
+import type { EnclaveKey } from '../../kernel/enclave/index.js';
+import type { EncryptedEnvelope } from '../../kernel/types.js';
+import type { ledgerAuditHook, WaveContext } from '../../kernel/via/dispatch.js';
+/** The per-write dispatch context threaded into `putDerivedOutput`. */
+interface DispatchCtx {
+    emit: (e: string, p: unknown) => void;
+    source: {
+        readonly collection: string;
+        readonly id: string;
+    };
+    audit: ReturnType<typeof ledgerAuditHook>;
+}
+/**
+ * What the dispatchers need from the collection that owns them. Passing this
+ * explicitly is what lets the logic live outside the class.
+ */
+export interface DerivationDeleteCtx {
+    readonly derivationSource: {
+        registry(): DerivationRegistry;
+        getCollection(name: string): Collection<Record<string, unknown>>;
+        getActiveTxContext(): TxContext | null;
+        getReadOnlyFacade(): ReadOnlyVaultFacade;
+    };
+    /** The collection the delete happened in. */
+    readonly collectionName: string;
+    readonly adapter: NoydbStore;
+    readonly vault: string;
+    readonly getDEK: (collectionName: string) => Promise<EnclaveKey>;
+    readonly storeCiphertext: boolean;
+}
+/**
+ * Erase the derived rows a deleted source record fanned out to, and drop the
+ * fan-out sidecars that recorded them.
+ *
+ * @param eraseRecordShapeToo also erase same-id `shape: 'record'` outputs.
+ *   Restricted to a source-triggered strategy writing into a DIFFERENT
+ *   collection — the self-denorm case would re-delete the record just
+ *   tombstoned, and triggerBy/sibling strategies derive under a different id.
+ * @returns rows ACTUALLY deleted, not edges visited (#622).
+ */
+export declare function dispatchArrayDerivationsOnDelete(ctx: DerivationDeleteCtx, id: string, eraseRecordShapeToo?: boolean): Promise<number>;
+/** Adds what the on-write derivation dispatch needs beyond the delete path. */
+export interface DerivationDispatchCtx extends DerivationDeleteCtx {
+    /** Via pipeline, for decoding the stored form back to canonical money shape. */
+    readonly via: {
+        canonicalizeStored(r: Record<string, unknown>): Record<string, unknown>;
+    } | undefined;
+    /** Recompute a rollup aggregate onto a parent. Stays on the spine — it walks collections. */
+    readonly recomputeRollup: (spec: any, parentId: string, source: {
+        readonly collection: string;
+        readonly id: string;
+    }, wave?: WaveContext) => Promise<unknown>;
+    /** Builds the per-write dispatch context threaded into `putDerivedOutput`. */
+    readonly dispatchCtx: (source: {
+        readonly collection: string;
+        readonly id: string;
+    }) => DispatchCtx;
+    /** Registers a write on the active transaction for rollback. */
+    readonly trackPut: (txCtx: TxContext, collectionName: string, id: string, priorEnvelope: EncryptedEnvelope | null) => void;
+}
+/**
+ * Fire registered derivation strategies for this source collection.
+ *
+ * Eager mode runs `derive` inline and writes each output; lazy mode records a
+ * stale mark for cold-session recompute. Rollups are handled here rather than
+ * by the executor — a write to the child recomputes the parent aggregate, and
+ * a write to the parent recomputes its own.
+ */
+export declare function dispatchDerivations(ctx: DerivationDispatchCtx, id: string, record: Record<string, unknown>, version: number, wave?: WaveContext): Promise<void>;
+export {};

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,6 +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;

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';