@noy-db/hub 0.2.0-pre.10 → 0.2.0-pre.12

package/dist/{chunk-4USCAEDT.js → chunk-TMHJEYW7.js}

@@ -4,37 +4,37 @@ import {
 import {
   TxContext,
   revertExecuted
-} from "./chunk-26NK23DZ.js";
+} from "./chunk-M45IRXDM.js";
 import {
   OverlayedCollection
-} from "./chunk-7CEGU63S.js";
+} from "./chunk-4BHFNKTP.js";
 import {
   LazyQuery,
   decodeIdxId,
   encodeIdxId
-} from "./chunk-QSOYKKMD.js";
+} from "./chunk-P4EDT5ZP.js";
 import {
   SCHEMAS_COLLECTION,
   loadPersistedSchema,
   resolveManagedSecret,
   savePersistedSchema,
   saveSealedPassphrase
-} from "./chunk-PM3QYWUU.js";
+} from "./chunk-XHM2SARW.js";
 import {
   loadPublicEnvelope,
   readPublicEnvelope,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-2N62W5YP.js";
+} from "./chunk-UA6G45ME.js";
 import {
   PERIODS_COLLECTION
-} from "./chunk-3LPV6BXR.js";
+} from "./chunk-RRDWXNBQ.js";
 import {
   getAtPath,
   isDictCollectionName,
   resolvePolicy,
   setAtPathInPlace
-} from "./chunk-GNHAC43Q.js";
+} from "./chunk-O53RIZCC.js";
 import {
   ManagedRecoveryNotEnrolledError,
   PolicyDeniedError,
@@ -56,13 +56,14 @@ import {
   saveShamirRecoveryEntries,
   updateAuthenticator,
   writeMagicLinkGrant
-} from "./chunk-PXTQPZO4.js";
+} from "./chunk-DLTU4M2I.js";
 import {
   assertTierAccess,
   dekKey
-} from "./chunk-CXFOITNS.js";
+} from "./chunk-ZC7MNVYN.js";
 import {
   USER_ENVELOPE_COLLECTION,
+  assertKeyringOpenAllowed,
   buildRecipientKeyringFile,
   changeSecret,
   createOwnerKeyring,
@@ -84,7 +85,7 @@ import {
   rotateKeys,
   saveUserEnvelope,
   updateKeyringIdentity
-} from "./chunk-HQSQC2XL.js";
+} from "./chunk-GFPR7VJS.js";
 import {
   INDEXED_STORE_POLICY
 } from "./chunk-2QR2PQTT.js";
@@ -94,7 +95,7 @@ import {
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
-} from "./chunk-4CLICFEY.js";
+} from "./chunk-SJJQKNMP.js";
 import {
   sha256Hex as sha256Hex2
 } from "./chunk-Z6FNBOTC.js";
@@ -102,10 +103,13 @@ import {
   NO_AGGREGATE,
   Query,
   ScanBuilder
-} from "./chunk-6YLPHBKR.js";
+} from "./chunk-UOC7JMZO.js";
 import {
-  canonicalGroupKey
-} from "./chunk-2LPPNWF6.js";
+  MoneyPrecisionError,
+  canonicalGroupKey,
+  formatScaledInt,
+  parseToScaledInt
+} from "./chunk-OPDTLHFA.js";
 import {
   readPath
 } from "./chunk-TV3YZ35S.js";
@@ -113,17 +117,17 @@ import {
   EXPORT_AUDIT_COLLECTION,
   createExportBlobsHandle,
   runCompaction
-} from "./chunk-DRXIZOFV.js";
+} from "./chunk-6AD5TBF2.js";
 import {
   NOYDB_BACKUP_VERSION,
   NOYDB_FORMAT_VERSION
-} from "./chunk-WIRRPTFH.js";
+} from "./chunk-LYNNZEQD.js";
 import {
   decrypt,
   encrypt,
   encryptDeterministic,
   sha256Hex
-} from "./chunk-R233SLY3.js";
+} from "./chunk-IUBHXEPJ.js";
 import {
   AlreadyElevatedError,
   AttestationError,
@@ -146,14 +150,17 @@ import {
   ReservedCollectionNameError,
   SchemaFenceError,
   SchemaValidationError,
+  SequenceContentionError,
+  SequenceOfflineError,
   StoreCapabilityError,
   TierDemoteDeniedError,
   TierNotGrantedError,
   TranslatorNotConfiguredError,
   UniqueConstraintError,
   UnsupportedIndexOptionError,
-  ValidationError
-} from "./chunk-O6EJ6WTI.js";
+  ValidationError,
+  VaultTemplateNotFoundError
+} from "./chunk-AGRC7NQQ.js";
 
 // src/policy/storage.ts
 var META_COLLECTION = "_meta";
@@ -328,6 +335,116 @@ var NO_CRDT = {
   }
 };
 
