@noy-db/hub 0.2.0-pre.11 → 0.2.0-pre.13

package/dist/{chunk-MPOLUAMI.js → chunk-P5MW7BG2.js}

@@ -1,40 +1,43 @@
+import {
+  STATE_VAULT_NAME
+} from "./chunk-ZC7J6ZYV.js";
 import {
   resolveSchema
 } from "./chunk-EMIGCR7X.js";
 import {
   TxContext,
   revertExecuted
-} from "./chunk-26NK23DZ.js";
+} from "./chunk-M6KXHRIA.js";
 import {
   OverlayedCollection
-} from "./chunk-7CEGU63S.js";
+} from "./chunk-3XZRRBFW.js";
 import {
   LazyQuery,
   decodeIdxId,
   encodeIdxId
-} from "./chunk-QSOYKKMD.js";
+} from "./chunk-D5Y3HIC6.js";
 import {
   SCHEMAS_COLLECTION,
   loadPersistedSchema,
   resolveManagedSecret,
   savePersistedSchema,
   saveSealedPassphrase
-} from "./chunk-LJXYPGRH.js";
+} from "./chunk-HHZ77DHM.js";
 import {
   loadPublicEnvelope,
   readPublicEnvelope,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-JQ4NEJJ6.js";
+} from "./chunk-KJF7EPUE.js";
 import {
   PERIODS_COLLECTION
-} from "./chunk-3DGHRDCX.js";
+} from "./chunk-J67BP5EP.js";
 import {
   getAtPath,
   isDictCollectionName,
   resolvePolicy,
   setAtPathInPlace
-} from "./chunk-ZBBW7YQN.js";
+} from "./chunk-7TEI2K2A.js";
 import {
   ManagedRecoveryNotEnrolledError,
   PolicyDeniedError,
@@ -56,11 +59,11 @@ import {
   saveShamirRecoveryEntries,
   updateAuthenticator,
   writeMagicLinkGrant
-} from "./chunk-YVZRTCGG.js";
+} from "./chunk-SYSKC237.js";
 import {
   assertTierAccess,
   dekKey
-} from "./chunk-CXFOITNS.js";
+} from "./chunk-SJ24GHID.js";
 import {
   USER_ENVELOPE_COLLECTION,
   assertKeyringOpenAllowed,
@@ -85,7 +88,7 @@ import {
   rotateKeys,
   saveUserEnvelope,
   updateKeyringIdentity
-} from "./chunk-QCXNMCHN.js";
+} from "./chunk-C3WRKABE.js";
 import {
   INDEXED_STORE_POLICY
 } from "./chunk-2QR2PQTT.js";
@@ -95,18 +98,20 @@ import {
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
-} from "./chunk-6MFH4BMK.js";
+} from "./chunk-HQXOEWLZ.js";
 import {
   sha256Hex as sha256Hex2
 } from "./chunk-Z6FNBOTC.js";
 import {
   NO_AGGREGATE,
   Query,
-  ScanBuilder
-} from "./chunk-6YLPHBKR.js";
+  ScanBuilder,
+  decodeMoneyFields,
+  quantizeMoneyFields
+} from "./chunk-NJMKHRQI.js";
 import {
   canonicalGroupKey
-} from "./chunk-2LPPNWF6.js";
+} from "./chunk-YWBHS25M.js";
 import {
   readPath
 } from "./chunk-TV3YZ35S.js";
