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

package/dist/{tx → transactions}/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/with-commit/tx/dry-run.ts","../../src/with-commit/tx/active.ts"],"sourcesContent":["/**\n * Dry-run transactions. Runs the tx body to STAGE ops, then builds\n * the directly-affected diff (before = current committed via collection.get,\n * after = staged record) and collects guard violations — without executing\n * phase 2. No adapter writes, no write-hooks, no commit. MV/derivation\n * cascade is NOT simulated (v2). Mirrors the guard loop in\n * `Collection._putInternal` — keep the two in sync.\n */\nimport type { Noydb } from '../../kernel/noydb.js'\nimport { TxContext, type StagedOp } from './transaction.js'\n\nimport { lazy } from '../../kernel/lazy.js'\n\n/** #846c — one memoized binding instead of a cast at the call site. */\nconst loadGuardExecutor = lazy(() => import('../../with-audit/guards/executor.js'))\n\nexport interface AffectedDocument {\n  readonly vault: string\n  readonly op: 'create' | 'update' | 'delete'\n  readonly collection: string\n  readonly docId: string\n  readonly before: unknown // current committed record; null when creating\n  readonly after: unknown // staged record; null when deleting\n}\n\nexport interface GuardViolation {\n  readonly vault: string\n  readonly collection: string\n  readonly docId: string\n  readonly message: string\n}\n\nexport interface DryRunResult {\n  readonly affected: ReadonlyArray<AffectedDocument>\n  readonly guardViolations: ReadonlyArray<GuardViolation>\n}\n\nconst SEP = ' '\nconst keyOf = (op: StagedOp) => `${op.vaultName}${SEP}${op.collectionName}${SEP}${op.id}`\n\nexport async function runDryRun(\n  db: Noydb,\n  fn: (tx: TxContext) => unknown,\n): Promise<DryRunResult> {\n  const ctx = new TxContext(db)\n  await fn(ctx) // stage ops (reads see staged writes via TxCollection); nothing committed\n\n  // Dedup by (vault, collection, id) — last staged op wins.\n  const lastOp = new Map<string, StagedOp>()\n  for (const op of ctx._ops) lastOp.set(keyOf(op), op)\n\n  const affected: AffectedDocument[] = []\n  const guardViolations: GuardViolation[] = []\n\n  for (const op of lastOp.values()) {\n    const v = db.vault(op.vaultName)\n    const coll = v.collection(op.collectionName)\n    const before = await coll.get(op.id)\n\n    if (op.type === 'delete') {\n      affected.push({ vault: op.vaultName, op: 'delete', collection: op.collectionName, docId: op.id, before, after: null })\n      continue\n    }\n\n    const after = op.record ?? null\n    affected.push({\n      vault: op.vaultName,\n      op: before === null ? 'create' : 'update',\n      collection: op.collectionName,\n      docId: op.id,\n      before,\n      after,\n    })\n\n    // Guard violations — run the SAME checks Collection._putInternal does,\n    // with the SAME ctx (existing + read-only facade + userId + role), but\n    // collect the first thrown error instead of aborting.\n    const registry = v._getGuardRegistry()\n    if (!registry) continue\n    const guards = registry.guardsFor(op.collectionName)\n    if (guards.length === 0) continue\n    const facade = v._getReadOnlyFacade()\n    if (!facade) continue\n    const gctx = { existing: before as Record<string, unknown> | null, vault: facade, userId: v.userId, role: v.role }\n    try {\n      await registry.runChecks(op.collectionName, after as Record<string, unknown>, gctx)\n      const { GuardExecutor } = await loadGuardExecutor()\n      for (const g of guards) {\n        await GuardExecutor.checkFrozenFields(g, op.id, before as Record<string, unknown> | null, after as Record<string, unknown>)\n      }\n    } catch (err) {\n      guardViolations.push({\n        vault: op.vaultName,\n        collection: op.collectionName,\n        docId: op.id,\n        message: err instanceof Error ? err.message : String(err),\n      })\n    }\n  }\n\n  return { affected, guardViolations }\n}\n","/**\n * Active transactions strategy. Only reachable via `@noy-db/hub/tx`.\n */\n\nimport { runTransaction } from './transaction.js'\nimport { runDryRun } from './dry-run.js'\nimport type { TxStrategy } from './strategy.js'\nimport type { TransactionInvariant } from './invariants.js'\n\n/**\n * Options for {@link withTransactions}. Currently only commit-time\n * changeset `invariants` (see {@link TransactionInvariant}).\n */\nexport interface TransactionStrategyOptions {\n  /**\n   * Commit-time set-level invariants run over the changeset on every\n   * commit (ordinary AND amendment). See {@link TransactionInvariant}.\n   */\n  invariants?: ReadonlyArray<TransactionInvariant>\n}\n\n/**\n * Build the default transactions strategy. Pass into\n * `createNoydb({ txStrategy: withTransactions() })` to enable\n * `db.transaction(fn)` (and `db.transaction({ dryRun: true }, fn)`).\n *\n * Supply `{ invariants }` to register commit-time changeset invariants —\n * set-level constraints that fire after the writes commit and revert the\n * transaction on a throw. Unlike `amendment.invariant`, these run for\n * ordinary `db.transaction(fn)` calls (and amendments) with no role gate.\n */\nexport function withTransactions(opts?: TransactionStrategyOptions): TxStrategy {\n  const invariants = opts?.invariants ?? []\n  return {\n    runTransaction: (db, fn, options) => runTransaction(db, fn, options, invariants),\n    runDryRun,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,IAAM,oBAAoB,KAAK,MAAM,OAAO,yBAAqC,CAAC;AAuBlF,IAAM,MAAM;AACZ,IAAM,QAAQ,CAAC,OAAiB,GAAG,GAAG,SAAS,GAAG,GAAG,GAAG,GAAG,cAAc,GAAG,GAAG,GAAG,GAAG,EAAE;AAEvF,eAAsB,UACpB,IACA,IACuB;AACvB,QAAM,MAAM,IAAI,UAAU,EAAE;AAC5B,QAAM,GAAG,GAAG;AAGZ,QAAM,SAAS,oBAAI,IAAsB;AACzC,aAAW,MAAM,IAAI,KAAM,QAAO,IAAI,MAAM,EAAE,GAAG,EAAE;AAEnD,QAAM,WAA+B,CAAC;AACtC,QAAM,kBAAoC,CAAC;AAE3C,aAAW,MAAM,OAAO,OAAO,GAAG;AAChC,UAAM,IAAI,GAAG,MAAM,GAAG,SAAS;AAC/B,UAAM,OAAO,EAAE,WAAW,GAAG,cAAc;AAC3C,UAAM,SAAS,MAAM,KAAK,IAAI,GAAG,EAAE;AAEnC,QAAI,GAAG,SAAS,UAAU;AACxB,eAAS,KAAK,EAAE,OAAO,GAAG,WAAW,IAAI,UAAU,YAAY,GAAG,gBAAgB,OAAO,GAAG,IAAI,QAAQ,OAAO,KAAK,CAAC;AACrH;AAAA,IACF;AAEA,UAAM,QAAQ,GAAG,UAAU;AAC3B,aAAS,KAAK;AAAA,MACZ,OAAO,GAAG;AAAA,MACV,IAAI,WAAW,OAAO,WAAW;AAAA,MACjC,YAAY,GAAG;AAAA,MACf,OAAO,GAAG;AAAA,MACV;AAAA,MACA;AAAA,IACF,CAAC;AAKD,UAAM,WAAW,EAAE,kBAAkB;AACrC,QAAI,CAAC,SAAU;AACf,UAAM,SAAS,SAAS,UAAU,GAAG,cAAc;AACnD,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,SAAS,EAAE,mBAAmB;AACpC,QAAI,CAAC,OAAQ;AACb,UAAM,OAAO,EAAE,UAAU,QAA0C,OAAO,QAAQ,QAAQ,EAAE,QAAQ,MAAM,EAAE,KAAK;AACjH,QAAI;AACF,YAAM,SAAS,UAAU,GAAG,gBAAgB,OAAkC,IAAI;AAClF,YAAM,EAAE,cAAc,IAAI,MAAM,kBAAkB;AAClD,iBAAW,KAAK,QAAQ;AACtB,cAAM,cAAc,kBAAkB,GAAG,GAAG,IAAI,QAA0C,KAAgC;AAAA,MAC5H;AAAA,IACF,SAAS,KAAK;AACZ,sBAAgB,KAAK;AAAA,QACnB,OAAO,GAAG;AAAA,QACV,YAAY,GAAG;AAAA,QACf,OAAO,GAAG;AAAA,QACV,SAAS,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAAA,MAC1D,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO,EAAE,UAAU,gBAAgB;AACrC;;;ACtEO,SAAS,iBAAiB,MAA+C;AAC9E,QAAM,aAAa,MAAM,cAAc,CAAC;AACxC,SAAO;AAAA,IACL,gBAAgB,CAAC,IAAI,IAAI,YAAY,eAAe,IAAI,IAAI,SAAS,UAAU;AAAA,IAC/E;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/with-commit/tx/dry-run.ts","../../src/with-commit/tx/active.ts"],"sourcesContent":["/**\n * Dry-run transactions. Runs the tx body to STAGE ops, then builds\n * the directly-affected diff (before = current committed via collection.get,\n * after = staged record) and collects guard violations — without executing\n * phase 2. No adapter writes, no write-hooks, no commit. MV/derivation\n * cascade is NOT simulated (v2). Mirrors the guard loop in\n * `Collection._putInternal` — keep the two in sync.\n */\nimport type { Noydb } from '../../kernel/noydb.js'\nimport { TxContext, type StagedOp } from './transaction.js'\n\nimport { lazy } from '../../kernel/lazy.js'\n\n/** #846c — one memoized binding instead of a cast at the call site. */\nconst loadGuardExecutor = lazy(() => import('../../with-audit/guards/executor.js'))\n\nexport interface AffectedDocument {\n  readonly vault: string\n  readonly op: 'create' | 'update' | 'delete'\n  readonly collection: string\n  readonly docId: string\n  readonly before: unknown // current committed record; null when creating\n  readonly after: unknown // staged record; null when deleting\n}\n\nexport interface GuardViolation {\n  readonly vault: string\n  readonly collection: string\n  readonly docId: string\n  readonly message: string\n}\n\nexport interface DryRunResult {\n  readonly affected: ReadonlyArray<AffectedDocument>\n  readonly guardViolations: ReadonlyArray<GuardViolation>\n}\n\nconst SEP = ' '\nconst keyOf = (op: StagedOp) => `${op.vaultName}${SEP}${op.collectionName}${SEP}${op.id}`\n\nexport async function runDryRun(\n  db: Noydb,\n  fn: (tx: TxContext) => unknown,\n): Promise<DryRunResult> {\n  const ctx = new TxContext(db)\n  await fn(ctx) // stage ops (reads see staged writes via TxCollection); nothing committed\n\n  // Dedup by (vault, collection, id) — last staged op wins.\n  const lastOp = new Map<string, StagedOp>()\n  for (const op of ctx._ops) lastOp.set(keyOf(op), op)\n\n  const affected: AffectedDocument[] = []\n  const guardViolations: GuardViolation[] = []\n\n  for (const op of lastOp.values()) {\n    const v = db.vault(op.vaultName)\n    const coll = v.collection(op.collectionName)\n    const before = await coll.get(op.id)\n\n    if (op.type === 'delete') {\n      affected.push({ vault: op.vaultName, op: 'delete', collection: op.collectionName, docId: op.id, before, after: null })\n      continue\n    }\n\n    const after = op.record ?? null\n    affected.push({\n      vault: op.vaultName,\n      op: before === null ? 'create' : 'update',\n      collection: op.collectionName,\n      docId: op.id,\n      before,\n      after,\n    })\n\n    // Guard violations — run the SAME checks Collection._putInternal does,\n    // with the SAME ctx (existing + read-only facade + userId + role), but\n    // collect the first thrown error instead of aborting.\n    const registry = v._getGuardRegistry()\n    if (!registry) continue\n    const guards = registry.guardsFor(op.collectionName)\n    if (guards.length === 0) continue\n    const facade = v._getReadOnlyFacade()\n    if (!facade) continue\n    const gctx = { existing: before as Record<string, unknown> | null, vault: facade, userId: v.userId, role: v.role }\n    try {\n      await registry.runChecks(op.collectionName, after as Record<string, unknown>, gctx)\n      const { GuardExecutor } = await loadGuardExecutor()\n      for (const g of guards) {\n        await GuardExecutor.checkFrozenFields(g, op.id, before as Record<string, unknown> | null, after as Record<string, unknown>)\n      }\n    } catch (err) {\n      guardViolations.push({\n        vault: op.vaultName,\n        collection: op.collectionName,\n        docId: op.id,\n        message: err instanceof Error ? err.message : String(err),\n      })\n    }\n  }\n\n  return { affected, guardViolations }\n}\n","/**\n * Active transactions strategy. Only reachable via `@noy-db/hub/transactions`.\n */\n\nimport { runTransaction } from './transaction.js'\nimport { runDryRun } from './dry-run.js'\nimport type { TransactionsStrategy } from './strategy.js'\nimport type { TransactionInvariant } from './invariants.js'\n\n/**\n * Options for {@link withTransactions}. Currently only commit-time\n * changeset `invariants` (see {@link TransactionInvariant}).\n */\nexport interface WithTransactionsOptions {\n  /**\n   * Commit-time set-level invariants run over the changeset on every\n   * commit (ordinary AND amendment). See {@link TransactionInvariant}.\n   */\n  invariants?: ReadonlyArray<TransactionInvariant>\n}\n\n/**\n * Build the default transactions strategy. Pass into\n * `createNoydb({ transactionsStrategy: withTransactions() })` to enable\n * `db.transaction(fn)` (and `db.transaction({ dryRun: true }, fn)`).\n *\n * Supply `{ invariants }` to register commit-time changeset invariants —\n * set-level constraints that fire after the writes commit and revert the\n * transaction on a throw. Unlike `amendment.invariant`, these run for\n * ordinary `db.transaction(fn)` calls (and amendments) with no role gate.\n */\nexport function withTransactions(opts?: WithTransactionsOptions): TransactionsStrategy {\n  const invariants = opts?.invariants ?? []\n  return {\n    runTransaction: (db, fn, options) => runTransaction(db, fn, options, invariants),\n    runDryRun,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,IAAM,oBAAoB,KAAK,MAAM,OAAO,yBAAqC,CAAC;AAuBlF,IAAM,MAAM;AACZ,IAAM,QAAQ,CAAC,OAAiB,GAAG,GAAG,SAAS,GAAG,GAAG,GAAG,GAAG,cAAc,GAAG,GAAG,GAAG,GAAG,EAAE;AAEvF,eAAsB,UACpB,IACA,IACuB;AACvB,QAAM,MAAM,IAAI,UAAU,EAAE;AAC5B,QAAM,GAAG,GAAG;AAGZ,QAAM,SAAS,oBAAI,IAAsB;AACzC,aAAW,MAAM,IAAI,KAAM,QAAO,IAAI,MAAM,EAAE,GAAG,EAAE;AAEnD,QAAM,WAA+B,CAAC;AACtC,QAAM,kBAAoC,CAAC;AAE3C,aAAW,MAAM,OAAO,OAAO,GAAG;AAChC,UAAM,IAAI,GAAG,MAAM,GAAG,SAAS;AAC/B,UAAM,OAAO,EAAE,WAAW,GAAG,cAAc;AAC3C,UAAM,SAAS,MAAM,KAAK,IAAI,GAAG,EAAE;AAEnC,QAAI,GAAG,SAAS,UAAU;AACxB,eAAS,KAAK,EAAE,OAAO,GAAG,WAAW,IAAI,UAAU,YAAY,GAAG,gBAAgB,OAAO,GAAG,IAAI,QAAQ,OAAO,KAAK,CAAC;AACrH;AAAA,IACF;AAEA,UAAM,QAAQ,GAAG,UAAU;AAC3B,aAAS,KAAK;AAAA,MACZ,OAAO,GAAG;AAAA,MACV,IAAI,WAAW,OAAO,WAAW;AAAA,MACjC,YAAY,GAAG;AAAA,MACf,OAAO,GAAG;AAAA,MACV;AAAA,MACA;AAAA,IACF,CAAC;AAKD,UAAM,WAAW,EAAE,kBAAkB;AACrC,QAAI,CAAC,SAAU;AACf,UAAM,SAAS,SAAS,UAAU,GAAG,cAAc;AACnD,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,SAAS,EAAE,mBAAmB;AACpC,QAAI,CAAC,OAAQ;AACb,UAAM,OAAO,EAAE,UAAU,QAA0C,OAAO,QAAQ,QAAQ,EAAE,QAAQ,MAAM,EAAE,KAAK;AACjH,QAAI;AACF,YAAM,SAAS,UAAU,GAAG,gBAAgB,OAAkC,IAAI;AAClF,YAAM,EAAE,cAAc,IAAI,MAAM,kBAAkB;AAClD,iBAAW,KAAK,QAAQ;AACtB,cAAM,cAAc,kBAAkB,GAAG,GAAG,IAAI,QAA0C,KAAgC;AAAA,MAC5H;AAAA,IACF,SAAS,KAAK;AACZ,sBAAgB,KAAK;AAAA,QACnB,OAAO,GAAG;AAAA,QACV,YAAY,GAAG;AAAA,QACf,OAAO,GAAG;AAAA,QACV,SAAS,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAAA,MAC1D,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO,EAAE,UAAU,gBAAgB;AACrC;;;ACtEO,SAAS,iBAAiB,MAAsD;AACrF,QAAM,aAAa,MAAM,cAAc,CAAC;AACxC,SAAO;AAAA,IACL,gBAAgB,CAAC,IAAI,IAAI,YAAY,eAAe,IAAI,IAAI,SAAS,UAAU;AAAA,IAC/E;AAAA,EACF;AACF;","names":[]}

package/dist/util/index.js

@@ -3,7 +3,7 @@ import {
 } from "../chunk-PY4KJPYU.js";
 import {
   FilenameSanitizationError
-} from "../chunk-6SYOHUHM.js";
+} from "../chunk-QZWTRENR.js";
 import "../chunk-PZ5AY32C.js";
 
 // src/kernel/util/sanitize-filename.ts