+// src/money/normalize.ts
+function isMoneyValueObject(v) {
+  return typeof v === "object" && v !== null && "currency" in v;
+}
+function quantizeAmount(field, input, scale, rounding) {
+  const r = parseToScaledInt(input, scale, rounding);
+  if (!r.ok) {
+    if (r.reason === "precision") throw new MoneyPrecisionError(field, input, scale);
+    throw new TypeError(`money: field "${field}" value ${JSON.stringify(input)} is not a finite decimal`);
+  }
+  return r.value.toString();
+}
+function quantizeMoneyFields(record, moneyFields) {
+  const out = { ...record };
+  for (const [field, desc] of Object.entries(moneyFields)) {
+    const raw = out[field];
+    if (raw === null || raw === void 0) continue;
+    if (desc.mode === "fixed") {
+      const currency2 = desc.fixedCurrency;
+      out[field] = quantizeAmount(field, raw, desc.scaleFor(currency2), desc.rounding);
+      continue;
+    }
+    let amount;
+    let currency;
+    if (isMoneyValueObject(raw)) {
+      currency = String(raw.currency);
+      amount = raw.amount;
+    } else {
+      const sole = desc.soleCurrency();
+      if (sole === void 0) {
+        throw new TypeError(
+          `money: field "${field}" is multi-currency \u2014 write { amount, currency }, not a bare amount`
+        );
+      }
+      currency = sole;
+      amount = raw;
+    }
+    const scale = desc.scaleFor(currency);
+    out[field] = { amount: quantizeAmount(field, amount, scale, desc.rounding), currency };
+  }
+  return out;
+}
+function formatCurrency(decimal, currency, scale, locale) {
+  const fmt = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: scale,
+    maximumFractionDigits: scale
+  });
+  return fmt.format(decimal);
+}
+function decodeMoneyFields(record, moneyFields, locale) {
+  const out = { ...record };
+  const format = locale !== "raw";
+  const fmtLocale = typeof locale === "string" && locale !== "raw" ? locale : "en-US";
+  for (const [field, desc] of Object.entries(moneyFields)) {
+    const stored = out[field];
+    if (stored === null || stored === void 0) continue;
+    let currency;
+    let scaledIntString;
+    if (desc.mode === "fixed") {
+      if (typeof stored !== "string" && typeof stored !== "number") continue;
+      currency = desc.fixedCurrency;
+      scaledIntString = String(stored);
+    } else {
+      if (!isMoneyValueObject(stored)) continue;
+      const amount = stored.amount;
+      if (typeof stored.currency !== "string" || typeof amount !== "string" && typeof amount !== "number") continue;
+      currency = stored.currency;
+      scaledIntString = String(amount);
+    }
+    const scale = desc.scaleFor(currency);
+    const decimal = formatScaledInt(BigInt(scaledIntString), scale);
+    out[field] = desc.mode === "fixed" ? decimal : { amount: decimal, currency };
+    if (format) {
+      out[`${field}Formatted`] = formatCurrency(decimal, currency, scale, fmtLocale);
+      out[`${field}Number`] = Number(decimal);
+    }
+  }
+  return out;
+}
+
+// src/computed/index.ts
+var ComputedFieldError = class extends NoydbError {
+  constructor(field, id, cause) {
+    super(
+      "COMPUTED_FIELD",
+      `computed field "${field}" threw for record "${id}": ` + (cause instanceof Error ? cause.message : String(cause))
+    );
+    this.field = field;
+    this.id = id;
+    this.cause = cause;
+    this.name = "ComputedFieldError";
+  }
+  field;
+  id;
+  cause;
+};
+function evalComputedFields(record, computed, id) {
+  const out = { ...record };
+  for (const [field, fn] of Object.entries(computed)) {
+    try {
+      out[field] = fn(out);
+    } catch (cause) {
+      throw new ComputedFieldError(field, id, cause);
+    }
+  }
+  return out;
+}
+
 // src/i18n/strategy.ts
 function notEnabled(op) {
   return new Error(
@@ -768,7 +885,7 @@ async function resolveStaleOnRead(accessor, outputCollection, id) {
     }
     const sourceWithId = { ...source, id };
     if (DerivationExecutor === null) {
-      ({ DerivationExecutor } = await import("./executor-S76VN45G.js"));
+      ({ DerivationExecutor } = await import("./executor-D2QMNGRJ.js"));
     }
     const ctx = { vault: accessor.getReadOnlyFacade() };
     const result = await DerivationExecutor.run(spec, sourceWithId, 0, strategyHash, ctx);
@@ -961,6 +1078,18 @@ var Collection = class {
    * fields when a locale is requested.
    */
   dictKeyFields;
+  /**
+   * Money field descriptors keyed by field path. Declared via the
+   * `moneyFields` collection option: `put()` quantizes to a scaled-int
+   * string, `get()`/`list()` decode back. Mutable so {@link _applyMoneyFields}
+   * can attach descriptors to a collection MV-analysis pre-created.
+   */
+  moneyFields;
+  /**
+   * Computed scalar fields, evaluated first on every `put()`. Mutable for
+   * the same MV-pre-creation reconcile as {@link moneyFields}.
+   */
+  computed;
   /**
    * Async callback provided by the Vault that resolves a dict key
    * to its label for a given locale. Used by the locale-read path for
@@ -1102,6 +1231,8 @@ var Collection = class {
     this.joinResolver = opts.joinResolver;
     this.i18nFields = opts.i18nFields;
     this.dictKeyFields = opts.dictKeyFields;
+    this.moneyFields = opts.moneyFields;
+    this.computed = opts.computed;
     this.dictLabelResolver = opts.dictLabelResolver;
     this.i18nPutValidator = opts.i18nPutValidator;
     this.autoTranslateHook = opts.autoTranslateHook;
@@ -1226,6 +1357,19 @@ var Collection = class {
   getSchema() {
     return this.schema;
   }
+  /**
+   * @internal — attach money descriptors post-construction. MV dependency
+   * analysis auto-creates a source collection (without options) during
+   * `openVault`, before the user's `collection(name, { moneyFields })`
+   * declaration; this reconciles that ordering. First-wins. Not public.
+   */
+  _applyMoneyFields(moneyFields) {
+    if (this.moneyFields === void 0) this.moneyFields = moneyFields;
+  }
+  /** @internal — attach computed fields post-construction. See {@link _applyMoneyFields}. */
+  _applyComputed(computed) {
+    if (this.computed === void 0) this.computed = computed;
+  }
   /**
    * Get a single record by ID.
    *
@@ -1247,7 +1391,7 @@ var Collection = class {
       }
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-VKXSXJF4.js");
+      const { resolveStaleMVOnRead } = await import("./stale-UBLP3RJ3.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name);
     }
     let record;
@@ -1397,7 +1541,7 @@ var Collection = class {
           existingRecord = null;
         }
       }
-      await this.subsystemBus.dispatchGate("beforePut", {
+      const gateEvent = {
         op: existingEnv ? "update" : "create",
         vault: this.vault,
         collection: this.name,
@@ -1407,12 +1551,20 @@ var Collection = class {
         existingVersion: existingEnv?._v ?? 0,
         existingTs: existingEnv?._ts,
         userId: this.keyring.userId,
-        role: this.keyring.role
-      });
+        role: this.keyring.role,
+        ...this.computed !== void 0 ? { computedFieldNames: new Set(Object.keys(this.computed)) } : {}
+      };
+      await this.subsystemBus.dispatchGate("beforePut", gateEvent);
+    }
+    if (this.computed !== void 0) {
+      record = evalComputedFields(record, this.computed, id);
     }
     if (this.schema !== void 0) {
       record = await validateSchemaInput(this.schema, record, `put(${id})`);
     }
+    if (this.moneyFields) {
+      record = quantizeMoneyFields(record, this.moneyFields);
+    }
     if (this.i18nFields) {
       const obj = record;
       for (const [field, descriptor] of Object.entries(this.i18nFields)) {
@@ -1636,7 +1788,7 @@ var Collection = class {
       if (mode === "eager") {
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-UCXLIGLW.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-O5AZK7UW.js"));
         }
         await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
@@ -1645,7 +1797,7 @@ var Collection = class {
         });
       } else if (mode === "lazy") {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-VKXSXJF4.js");
+          staleHelpers = await import("./stale-UBLP3RJ3.js");
         }
         staleHelpers.markMVStale(registry, reg.spec.name);
       }
@@ -1674,7 +1826,7 @@ var Collection = class {
       const mode = typeof spec.lifecycle === "string" ? spec.lifecycle : spec.lifecycle.mode;
       if (mode === "eager") {
         if (DerivationExecutor === null) {
-          ({ DerivationExecutor } = await import("./executor-S76VN45G.js"));
+          ({ DerivationExecutor } = await import("./executor-D2QMNGRJ.js"));
         }
         const sourceWithId = { ...incoming, id };
         const ctx = { vault: this.derivationSource.getReadOnlyFacade() };
@@ -1693,7 +1845,7 @@ var Collection = class {
           const outputCollection = this.derivationSource.getCollection(outSpec.collection);
           const txCtx = this.derivationSource.getActiveTxContext();
           if (out.kind === "array") {
-            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-OKPMMPLG.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-ZSKEQ6NI.js");
             const prior = await loadFanoutSidecar(
               this.adapter,
               this.vault,
@@ -1986,7 +2138,7 @@ var Collection = class {
       for (const [outputKey, outSpec] of Object.entries(spec.outputs)) {
         if (outSpec.shape !== "array") continue;
         if (helpers === null) {
-          helpers = await import("./fanout-sidecar-OKPMMPLG.js");
+          helpers = await import("./fanout-sidecar-ZSKEQ6NI.js");
         }
         const sidecar = await helpers.loadFanoutSidecar(
           this.adapter,
@@ -2026,7 +2178,7 @@ var Collection = class {
       if (mode === "eager") {
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-UCXLIGLW.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-O5AZK7UW.js"));
         }
         await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
@@ -2035,7 +2187,7 @@ var Collection = class {
         });
       } else if (mode === "lazy") {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-VKXSXJF4.js");
+          staleHelpers = await import("./stale-UBLP3RJ3.js");
         }
         staleHelpers.markMVStale(registry, reg.spec.name);
       }
@@ -2058,7 +2210,7 @@ var Collection = class {
       );
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-VKXSXJF4.js");
+      const { resolveStaleMVOnRead } = await import("./stale-UBLP3RJ3.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name);
     }
     await this.ensureHydrated();
@@ -2234,7 +2386,8 @@ var Collection = class {
       // fields. The Query builder consults these when present and falls
       // back to a linear scan otherwise.
       getIndexes: () => this.getIndexes(),
-      lookupById: (id) => this.cache.get(id)?.record
+      lookupById: (id) => this.cache.get(id)?.record,
+      ...this.moneyFields ? { moneyFields: this.moneyFields } : {}
     };
     const resolver = this.joinResolver;
     const leftCollection = this.name;
@@ -2916,10 +3069,14 @@ var Collection = class {
   async applyLocaleToRecord(record, localeOpts) {
     const hasI18n = this.i18nFields && Object.keys(this.i18nFields).length > 0;
     const hasDict = this.dictKeyFields && Object.keys(this.dictKeyFields).length > 0;
-    if (!hasI18n && !hasDict) return record;
+    const hasMoney = this.moneyFields && Object.keys(this.moneyFields).length > 0;
+    if (!hasI18n && !hasDict && !hasMoney) return record;
     const locale = localeOpts?.locale ?? this.defaultLocale;
-    if (!locale) return record;
     let result = record;
+    if (hasMoney && this.moneyFields) {
+      result = decodeMoneyFields(result, this.moneyFields, typeof locale === "string" ? locale : void 0);
+    }
+    if (!locale) return result;
     if (hasI18n && this.i18nFields) {
       result = this.i18nStrategy.applyI18nLocale(result, this.i18nFields, locale, localeOpts?.fallback);
     }
@@ -3615,6 +3772,165 @@ function valuesMatch(stored, live) {
   }
 }
 
+// src/archive/engine.ts
+function isHeld(policy, record) {
+  if (!policy.legalHold) return false;
+  try {
+    return policy.legalHold(record);
+  } catch {
+    return true;
+  }
+}
+async function runArchive(ctx, options = {}) {
+  const maxArchives = options.maxArchives ?? Infinity;
+  const dryRun = options.dryRun === true;
+  let archived = 0;
+  let held = 0;
+  let scanned = 0;
+  const byCollection = {};
+  outer: for (const collection of ctx.collectionsWithPolicy()) {
+    const policy = ctx.getPolicy(collection);
+    if (!policy) continue;
+    byCollection[collection] = { archived: 0, held: 0 };
+    for (const id of await ctx.listRecordIds(collection)) {
+      if (archived >= maxArchives) break outer;
+      const record = await ctx.getRecord(collection, id).catch(() => null);
+      if (record === null) continue;
+      scanned += 1;
+      let eligible = false;
+      try {
+        eligible = policy.archiveWhen(record);
+      } catch {
+        eligible = false;
+      }
+      if (!eligible) continue;
+      if (isHeld(policy, record)) {
+        held += 1;
+        byCollection[collection].held += 1;
+        continue;
+      }
+      if (!dryRun) {
+        const env = await ctx.getEnvelope(collection, id);
+        if (!env) continue;
+        await ctx.archiveStore.put(ctx.vaultId, collection, id, env);
+        await ctx.removeFromPrimary(collection, id);
+      }
+      archived += 1;
+      byCollection[collection].archived += 1;
+    }
+  }
+  return { archived, held, scanned, byCollection };
+}
+async function runRestore(ctx, collection, id) {
+  const env = await ctx.archiveStore.get(ctx.vaultId, collection, id);
+  if (!env) return false;
+  await ctx.restoreToPrimary(collection, id, env);
+  await ctx.archiveStore.delete(ctx.vaultId, collection, id);
+  return true;
+}
+async function runListArchived(ctx, collection) {
+  const collections = collection ? [collection] : ctx.collectionsWithPolicy();
+  const out = [];
+  for (const c of collections) {
+    const ids = await ctx.archiveStore.list(ctx.vaultId, c);
+    for (const id of ids) out.push({ collection: c, id });
+  }
+  return out;
+}
+
+// src/archive/index.ts
+function withArchive(opts) {
+  return { store: opts.store };
+}
+
+// src/sequence/index.ts
+var SEQUENCE_COLLECTION = "_sequences";
+var MAX_NEXT_ATTEMPTS = 16;
+async function sleepBackoff(attempt) {
+  const ceil = Math.min(2 ** attempt, 32);
+  const ms = Math.floor(Math.random() * ceil);
+  await new Promise((r) => setTimeout(r, ms));
+}
+var SequenceStore = class {
+  adapter;
+  vault;
+  encrypted;
+  getDEK;
+  actor;
+  /**
+   * Memoized DEK promise. The `_sequences` collection DEK is created on
+   * first access; without sharing one promise, a burst of concurrent
+   * `next()` calls would each trigger DEK creation and diverge (one
+   * writer's ciphertext unreadable by another). One shared promise → one
+   * DEK.
+   */
+  dekPromise = null;
+  constructor(opts) {
+    this.adapter = opts.adapter;
+    this.vault = opts.vault;
+    this.encrypted = opts.encrypted;
+    this.getDEK = opts.getDEK;
+    this.actor = opts.actor;
+  }
+  /** A handle bound to one sequence name. */
+  handle(name) {
+    return {
+      next: () => this.next(name),
+      peek: () => this.peek(name)
+    };
+  }
+  assertOnline() {
+    if (this.adapter.capabilities?.casAtomic !== true) {
+      throw new SequenceOfflineError();
+    }
+  }
+  dek() {
+    if (!this.dekPromise) this.dekPromise = this.getDEK(SEQUENCE_COLLECTION);
+    return this.dekPromise;
+  }
+  async read(name) {
+    const env = await this.adapter.get(this.vault, SEQUENCE_COLLECTION, name);
+    if (!env) return { env: null, value: 0 };
+    const json = this.encrypted ? await decrypt(env._iv, env._data, await this.dek()) : env._data;
+    const state = JSON.parse(json);
+    return { env, value: state.value };
+  }
+  async encryptState(state, version) {
+    const json = JSON.stringify(state);
+    if (!this.encrypted) {
+      return { _noydb: NOYDB_FORMAT_VERSION, _v: version, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: "", _data: json, _by: this.actor };
+    }
+    const { iv, data } = await encrypt(json, await this.dek());
+    return { _noydb: NOYDB_FORMAT_VERSION, _v: version, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: iv, _data: data, _by: this.actor };
+  }
+  async peek(name) {
+    return (await this.read(name)).value;
+  }
+  async next(name) {
+    this.assertOnline();
+    let lastConflict;
+    for (let attempt = 0; attempt < MAX_NEXT_ATTEMPTS; attempt++) {
+      const { env, value } = await this.read(name);
+      const nextValue = value + 1;
+      const expectedVersion = env?._v ?? 0;
+      const envelope = await this.encryptState({ value: nextValue }, expectedVersion + 1);
+      try {
+        await this.adapter.put(this.vault, SEQUENCE_COLLECTION, name, envelope, expectedVersion);
+        return nextValue;
+      } catch (err) {
+        if (err instanceof ConflictError) {
+          lastConflict = err;
+          if (attempt < MAX_NEXT_ATTEMPTS - 1) await sleepBackoff(attempt);
+          continue;
+        }
+        throw err;
+      }
+    }
+    void lastConflict;
+    throw new SequenceContentionError(name, MAX_NEXT_ATTEMPTS);
+  }
+};
+
 // src/shadow/strategy.ts
 var NOT_ENABLED2 = new Error(
   'VaultFrame requires the shadow strategy. Import `{ withShadow }` from "@noy-db/hub/shadow" and pass it to `createNoydb({ shadowStrategy: withShadow() })`.'
@@ -4725,6 +5041,10 @@ var Vault = class {
    * call throws with a pointer at `@noy-db/hub/blobs`.
    */
   blobStrategy;
+  /** Cold-storage archival strategy (the archive target store). */
+  archiveStrategy;
+  /** Per-collection record archival policies. Indexed by collection name. */
+  archiveRegistry = /* @__PURE__ */ new Map();
   indexStrategy;
   aggregateStrategy;
   crdtStrategy;
@@ -4828,6 +5148,8 @@ var Vault = class {
    * docstring.
    */
   ledgerStore = null;
+  /** Lazily-built atomic-sequence store. See {@link sequence}. */
+  sequenceStore = null;
   /**
    * Background writes for persisted-schema envelopes (#schema-dump v0
    * slice 1). One promise per `collection({ persistJsonSchema: true })`
@@ -4929,6 +5251,7 @@ var Vault = class {
     this.onRegisterConflictResolver = opts.onRegisterConflictResolver;
     this.syncAdapter = opts.syncAdapter;
     this.blobStrategy = opts.blobStrategy;
+    this.archiveStrategy = opts.archiveStrategy;
     this.indexStrategy = opts.indexStrategy;
     this.aggregateStrategy = opts.aggregateStrategy;
     this.crdtStrategy = opts.crdtStrategy;
@@ -4991,8 +5314,9 @@ var Vault = class {
    *. `put()` validates keys against the declared set; reads
    *   with `{ locale }` add `<field>Label` virtual fields.
    *
-   * Throws `ReservedCollectionNameError` for names starting with `_dict_`.
-   * Use `vault.dictionary(name)` to access dictionary collections.
+   * Throws `ReservedCollectionNameError` for names starting with `_dict_` or
+   * equal to `_sequences`. Use `vault.dictionary(name)` for dict collections
+   * and `vault.sequence(name)` for sequence counters.
    *
    * Lazy mode + indexes is rejected at construction time — see the
    * Collection constructor for the rationale.
@@ -5011,7 +5335,16 @@ var Vault = class {
     if (isDictCollectionName(collectionName)) {
       throw new ReservedCollectionNameError(collectionName);
     }
+    if (collectionName === SEQUENCE_COLLECTION) {
+      throw new ReservedCollectionNameError(collectionName);
+    }
     let coll = this.collectionCache.get(collectionName);
+    if (coll && options?.moneyFields) {
+      coll._applyMoneyFields(options.moneyFields);
+    }
+    if (coll && options?.computed) {
+      coll._applyComputed(options.computed);
+    }
     if (!coll) {
       if (options?.refs) {
         this.refRegistry.register(collectionName, options.refs);
@@ -5022,6 +5355,9 @@ var Vault = class {
       if (options?.blobFields) {
         this.blobFieldsRegistry.set(collectionName, options.blobFields);
       }
+      if (options?.archive) {
+        this.archiveRegistry.set(collectionName, options.archive);
+      }
       if (options?.attestation !== void 0) {
         this.attestationRegistry.set(collectionName, options.attestation);
       }
@@ -5137,6 +5473,8 @@ var Vault = class {
       collOpts.onCrossTierAccess = (event) => this.emitCrossTier(event);
       if (this.syncAdapter !== void 0) collOpts.syncAdapter = this.syncAdapter;
       if (options?.i18nFields !== void 0) collOpts.i18nFields = options.i18nFields;
+      if (options?.moneyFields !== void 0) collOpts.moneyFields = options.moneyFields;
+      if (options?.computed !== void 0) collOpts.computed = options.computed;
       if (options?.dictKeyFields !== void 0) {
         collOpts.dictLabelResolver = async (dictName, key, locale, fallback) => {
           const handle = this.dictionary(dictName);
@@ -5556,6 +5894,33 @@ var Vault = class {
    * await vault.compact({ maxEvictions: 1000 })             // cap batch
    * ```
    */
+  /**
+   * Atomic, gap-free numbering. `vault.sequence('invoice-2026').next()`
+   * returns 1, 2, 3, … with no gaps or duplicates under concurrency, via
+   * an optimistic-CAS counter at `_sequences/<name>`. Each name is an
+   * independent sequence.
+   *
+   * **Online-only:** `next()` throws `SequenceOfflineError` unless the
+   * store advertises `capabilities.casAtomic` — gap-free numbering cannot
+   * be serialized by an offline / non-CAS writer.
+   *
+   * ```ts
+   * const n = await vault.sequence('invoice-2026').next()   // 1, then 2, …
+   * const cur = await vault.sequence('invoice-2026').peek()  // current value, no allocation
+   * ```
+   */
+  sequence(name) {
+    if (!this.sequenceStore) {
+      this.sequenceStore = new SequenceStore({
+        adapter: this.adapter,
+        vault: this.name,
+        encrypted: this.encrypted,
+        getDEK: this.getDEK,
+        actor: this.keyring.userId
+      });
+    }
+    return this.sequenceStore.handle(name);
+  }
   async compact(options = {}) {
     return runCompaction({
       adapter: this.adapter,
@@ -5580,6 +5945,48 @@ var Vault = class {
       }
     }, options);
   }
+  /**
+   * Sweep records eligible by their collection's `archive` policy into the
+   * cold archive store. Relocation is envelope-level (no re-encryption) and
+   * bypasses guards + materialized-view dispatch, so issued/immutable
+   * records over a sealed period can be archived without recomputing
+   * finalized aggregates. A `legalHold` predicate blocks archival.
+   * Requires `archiveStrategy: withArchive({ store })` in `createNoydb`.
+   */
+  async archive(options = {}) {
+    return runArchive(this._archiveContext(), options);
+  }
+  /** Relocate one archived record back to the primary store. Returns false if it was not archived. */
+  async restore(collection, id) {
+    return runRestore(this._archiveContext(), collection, id);
+  }
+  /** List archived record ids for a collection (or all collections with an archive policy). */
+  async listArchived(collection) {
+    return runListArchived(this._archiveContext(), collection);
+  }
+  _archiveContext() {
+    const strategy = this.archiveStrategy;
+    if (!strategy) {
+      throw new Error(
+        "vault.archive/restore/listArchived require `archiveStrategy: withArchive({ store })` in createNoydb"
+      );
+    }
+    const archiveStore = strategy.store;
+    return {
+      vaultId: this.name,
+      archiveStore,
+      collectionsWithPolicy: () => [...this.archiveRegistry.keys()],
+      getPolicy: (c) => this.archiveRegistry.get(c) ?? null,
+      listRecordIds: (c) => this.adapter.list(this.name, c),
+      getRecord: async (c, id) => await this.collection(c).get(id, { locale: "raw" }),
+      getEnvelope: (c, id) => this.adapter.get(this.name, c, id),
+      removeFromPrimary: (c, id) => this.collection(c)._internalDelete(id),
+      restoreToPrimary: async (c, id, env) => {
+        await this.adapter.put(this.name, c, id, env);
+        await this.collection(c)._invalidateCacheEntry(id);
+      }
+    };
+  }
   exportBlobs(options = {}) {
     this.assertCanExport("plaintext", "blob");
     return createExportBlobsHandle(
@@ -5595,12 +6002,12 @@ var Vault = class {
     if (!fieldSchema) {
       throw new AttestationError(`issueAttestation: collection '${collectionName}' has no attestation field-schema. Declare it via vault.collection('${collectionName}', { attestation: { fields: [...] } }).`);
     }
-    const { issueAttestationCore } = await import("./issue-3W6IVLKH.js");
+    const { issueAttestationCore } = await import("./issue-YIYG4OW5.js");
     const out = await issueAttestationCore(this.makeIssueContext(), { collection: collectionName, id, fieldSchema });
     return { docId: out.docId, qr: out.qr, keyId: out.keyId, publicKeyB64: out.publicKeyB64 };
   }
   async getDocumentSigningPublicKey() {
-    const { loadSigner, loadOrCreateSigner } = await import("./signer-7NPTB3SQ.js");
+    const { loadSigner, loadOrCreateSigner } = await import("./signer-6JF44I4A.js");
     const existing = await loadSigner(this.adapter, this.name, this.getDEK);
     if (existing) return { keyId: existing.keyId, publicKeyB64: existing.publicKeyB64 };
     if (this.keyring.role !== "owner") {
@@ -5626,19 +6033,19 @@ var Vault = class {
     };
   }
   async revokeAttestation(docId) {
-    const { revokeDocCore } = await import("./revoke-S6JMSLUN.js");
+    const { revokeDocCore } = await import("./revoke-7RLGQWZ7.js");
     await revokeDocCore(this.makeRevokeContext(), docId);
   }
   async unrevokeAttestation(docId) {
-    const { unrevokeDocCore } = await import("./revoke-S6JMSLUN.js");
+    const { unrevokeDocCore } = await import("./revoke-7RLGQWZ7.js");
     await unrevokeDocCore(this.makeRevokeContext(), docId);
   }
   async getRevokedDocIds() {
-    const { getRevokedDocIdsCore } = await import("./revoke-S6JMSLUN.js");
+    const { getRevokedDocIdsCore } = await import("./revoke-7RLGQWZ7.js");
     return getRevokedDocIdsCore(this.makeRevokeContext());
   }
   async publishRevocationList() {
-    const { publishRevocationListCore } = await import("./revoke-S6JMSLUN.js");
+    const { publishRevocationListCore } = await import("./revoke-7RLGQWZ7.js");
     return publishRevocationListCore(this.makeRevokeContext());
   }
   makeRevokeContext() {
@@ -5955,7 +6362,7 @@ var Vault = class {
   async _initDerivations(handles) {
     if (handles.length === 0) return;
     const [{ DerivationRegistry }, { ReadOnlyVaultFacade }] = await Promise.all([
-      import("./registry-UFIK7CSR.js"),
+      import("./registry-JLP3QOLD.js"),
       import("./read-only-facade-ITU6L7BL.js")
     ]);
     const registry = new DerivationRegistry();
@@ -5986,7 +6393,7 @@ var Vault = class {
    */
   async _initMaterializedViews(handles) {
     if (handles.length === 0) return;
-    const { MaterializedViewRegistry } = await import("./registry-ST2VNFZC.js");
+    const { MaterializedViewRegistry } = await import("./registry-NCY445U5.js");
     const registry = new MaterializedViewRegistry();
     this.materializedViewRegistry = registry;
     const db = this;
@@ -6010,7 +6417,7 @@ var Vault = class {
    */
   async _initOverlayedViews(handles) {
     if (handles.length === 0) return;
-    const { OverlayedViewRegistry } = await import("./registry-ZGYYSM5I.js");
+    const { OverlayedViewRegistry } = await import("./registry-BVQ5ITMF.js");
     const registry = new OverlayedViewRegistry();
     const mvRegistry = this.materializedViewRegistry;
     const overlayNames = /* @__PURE__ */ new Set();
@@ -6057,13 +6464,13 @@ var Vault = class {
     if (!reg) {
       throw new Error(`refreshView: no MV registered with name "${name}"`);
     }
-    const { MaterializedViewExecutor } = await import("./executor-UCXLIGLW.js");
+    const { MaterializedViewExecutor } = await import("./executor-O5AZK7UW.js");
     const result = await MaterializedViewExecutor.refresh(reg, {
       getCollection: (n) => this.collection(n),
       getActiveTxContext: () => this.noydb._activeTxContextOrNull,
       getQueryContext: () => this
     });
-    const { clearMVStale } = await import("./stale-VKXSXJF4.js");
+    const { clearMVStale } = await import("./stale-UBLP3RJ3.js");
     clearMVStale(registry, name);
     return result;
   }
@@ -6079,7 +6486,7 @@ var Vault = class {
     if (registry === null) return { derived: 0, failed: 0 };
     const strategies = registry.strategiesForSource(sourceCollection);
     if (strategies.length === 0) return { derived: 0, failed: 0 };
-    const { DerivationExecutor } = await import("./executor-S76VN45G.js");
+    const { DerivationExecutor } = await import("./executor-D2QMNGRJ.js");
     const sourceColl = this.collection(sourceCollection);
     const records = await sourceColl.list();
     const ctx = { vault: this.readOnlyFacade ?? new (await import("./read-only-facade-ITU6L7BL.js")).ReadOnlyVaultFacade(this) };
@@ -6104,7 +6511,7 @@ var Vault = class {
           if (!outSpec) continue;
           const outputColl = this.collection(outSpec.collection);
           if (out.kind === "array") {
-            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-OKPMMPLG.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-ZSKEQ6NI.js");
             const prior = await loadFanoutSidecar(this.adapter, this.name, spec.source, id, key);
             const prevKeys = new Set(prior?.keys ?? []);
             const newKeysList = out.entries.map((e) => e.key);
@@ -6325,7 +6732,7 @@ var Vault = class {
    * collection.
    */
   async delegate(opts) {
-    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-ZTRT2PRV.js");
+    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-6FCWDRUS.js");
     if (!this.keyring.kek) {
       throw new ValidationError(
         "issueDelegation: keyring.kek is null \u2014 issuing a delegation requires a tier-1 unlock. Re-authenticate at tier 1 (passphrase) first."
@@ -6347,7 +6754,7 @@ var Vault = class {
    * if the id does not exist.
    */
   async revokeDelegation(id) {
-    const { revokeDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-ZTRT2PRV.js");
+    const { revokeDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-6FCWDRUS.js");
     await revokeDelegation(this.adapter, this.name, id);
     void DELEGATIONS_COLLECTION;
   }
@@ -6816,7 +7223,7 @@ var Vault = class {
    * @see docs/subsystems/public-envelope.md
    */
   async getPublicEnvelope(opts = {}) {
-    const { readPublicEnvelope: readPublicEnvelope2 } = await import("./public-envelope-HMYHZIRH.js");
+    const { readPublicEnvelope: readPublicEnvelope2 } = await import("./public-envelope-PFLZI5MO.js");
     return readPublicEnvelope2(this.adapter, this.name, opts);
   }
   /**
@@ -6841,7 +7248,7 @@ var Vault = class {
       }
     }
     const internalSnapshot = {};
-    for (const internalName of [LEDGER_COLLECTION, LEDGER_DELTAS_COLLECTION, SCHEMAS_COLLECTION]) {
+    for (const internalName of [LEDGER_COLLECTION, LEDGER_DELTAS_COLLECTION, SCHEMAS_COLLECTION, SEQUENCE_COLLECTION]) {
       const ids = await this.adapter.list(this.name, internalName);
       if (ids.length === 0) continue;
       const records = {};
@@ -8358,6 +8765,7 @@ var Noydb = class {
   writeRelay;
   /** Per-vault policy enforcers. */
   policyEnforcers = /* @__PURE__ */ new Map();
+  vaultTemplates = /* @__PURE__ */ new Map();
   txStrategy;
   sessionStrategy;
   syncStrategy;
@@ -8425,9 +8833,9 @@ var Noydb = class {
       if (!facade) return;
       const ctx = { existing, vault: facade, userId: e.userId, role: e.role };
       await registry.runChecks(e.collection, incoming, ctx);
-      const { GuardExecutor } = await import("./executor-ZCNZJMGR.js");
+      const { GuardExecutor } = await import("./executor-7KSCEIFA.js");
       for (const g of guards) {
-        await GuardExecutor.checkFrozenFields(g, e.docId, existing, incoming);
+        await GuardExecutor.checkFrozenFields(g, e.docId, existing, incoming, e.computedFieldNames);
       }
     });
     this.subsystemBus.registerGate("beforeDelete", async (e) => {
@@ -8548,7 +8956,7 @@ var Noydb = class {
       }
       return comp;
     }
-    const keyring = await this.getKeyringInternal(name);
+    const keyring = await this.getKeyringInternal(name, { create: opts?.create !== false });
     if (!this.activeTier.has(name)) {
       this.activeTier.set(name, 1);
     }
@@ -8606,6 +9014,7 @@ var Noydb = class {
       syncAdapter: targets.length > 0 ? targets[0].store : void 0,
       historyConfig: this.options.history,
       ...this.options.blobStrategy !== void 0 ? { blobStrategy: this.options.blobStrategy } : {},
+      ...this.options.archiveStrategy !== void 0 ? { archiveStrategy: this.options.archiveStrategy } : {},
       ...this.options.indexStrategy !== void 0 ? { indexStrategy: this.options.indexStrategy } : {},
       ...this.options.aggregateStrategy !== void 0 ? { aggregateStrategy: this.options.aggregateStrategy } : {},
       ...this.options.crdtStrategy !== void 0 ? { crdtStrategy: this.options.crdtStrategy } : {},
@@ -8659,6 +9068,7 @@ var Noydb = class {
         emitter: this.emitter,
         historyConfig: this.options.history,
         ...this.options.blobStrategy !== void 0 ? { blobStrategy: this.options.blobStrategy } : {},
+        ...this.options.archiveStrategy !== void 0 ? { archiveStrategy: this.options.archiveStrategy } : {},
         ...this.options.indexStrategy !== void 0 ? { indexStrategy: this.options.indexStrategy } : {},
         ...this.options.aggregateStrategy !== void 0 ? { aggregateStrategy: this.options.aggregateStrategy } : {},
         ...this.options.crdtStrategy !== void 0 ? { crdtStrategy: this.options.crdtStrategy } : {},
@@ -8687,6 +9097,7 @@ var Noydb = class {
       encrypted: true,
       historyConfig: this.options.history,
       ...this.options.blobStrategy !== void 0 ? { blobStrategy: this.options.blobStrategy } : {},
+      ...this.options.archiveStrategy !== void 0 ? { archiveStrategy: this.options.archiveStrategy } : {},
       ...this.options.indexStrategy !== void 0 ? { indexStrategy: this.options.indexStrategy } : {},
       ...this.options.aggregateStrategy !== void 0 ? { aggregateStrategy: this.options.aggregateStrategy } : {},
       ...this.options.crdtStrategy !== void 0 ? { crdtStrategy: this.options.crdtStrategy } : {},
@@ -8976,7 +9387,7 @@ var Noydb = class {
       const vaultId = vaultIds[idx];
       const task = (async () => {
         try {
-          const comp = await this.openVault(vaultId);
+          const comp = await this.openVault(vaultId, { create: options.create !== false });
           const result = await fn(comp);
           results[idx] = { vault: vaultId, result };
         } catch (err) {
@@ -9001,6 +9412,32 @@ var Noydb = class {
     }
     return results;
   }
+  /**
+   * Register a shard schema blueprint. `createShard` / `openVaultGroup`
+   * stamp shards from the named template. See the MVF design spec.
+   */
+  withVaultTemplate(name, template) {
+    this.vaultTemplates.set(name, template);
+  }
+  /**
+   * Open a VaultGroup — transparent routing over per-partition shard
+   * vaults, with shard discovery backed by the supplied `vault-registry`
+   * collection.
+   */
+  async openVaultGroup(name, opts) {
+    if (this.closed) throw new ValidationError("Instance is closed");
+    const template = this.vaultTemplates.get(opts.sharding.vaultTemplate);
+    if (!template) throw new VaultTemplateNotFoundError(opts.sharding.vaultTemplate);
+    const { VaultGroup } = await import("./vault-group-Z4KB75ZH.js");
+    return new VaultGroup(this, name, opts.registry, opts.sharding, template);
+  }
+  /**
+   * @internal — true when an encrypted shard vault is provisioned
+   * (its keyring exists in the store).
+   */
+  async _shardVaultProvisioned(vaultId) {
+    return (await this.options.store.list(vaultId, "_keyring")).length > 0;
+  }
   /**
    * Change the current user's passphrase for a vault.
    *
@@ -10318,7 +10755,7 @@ var Noydb = class {
    * accesses see them. Not exposed publicly — callers outside hub
    * should use {@link getKeyring}, which returns a defensive copy.
    */
-  async getKeyringInternal(vault) {
+  async getKeyringInternal(vault, opts = { create: true }) {
     if (this.options.encrypt === false) {
       return createPlaintextKeyring(this.options.user);
     }
@@ -10329,6 +10766,7 @@ var Noydb = class {
       this.keyringCache.set(vault, keyring2);
       return keyring2;
     }
+    await assertKeyringOpenAllowed(this.options.store, vault, this.options.user, opts.create);
     let effectiveSecret;
     if (this.options.passphraseMode === "managed") {
       effectiveSecret = await resolveManagedSecret(
@@ -10491,6 +10929,8 @@ function normalizeSyncTargets(sync) {
 }
 
 export {
+  withArchive,
+  SequenceStore,
   validateSchemaInput,
   validateSchemaOutput,
   isZodSchema,
@@ -10510,6 +10950,8 @@ export {
   diagramAuthConfig,
   describeUserAuth,
   describeAllUsersAuth,
+  ComputedFieldError,
+  evalComputedFields,
   Lru,
   parseBytes,
   estimateRecordBytes,
@@ -10526,4 +10968,4 @@ export {
   Noydb,
   createNoydb
 };
-//# sourceMappingURL=chunk-4USCAEDT.js.map
+//# sourceMappingURL=chunk-TMHJEYW7.js.map