@@ -114,17 +119,17 @@ import {
   EXPORT_AUDIT_COLLECTION,
   createExportBlobsHandle,
   runCompaction
-} from "./chunk-77DWLQRY.js";
+} from "./chunk-TDECYU4Y.js";
 import {
   NOYDB_BACKUP_VERSION,
   NOYDB_FORMAT_VERSION
-} from "./chunk-SLV4LAKX.js";
+} from "./chunk-GC4V7RU7.js";
 import {
   decrypt,
   encrypt,
   encryptDeterministic,
   sha256Hex
-} from "./chunk-R233SLY3.js";
+} from "./chunk-E3DIBDKA.js";
 import {
   AlreadyElevatedError,
   AttestationError,
@@ -141,20 +146,25 @@ import {
   MigrationRequiredError,
   NoAccessError,
   NoydbError,
+  NumberingUncertaintyError,
   PermissionDeniedError,
   QuiesceTimeoutError,
   ReadOnlyError,
   ReservedCollectionNameError,
+  ReservedVaultNameError,
   SchemaFenceError,
   SchemaValidationError,
+  SequenceContentionError,
+  SequenceOfflineError,
   StoreCapabilityError,
   TierDemoteDeniedError,
   TierNotGrantedError,
   TranslatorNotConfiguredError,
   UniqueConstraintError,
   UnsupportedIndexOptionError,
-  ValidationError
-} from "./chunk-O6EJ6WTI.js";
+  ValidationError,
+  VaultTemplateNotFoundError
+} from "./chunk-NKGY3C53.js";
 
 // src/policy/storage.ts
 var META_COLLECTION = "_meta";
@@ -329,6 +339,34 @@ var NO_CRDT = {
   }
 };
 
+// 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(
@@ -769,7 +807,7 @@ async function resolveStaleOnRead(accessor, outputCollection, id) {
     }
     const sourceWithId = { ...source, id };
     if (DerivationExecutor === null) {
-      ({ DerivationExecutor } = await import("./executor-S76VN45G.js"));
+      ({ DerivationExecutor } = await import("./executor-AVJ7UEWA.js"));
     }
     const ctx = { vault: accessor.getReadOnlyFacade() };
     const result = await DerivationExecutor.run(spec, sourceWithId, 0, strategyHash, ctx);
@@ -962,6 +1000,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
@@ -1103,6 +1153,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;
@@ -1227,6 +1279,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.
    *
@@ -1248,7 +1313,7 @@ var Collection = class {
       }
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-VKXSXJF4.js");
+      const { resolveStaleMVOnRead } = await import("./stale-LZYMMDDS.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name);
     }
     let record;
@@ -1398,7 +1463,7 @@ var Collection = class {
           existingRecord = null;
         }
       }
-      await this.subsystemBus.dispatchGate("beforePut", {
+      const gateEvent = {
         op: existingEnv ? "update" : "create",
         vault: this.vault,
         collection: this.name,
@@ -1408,12 +1473,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)) {
@@ -1637,7 +1710,7 @@ var Collection = class {
       if (mode === "eager") {
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-UCXLIGLW.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-IQO3KGXQ.js"));
         }
         await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
@@ -1646,7 +1719,7 @@ var Collection = class {
         });
       } else if (mode === "lazy") {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-VKXSXJF4.js");
+          staleHelpers = await import("./stale-LZYMMDDS.js");
         }
         staleHelpers.markMVStale(registry, reg.spec.name);
       }
@@ -1675,7 +1748,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-AVJ7UEWA.js"));
         }
         const sourceWithId = { ...incoming, id };
         const ctx = { vault: this.derivationSource.getReadOnlyFacade() };
@@ -1694,7 +1767,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-F3ZRFU4H.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-N6OJX6QR.js");
             const prior = await loadFanoutSidecar(
               this.adapter,
               this.vault,
@@ -1987,7 +2060,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-F3ZRFU4H.js");
+          helpers = await import("./fanout-sidecar-N6OJX6QR.js");
         }
         const sidecar = await helpers.loadFanoutSidecar(
           this.adapter,
@@ -2027,7 +2100,7 @@ var Collection = class {
       if (mode === "eager") {
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-UCXLIGLW.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-IQO3KGXQ.js"));
         }
         await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
@@ -2036,7 +2109,7 @@ var Collection = class {
         });
       } else if (mode === "lazy") {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-VKXSXJF4.js");
+          staleHelpers = await import("./stale-LZYMMDDS.js");
         }
         staleHelpers.markMVStale(registry, reg.spec.name);
       }
@@ -2059,14 +2132,22 @@ var Collection = class {
       );
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-VKXSXJF4.js");
+      const { resolveStaleMVOnRead } = await import("./stale-LZYMMDDS.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name);
     }
     await this.ensureHydrated();
     const records = [...this.cache.values()].map((e) => e.record);