package/dist/{verify-5X37OXRY.js → verify-7XWHJWUN.js}

@@ -2,10 +2,10 @@ import {
   blindedEqual,
   evaluateKofN,
   openVdigPayload
-} from "./chunk-5WLDZZ6S.js";
+} from "./chunk-35NMVJ7I.js";
 import {
   dualReadSealedSlot
-} from "./chunk-5HSSTOOG.js";
+} from "./chunk-NFZGZ4AK.js";
 import {
   VDIG_ITERATIONS,
   normalizeForVerify,
@@ -14,11 +14,11 @@ import {
 import {
   base64ToBuffer,
   generateSalt
-} from "./chunk-7U6AB7DZ.js";
+} from "./chunk-AKKRXT23.js";
 import {
   ClassifiedConfigError,
   ClassifiedVerifyError
-} from "./chunk-6SYOHUHM.js";
+} from "./chunk-QZWTRENR.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/kernel/enclave/classify/verify.ts
@@ -137,4 +137,4 @@ export {
   verifyDigestField,
   verifyTextField
 };
-//# sourceMappingURL=verify-5X37OXRY.js.map
+//# sourceMappingURL=verify-7XWHJWUN.js.map

package/dist/via/blob/active.d.ts

@@ -1,16 +1,16 @@
 /**
  * Active blob strategy factory. Calling `blobs()` returns a
- * `BlobStrategy` whose `openSlot` constructs a real `BlobSet` bound
+ * `BlobsStrategy` whose `openSlot` constructs a real `BlobSet` bound
  * to the caller's record. The returned strategy is passed into
- * `createNoydb({ blobStrategy: blobs() })` to light up the
+ * `createNoydb({ blobsStrategy: blobs() })` to light up the
  * `collection.blob(id)` path.
  *
  * This module is only reachable through the `@noy-db/hub/blobs`
  * subpath — a consumer that never imports the subpath ships none of
  * this (ESM tree-shaking + hub's `"sideEffects": false`).
  */
