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

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-audit/periods/vault-facade.d.ts

@@ -28,6 +28,12 @@ export interface VaultPeriodsDeps {
     archiveRecords(before: string): Promise<number>;
     /** #615: sweep delete markers off the vault's push-only sync targets. Bound to `vault._purgePeriodTargets`. */
     purgeTargets(before: string): Promise<readonly TargetPurgeCount[]>;
+    /**
+     * #822: mark a reserved-collection write dirty so the sync engine pushes
+     * it. Bound to the vault's `onDirty` when sync is configured, `undefined`
+     * otherwise. Only `_periods` uses it — see `writeReserved`.
+     */
+    onDirty?: ((collection: string, id: string, action: 'put', version: number) => Promise<void>) | undefined;
 }
 export declare class VaultPeriods {
     private readonly deps;

package/dist/with-audit/portability/export-accessible.d.ts

@@ -7,7 +7,7 @@
  * Reuses the existing bundle machinery: the access boundary is the caller's DEK
  * set (operator/client → `keyring.permissions`; owner/admin/viewer → all), so a
  * record outside the caller's keys can never enter the bundle. Re-keying to a
- * new owner reuses `writePod`'s `exportPassphrase` shorthand.
+ * new owner reuses `writePod`'s `exportSecret` shorthand.
  */
 import type { Vault } from '../../kernel/vault.js';
 import type { UnlockedKeyring } from '../../with-party/team/keyring.js';
@@ -22,16 +22,16 @@ export declare function resolveAccessibleCollections(keyring: UnlockedKeyring, s
 } | undefined, writableOnly?: boolean): string[] | undefined;
 /** Produce a (optionally re-keyed, scoped) `.noydb` bundle — no audit. */
 export declare function buildAccessibleBundle(vault: Vault, collections: string[] | undefined, reKey: {
-    passphrase: string;
+    secret: string;
 } | undefined, compression?: 'auto' | 'brotli' | 'gzip' | 'none'): Promise<Uint8Array>;
 export interface ExportAccessibleOptions {
     /**
      * Re-key the bundle so it is independently openable by a new owner with this
-     * passphrase (the receiving firm / the client themselves). Omit to inherit
+     * secret (the receiving firm / the client themselves). Omit to inherit
      * the source keyring (personal backup).
      */
     readonly reKey?: {
-        readonly passphrase: string;
+        readonly secret: string;
     };
     /** Narrow the export to a subset of the caller's accessible collections. */
     readonly scope?: {

package/dist/with-audit/portability/request-withdrawal.d.ts

@@ -15,7 +15,7 @@
  * Requests live in the reserved `_user_withdrawal_requests` namespace. The
  * record body is plaintext metadata (collection names + disposition + legal
  * basis — none secret in this trust model; the owner sees the data anyway) and
- * carries NO passphrase: the re-key passphrase is supplied by the approver at
+ * carries NO secret: the re-key secret is supplied by the approver at
  * approval time and conveyed to the requester out-of-band, so no secret is
  * stored at rest.
  */
@@ -66,9 +66,9 @@ export declare function listWithdrawalRequests(vault: Vault, opts?: {
     status?: WithdrawalRequestStatus;
 }): Promise<WithdrawalRequest[]>;
 export interface ApproveWithdrawalOptions {
-    /** Re-key the handed-back bundle to a passphrase the requester will use. */
+    /** Re-key the handed-back bundle to a secret the requester will use. */
     readonly reKey?: {
-        readonly passphrase: string;
+        readonly secret: string;
     };
 }
 /**

package/dist/with-audit/portability/withdraw-accessible.d.ts

@@ -29,9 +29,9 @@ export interface FrozenSnapshotRef {
 export interface WithdrawAccessibleOptions {
     /** Legal/contractual basis recorded in the audit (e.g. 'gdpr-art-17'). */
     readonly legalBasis: string;
-    /** Re-key the exported bundle to a new owner passphrase. */
+    /** Re-key the exported bundle to a new owner secret. */
     readonly reKey?: {
-        readonly passphrase: string;
+        readonly secret: string;
     };
     /** Source disposition. Default 'delete'. */
     readonly disposition?: 'delete' | 'freeze';

package/dist/with-audit/sealed-record/strategy.d.ts

@@ -13,7 +13,7 @@
  * @internal
  */
 import type { SealingContext } from '../../kernel/enclave/index.js';
-import type { RecipientSealer } from '../../with-party/team/managed-passphrase.js';
+import type { RecipientSealer } from '../../with-party/team/managed-secret.js';
 export interface SealedRecordStrategy {
     sealRecordToHost(ctx: SealingContext, collection: string, id: string, hostSealer: RecipientSealer, opts: {
         expiresAt: string;

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

@@ -392,3 +392,4 @@ export declare function demote<T>(ctx: TiersContext<T>, id: string, toTier: numb
 export declare function classifySealedShred<T>(ctx: TiersContext<T>, live: EncryptedEnvelope): Promise<{
     readonly slots: readonly SealedShredSlot[];
 }>;
+export type { SealedShredSlot } from '../../kernel/enclave/index.js';

package/dist/with-cargo/adopt-partition.d.ts

@@ -9,7 +9,7 @@
  */
 import { type EnclaveKey } from '../kernel/enclave/index.js';
 import type { NoydbStore } from '../kernel/types.js';
-import type { SealingKeyProvider } from '../with-party/team/managed-passphrase.js';
+import type { SealingKeyProvider } from '../with-party/team/managed-secret.js';
 import type { ShamirRecoveryProvider } from '../with-party/team/shamir-recovery-provider.js';
 import type { RecoveryEnrollmentInput } from '../with-party/team/rotate-recover.js';
 import type { TransferSealPayload } from '../with-pod/bundle.js';
@@ -35,14 +35,14 @@ export interface CreateOwnerResult {
     readonly vaultName: string;
     readonly userId: string;
 }
-/** Standard-mode owner: recipient supplies the passphrase. */
+/** Standard-mode owner: recipient supplies the secret. */
 export interface CreateOwnerStandardOptions {
     readonly userId: string;
-    readonly passphrase: string;
+    readonly secret: string;
     readonly transferKey: Uint8Array;
 }
 /**
- * Managed-mode owner: the passphrase is minted + sealed under
+ * Managed-mode owner: the secret is minted + sealed under
  * a `SealingKeyProvider` (e.g. an `at-*` OS keychain) so the partition
  * auto-unlocks on the recipient's device. Managed mode mandates a strong
  * (Shamir) recovery profile at creation, which needs the
@@ -50,7 +50,7 @@ export interface CreateOwnerStandardOptions {
  */
 export interface CreateOwnerManagedOptions {
     readonly userId: string;
-    readonly passphraseMode: 'managed';
+    readonly secretMode: 'managed';
     readonly sealingKey: SealingKeyProvider;
     readonly recovery: ReadonlyArray<RecoveryEnrollmentInput>;
     readonly shamirRecovery: ShamirRecoveryProvider;
@@ -61,8 +61,8 @@ export type CreateOwnerOptions = CreateOwnerStandardOptions | CreateOwnerManaged
  * Mint the first owner keyring on an adopted-but-unowned partition,
  * then destroy the transfer seal.
  *
- * Standard mode: the recipient supplies a passphrase. Managed mode: the
- * passphrase is minted + sealed under a `SealingKeyProvider` and a strong
+ * Standard mode: the recipient supplies a secret. Managed mode: the
+ * secret is minted + sealed under a `SealingKeyProvider` and a strong
  * (Shamir) recovery profile is enrolled — orchestrated via the existing
  * `openVaultAndEnrollRecovery` ceremony.
  *

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,14 +12,14 @@
  *
  * @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';
@@ -32,8 +32,15 @@ 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>;
     /**