-    if (!locale) return records;
+    if (!this.hasReadTransforms()) return records;
     return Promise.all(records.map((r) => this.applyLocaleToRecord(r, locale)));
   }
+  /**
+   * @internal — whether any read-side record transform is registered
+   * (money decode, i18nText resolution, dictKey labels). Gates the
+   * no-transform fast path in {@link list}.
+   */
+  hasReadTransforms() {
+    return this.moneyFields !== void 0 && Object.keys(this.moneyFields).length > 0 || this.i18nFields !== void 0 && Object.keys(this.i18nFields).length > 0 || this.dictKeyFields !== void 0 && Object.keys(this.dictKeyFields).length > 0;
+  }
   // ─── Bulk operations ─────────────────────────────────────
   /**
    * Put many records in one call. Each item is processed sequentially
@@ -2235,7 +2316,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;
@@ -2571,7 +2653,8 @@ var Collection = class {
       pageSize,
       [],
       [],
-      joinContext
+      joinContext,
+      this.moneyFields
     );
   }
   /** Decrypt a page of envelopes returned by `adapter.listPage`. */
@@ -2917,10 +3000,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);
     }
@@ -3616,6 +3703,318 @@ 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/numbering/index.ts
+var NUMBERING_HEAD_COLLECTION = "_numbering_head";
+var NUMBERING_PENDING_COLLECTION = "_numbering_pending";
+var DeferredNumberingStore = class {
+  adapter;
+  vault;
+  encrypted;
+  getDEK;
+  actor;
+  configs;
+  /**
+   * Stamp a serial onto a USER record THROUGH the Collection layer (so the
+   * cache, indexes, and MVs stay coherent — the engine must NOT write user
+   * collections at the raw adapter level). Returns false if the record is
+   * gone (the engine then skips it without burning a serial). Provided by the
+   * vault; unit tests pass a Map-backed double.
+   */
+  stamp;
+  /** In-process registry: `${series}::${recordId}` → resolver for the live next() Promise. */
+  waiters = /* @__PURE__ */ new Map();
+  dekCache = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.adapter = opts.adapter;
+    this.vault = opts.vault;
+    this.encrypted = opts.encrypted;
+    this.getDEK = opts.getDEK;
+    this.actor = opts.actor;
+    this.configs = opts.configs;
+    this.stamp = opts.stamp;
+  }
+  has(series) {
+    return this.configs.has(series);
+  }
+  dek(collection) {
+    let p = this.dekCache.get(collection);
+    if (!p) {
+      p = this.getDEK(collection);
+      this.dekCache.set(collection, p);
+    }
+    return p;
+  }
+  async readJson(collection, id) {
+    const env = await this.adapter.get(this.vault, collection, id);
+    if (!env) return { env: null, value: null };
+    const json = this.encrypted ? await decrypt(env._iv, env._data, await this.dek(collection)) : env._data;
+    return { env, value: JSON.parse(json) };
+  }
+  async writeJson(collection, id, value, expectedVersion) {
+    const json = JSON.stringify(value);
+    let env;
+    if (!this.encrypted) {
+      env = { _noydb: NOYDB_FORMAT_VERSION, _v: expectedVersion + 1, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: "", _data: json, _by: this.actor };
+    } else {
+      const { iv, data } = await encrypt(json, await this.dek(collection));
+      env = { _noydb: NOYDB_FORMAT_VERSION, _v: expectedVersion + 1, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: iv, _data: data, _by: this.actor };
+    }
+    await this.adapter.put(this.vault, collection, id, env, expectedVersion);
+  }
+  pendingId(series, recordId) {
+    return `${series}::${recordId}`;
+  }
+  /** Current last-assigned serial for a series (0 if none). */
+  async peek(series) {
+    const { value } = await this.readJson(NUMBERING_HEAD_COLLECTION, series);
+    return value?.lastSerial ?? 0;
+  }
+  /**
+   * Enqueue a record for numbering: stamp it with the current store clock and
+   * durably write a pending entry. The returned Promise resolves once the
+   * record is durably enqueued; its `assigned` field resolves with the serial
+   * at the next pass (the record's `field` is the durable source of truth —
+   * `assigned` is an in-process convenience that a crash may drop).
+   */
+  async enqueue(series, recordId) {
+    const cfg = this.configs.get(series);
+    if (!cfg) throw new NumberingUncertaintyError(series);
+    if (typeof this.adapter.getStoreTime !== "function") throw new NumberingUncertaintyError(series);
+    const st = await this.adapter.getStoreTime();
+    const id = this.pendingId(series, recordId);
+    const { env } = await this.readJson(NUMBERING_PENDING_COLLECTION, id);
+    const entry = {
+      series,
+      recordId,
+      collection: cfg.collection,
+      field: cfg.field,
+      storeEarliest: st.earliest,
+      storeLatest: st.latest,
+      enqueuedAt: Date.now()
+    };
+    await this.writeJson(NUMBERING_PENDING_COLLECTION, id, entry, env?._v ?? 0);
+    const assigned = new Promise((resolve, reject) => {
+      this.waiters.set(id, { resolve, reject });
+    });
+    return { assigned };
+  }
+  async listPending(series) {
+    const ids = await this.adapter.list(this.vault, NUMBERING_PENDING_COLLECTION);
+    const prefix = `${series}::`;
+    const out = [];
+    for (const id of ids) {
+      if (!id.startsWith(prefix)) continue;
+      const { value } = await this.readJson(NUMBERING_PENDING_COLLECTION, id);
+      if (value) out.push({ id, entry: value });
+    }
+    return out;
+  }
+  /**
+   * Run a numbering pass for `series`: select entries provably settled
+   * (`storeLatest ≤ now.earliest` — commit-wait), order by
+   * `(storeEarliest, recordId)`, assign serials after the head, stamp each
+   * record's field, advance the head with one CAS, and consume the entries.
+   * Idempotent/convergent: a losing concurrent pass returns `[]` and the next
+   * pass reconciles. Resolves any in-process enqueue() `assigned` Promises.
+   */
+  async runPass(series) {
+    const cfg = this.configs.get(series);
+    if (!cfg) throw new NumberingUncertaintyError(series);
+    if (typeof this.adapter.getStoreTime !== "function") throw new NumberingUncertaintyError(series);
+    const now = await this.adapter.getStoreTime();
+    const settled = (await this.listPending(series)).filter((p) => p.entry.storeLatest <= now.earliest).sort(
+      (a, b) => a.entry.storeEarliest - b.entry.storeEarliest || (a.entry.recordId < b.entry.recordId ? -1 : a.entry.recordId > b.entry.recordId ? 1 : 0)
+    );
+    if (settled.length === 0) return [];
+    const { env: headEnv, value: head } = await this.readJson(NUMBERING_HEAD_COLLECTION, series);
+    let serial = head?.lastSerial ?? 0;
+    const assignments = [];
+    for (const { entry } of settled) {
+      serial += 1;
+      const ok = await this.stamp(entry.collection, entry.recordId, entry.field, serial);
+      if (!ok) {
+        serial -= 1;
+        continue;
+      }
+      assignments.push({ recordId: entry.recordId, serial });
+    }
+    try {
+      await this.writeJson(NUMBERING_HEAD_COLLECTION, series, { series, lastSerial: serial, watermark: now.earliest }, headEnv?._v ?? 0);
+    } catch (err) {
+      if (err instanceof ConflictError) return [];
+      throw err;
+    }
+    for (const { id, entry } of settled) {
+      await this.adapter.delete(this.vault, NUMBERING_PENDING_COLLECTION, id);
+      const a = assignments.find((x) => x.recordId === entry.recordId);
+      if (a) {
+        this.waiters.get(id)?.resolve(a.serial);
+        this.waiters.delete(id);
+      }
+    }
+    return assignments;
+  }
+};
+
 // 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() })`.'