-import type { BlobStrategy } from '../../port/with/blob-strategy.js';
-import type { BlobPinStore, BlobCacheStats } from '../../with-shape/blobs/blob-pinning.js';
+import type { BlobsStrategy } from '../../port/with/blob-strategy.js';
+import type { BlobPinStore } from '../../with-shape/blobs/blob-pinning.js';
 /** Options for {@link withBlobs} (#808). */
 export interface WithBlobsOptions {
     /**
@@ -23,18 +23,7 @@ export interface WithBlobsOptions {
     readonly pinStore?: BlobPinStore;
 }
 /**
- * The strategy `withBlobs()` returns — a `BlobStrategy` plus the device-local
- * blob-cache KPI surface (#808).
- */
-export interface BlobsService extends BlobStrategy {
-    /**
-     * Snapshot of this device's blob-cache KPI counters: local-read hits,
-     * network misses, and total bytes downloaded from the object store.
-     */
-    cacheStats(): BlobCacheStats;
-}
-/**
- * Build a default `BlobStrategy` ready to pass into `createNoydb`.
+ * Build a default `BlobsStrategy` ready to pass into `createNoydb`.
  *
  * Named `withBlobs` (plugin-pattern canonical) rather than `blobs` to
  * avoid shadowing the very common local idiom
@@ -50,7 +39,7 @@ export interface BlobsService extends BlobStrategy {
  *
  * const db = await createNoydb({
  *   store, user, secret,
- *   blobStrategy: withBlobs(),
+ *   blobsStrategy: withBlobs(),
  * })
  *
  * // Now live — delegates to BlobSet.
@@ -58,4 +47,4 @@ export interface BlobsService extends BlobStrategy {
  * await vault.collection('invoices').blob('inv-1').put('receipt.pdf', bytes)
  * ```
  */
-export declare function withBlobs(options?: WithBlobsOptions): BlobsService;
+export declare function withBlobs(options?: WithBlobsOptions): BlobsStrategy;

package/dist/via/blob/binding.d.ts

@@ -45,7 +45,7 @@ import type { BlobFieldsConfig } from '../../with-shape/blobs/blob-compaction.js
  * DELIBERATELY left unwired by `compileViaBindings` (#629 Task 10, resolved
  * within parity-first — see task-10-report.md "blob purge" section):
  * `per-blob-cek.test.ts`/`forget.test.ts` prove blob-shred-on-forget is
- * gated SOLELY on the vault's `blobStrategy` being configured, never on a
+ * gated SOLELY on the vault's `blobsStrategy` being configured, never on a
  * given collection's OWN `blobFields` declaration (`.blob(id)` is callable,
  * and IS exercised by those tests, on collections with no `blobFields` at
  * all). Routing it exclusively through this binding would silently stop

package/dist/via/blob/index.d.ts

@@ -19,8 +19,8 @@
  * code should prefer this subpath so the import boundary is explicit.
  */
 export { withBlobs } from './active.js';
-export type { WithBlobsOptions, BlobsService } from './active.js';
-export type { BlobStrategy, BlobStrategyOpenArgs } from '../../port/with/blob-strategy.js';
+export type { WithBlobsOptions } from './active.js';
+export type { BlobsStrategy, BlobsStrategyOpenArgs } from '../../port/with/blob-strategy.js';
 export { memoryBlobPinStore, blobPinKey } from '../../with-shape/blobs/blob-pinning.js';
 export type { BlobPinStore, BlobPinEntry, BlobCacheStats } from '../../with-shape/blobs/blob-pinning.js';
 export { BlobOfflineError } from '../../kernel/errors.js';

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/walk-6OHAWGBS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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-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/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,6 +1,6 @@
 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). */

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