@@ -4726,6 +5125,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;
@@ -4829,6 +5232,12 @@ var Vault = class {
    * docstring.
    */
   ledgerStore = null;
+  /** Lazily-built atomic-sequence store. See {@link sequence}. */
+  sequenceStore = null;
+  /** Lazily-built deferred-numbering engine. See {@link runNumberingPass}. */
+  deferredNumbering = null;
+  /** Registered deferred-numbering series, keyed by series name. */
+  numberingConfigs;
   /**
    * Background writes for persisted-schema envelopes (#schema-dump v0
    * slice 1). One promise per `collection({ persistJsonSchema: true })`
@@ -4915,6 +5324,7 @@ var Vault = class {
   constructor(opts) {
     this.adapter = opts.adapter;
     this.name = opts.name;
+    this.numberingConfigs = new Map((opts.numberingConfigs ?? []).map((c) => [c.series, c]));
     this.noydb = opts.noydb;
     this.keyring = opts.keyring;
     this.encrypted = opts.encrypted;
@@ -4930,6 +5340,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;
@@ -4992,8 +5403,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.
@@ -5012,7 +5424,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);
@@ -5023,6 +5444,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);
       }
@@ -5138,6 +5562,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);
@@ -5557,6 +5983,77 @@ 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.numberingConfigs.has(name)) {
+      const eng = this.deferred();
+      return {
+        next: async (opts) => {
+          if (!opts?.for) {
+            throw new ValidationError(`sequence("${name}") is a deferred-numbering series; call next({ for: recordId }).`);
+          }
+          return (await eng.enqueue(name, opts.for)).assigned;
+        },
+        peek: () => eng.peek(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);
+  }
+  /** @internal — lazily build the deferred-numbering engine with a cache-coherent stamp. */
+  deferred() {
+    if (!this.deferredNumbering) {
+      this.deferredNumbering = new DeferredNumberingStore({
+        adapter: this.adapter,
+        vault: this.name,
+        encrypted: this.encrypted,
+        getDEK: this.getDEK,
+        actor: this.keyring.userId,
+        configs: this.numberingConfigs,
+        // Stamp THROUGH the Collection layer so cache/indexes/MVs stay coherent —
+        // `this.collection(name)` returns the shared cached instance, so a
+        // subsequent user `collection.get(id)` sees the assigned serial.
+        stamp: async (collection, recordId, field, serial) => {
+          const coll = this.collection(collection);
+          const rec = await coll.get(recordId);
+          if (!rec) return false;
+          await coll.put(recordId, { ...rec, [field]: serial });
+          return true;
+        }
+      });
+    }
+    return this.deferredNumbering;
+  }
+  /**
+   * Run a deferred-numbering pass for `series`: assign gap-free serials to all
+   * records whose store-commit-time interval has settled, in store-time order.
+   * Returns the assignments made. See {@link sequence} / `withDeferredNumbering`.
+   */
+  async runNumberingPass(series) {
+    return this.deferred().runPass(series);
+  }
   async compact(options = {}) {
     return runCompaction({
       adapter: this.adapter,
@@ -5581,6 +6078,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(
@@ -5596,12 +6135,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-IVTVSKWW.js");
+    const { issueAttestationCore } = await import("./issue-ZH27C23Y.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-QNU66JF5.js");
+    const { loadSigner, loadOrCreateSigner } = await import("./signer-GRIYBA22.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") {
@@ -5627,19 +6166,19 @@ var Vault = class {
     };
   }
   async revokeAttestation(docId) {
-    const { revokeDocCore } = await import("./revoke-RT7QYB4G.js");
+    const { revokeDocCore } = await import("./revoke-5BOLVJ3N.js");
     await revokeDocCore(this.makeRevokeContext(), docId);
   }
   async unrevokeAttestation(docId) {
-    const { unrevokeDocCore } = await import("./revoke-RT7QYB4G.js");
+    const { unrevokeDocCore } = await import("./revoke-5BOLVJ3N.js");
     await unrevokeDocCore(this.makeRevokeContext(), docId);
   }
   async getRevokedDocIds() {
-    const { getRevokedDocIdsCore } = await import("./revoke-RT7QYB4G.js");
+    const { getRevokedDocIdsCore } = await import("./revoke-5BOLVJ3N.js");
     return getRevokedDocIdsCore(this.makeRevokeContext());
   }
   async publishRevocationList() {
-    const { publishRevocationListCore } = await import("./revoke-RT7QYB4G.js");
+    const { publishRevocationListCore } = await import("./revoke-5BOLVJ3N.js");
     return publishRevocationListCore(this.makeRevokeContext());
   }
   makeRevokeContext() {
@@ -5956,7 +6495,7 @@ var Vault = class {
   async _initDerivations(handles) {
     if (handles.length === 0) return;
     const [{ DerivationRegistry }, { ReadOnlyVaultFacade }] = await Promise.all([
-      import("./registry-UFIK7CSR.js"),
+      import("./registry-2PKBQDCH.js"),
       import("./read-only-facade-ITU6L7BL.js")
     ]);
     const registry = new DerivationRegistry();
@@ -5987,7 +6526,7 @@ var Vault = class {
    */
   async _initMaterializedViews(handles) {
     if (handles.length === 0) return;
-    const { MaterializedViewRegistry } = await import("./registry-ST2VNFZC.js");
+    const { MaterializedViewRegistry } = await import("./registry-PV4G3OPA.js");
     const registry = new MaterializedViewRegistry();
     this.materializedViewRegistry = registry;
     const db = this;
@@ -6011,7 +6550,7 @@ var Vault = class {
    */
   async _initOverlayedViews(handles) {
     if (handles.length === 0) return;
-    const { OverlayedViewRegistry } = await import("./registry-ZGYYSM5I.js");
+    const { OverlayedViewRegistry } = await import("./registry-4VXFKCBJ.js");
     const registry = new OverlayedViewRegistry();
     const mvRegistry = this.materializedViewRegistry;
     const overlayNames = /* @__PURE__ */ new Set();
@@ -6058,13 +6597,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-IQO3KGXQ.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-LZYMMDDS.js");
     clearMVStale(registry, name);
     return result;
   }
@@ -6080,7 +6619,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-AVJ7UEWA.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) };
@@ -6105,7 +6644,7 @@ var Vault = class {
           if (!outSpec) continue;
           const outputColl = this.collection(outSpec.collection);
           if (out.kind === "array") {
-            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-F3ZRFU4H.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-N6OJX6QR.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);
@@ -6326,7 +6865,7 @@ var Vault = class {
    * collection.
    */
   async delegate(opts) {
-    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-ZTRT2PRV.js");
+    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-K5ERUH6A.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."
@@ -6348,7 +6887,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-K5ERUH6A.js");
     await revokeDelegation(this.adapter, this.name, id);
     void DELEGATIONS_COLLECTION;
   }
@@ -6817,7 +7356,7 @@ var Vault = class {
    * @see docs/subsystems/public-envelope.md
    */
   async getPublicEnvelope(opts = {}) {
-    const { readPublicEnvelope: readPublicEnvelope2 } = await import("./public-envelope-QOXZEHKH.js");
+    const { readPublicEnvelope: readPublicEnvelope2 } = await import("./public-envelope-MHG6YVXW.js");
     return readPublicEnvelope2(this.adapter, this.name, opts);
   }
   /**
@@ -6842,7 +7381,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 = {};
@@ -8359,6 +8898,7 @@ var Noydb = class {
   writeRelay;
   /** Per-vault policy enforcers. */
   policyEnforcers = /* @__PURE__ */ new Map();
+  vaultTemplates = /* @__PURE__ */ new Map();
   txStrategy;
   sessionStrategy;
   syncStrategy;
@@ -8426,9 +8966,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-VT7TKGE4.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) => {
@@ -8607,6 +9147,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 } : {},
@@ -8617,6 +9158,7 @@ var Noydb = class {
       ...this.options.i18nStrategy !== void 0 ? { i18nStrategy: this.options.i18nStrategy } : {},
       ...this.options.syncStrategy !== void 0 ? { syncStrategy: this.options.syncStrategy } : {},
       ...this.options.guardStrategies !== void 0 ? { guardStrategies: this.options.guardStrategies } : {},
+      ...this.options.numbering !== void 0 ? { numberingConfigs: this.options.numbering } : {},
       locale: opts?.locale,
       // Thread the translator hook so Collection.put() can invoke it
       plaintextTranslator: this.options.plaintextTranslator ? (text, from, to, field, collection) => this.invokeTranslator(text, from, to, field, collection) : void 0,
@@ -8660,6 +9202,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 } : {},
@@ -8669,7 +9212,8 @@ var Noydb = class {
         ...this.options.historyStrategy !== void 0 ? { historyStrategy: this.options.historyStrategy } : {},
         ...this.options.i18nStrategy !== void 0 ? { i18nStrategy: this.options.i18nStrategy } : {},
         ...this.options.syncStrategy !== void 0 ? { syncStrategy: this.options.syncStrategy } : {},
-        ...this.options.guardStrategies !== void 0 ? { guardStrategies: this.options.guardStrategies } : {}
+        ...this.options.guardStrategies !== void 0 ? { guardStrategies: this.options.guardStrategies } : {},
+        ...this.options.numbering !== void 0 ? { numberingConfigs: this.options.numbering } : {}
       });
       this.vaultCache.set(name, comp2);
       return comp2;
@@ -8688,6 +9232,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 } : {},
@@ -8698,6 +9243,7 @@ var Noydb = class {
       ...this.options.i18nStrategy !== void 0 ? { i18nStrategy: this.options.i18nStrategy } : {},
       ...this.options.syncStrategy !== void 0 ? { syncStrategy: this.options.syncStrategy } : {},
       ...this.options.guardStrategies !== void 0 ? { guardStrategies: this.options.guardStrategies } : {},
+      ...this.options.numbering !== void 0 ? { numberingConfigs: this.options.numbering } : {},
       emitter: this.emitter
     });
     this.vaultCache.set(name, comp);
@@ -9002,6 +9548,61 @@ 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");
+    if (name === STATE_VAULT_NAME) throw new ReservedVaultNameError(name);
+    const template = this.vaultTemplates.get(opts.sharding.vaultTemplate);
+    if (!template) throw new VaultTemplateNotFoundError(opts.sharding.vaultTemplate);
+    const { VaultGroup } = await import("./vault-group-UO4YUZOG.js");
+    const { StateManagementVault } = await import("./state-vault-QFJWU23A.js");
+    const stateVault = opts.registry ? void 0 : await StateManagementVault.open(this);
+    const registry = opts.registry ?? stateVault.registry;
+    const group = new VaultGroup(this, name, registry, opts.sharding, template);
+    if (stateVault) {
+      group._attachStateVault(stateVault);
+      await stateVault.recordManifest(opts.sharding.vaultTemplate, template);
+      try {
+        await stateVault.appendEvent({
+          type: "manifest-recorded",
+          group: name,
+          templateName: opts.sharding.vaultTemplate,
+          version: template.version
+        });
+        await stateVault.appendEvent({ type: "group-opened", group: name });
+      } catch {
+      }
+    }
+    return group;
+  }
+  /**
+   * Open the reserved StateManagement control-plane vault (registry +
+   * schema-manifest + deployment-events). Lazy-loaded so the federation
+   * chunk stays out of the core graph until used.
+   */
+  async openStateManagementVault() {
+    if (this.closed) throw new ValidationError("Instance is closed");
+    const { StateManagementVault } = await import("./state-vault-QFJWU23A.js");
+    return StateManagementVault.open(this);
+  }
+  /**
+   * @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.
    *
@@ -10493,6 +11094,8 @@ function normalizeSyncTargets(sync) {
 }
 
 export {
+  withArchive,
+  SequenceStore,
   validateSchemaInput,
   validateSchemaOutput,
   isZodSchema,
@@ -10512,6 +11115,8 @@ export {
   diagramAuthConfig,
   describeUserAuth,
   describeAllUsersAuth,
+  ComputedFieldError,
+  evalComputedFields,
   Lru,
   parseBytes,
   estimateRecordBytes,
@@ -10528,4 +11133,4 @@ export {
   Noydb,
   createNoydb
 };
-//# sourceMappingURL=chunk-MPOLUAMI.js.map
+//# sourceMappingURL=chunk-P5MW7BG2.js.map