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

package/dist/{chunk-A2QF4JUE.js → chunk-X7QBD67R.js}

@@ -6,34 +6,36 @@ import {
   SEQUENCE_COLLECTION,
   compileSequenceFormat,
   resolveSequenceKey
-} from "./chunk-5JB73NMC.js";
+} from "./chunk-EYZ6IQ6X.js";
 import {
   loadVaultPolicy
-} from "./chunk-DIRRS7WP.js";
+} from "./chunk-CRI4OUV4.js";
 import {
   LinkIntegrityError,
   isLinkCollectionName,
   linkCollectionName,
   linkRowKey
-} from "./chunk-AWB5JZW6.js";
+} from "./chunk-JZUV47FZ.js";
 import {
   hashFields,
   validateSatelliteDeclaration
-} from "./chunk-7ITPJFGC.js";
+} from "./chunk-ZAJAVEXY.js";
 import {
   loadFence
-} from "./chunk-Q3XSMOZM.js";
+} from "./chunk-RYCTDFUX.js";
 import {
   InvertedIndex,
   MemoryIndexStore,
   NO_SEARCH,
   VectorSet,
-  buildPersistedIndexCallbacks
-} from "./chunk-P5RY4ZWD.js";
+  buildPersistedIndexCallbacks,
+  encodeVecId,
+  syncTierSearch
+} from "./chunk-OSDB5WW3.js";
 import {
   derivePersistedSchema,
   isZod4Schema
-} from "./chunk-QLLKLFE2.js";
+} from "./chunk-W22IKJE2.js";
 import {
   isBaseLive,
   liveBaseIdSet
@@ -42,7 +44,7 @@ import {
   CustodyApi,
   NO_CARGO,
   NO_CUSTODY
-} from "./chunk-BZO4WCJI.js";
+} from "./chunk-6T2SCQRU.js";
 import {
   ServiceBus,
   WriteHookRegistry,
@@ -50,43 +52,45 @@ import {
   assertCanImport,
   canExport,
   canImport
-} from "./chunk-JOQ53DMI.js";
+} from "./chunk-6QTNZJBS.js";
 import {
   runDrainBarrier
-} from "./chunk-D26JB3LZ.js";
+} from "./chunk-3QCRBHCY.js";
 import {
   OverlayedCollection
-} from "./chunk-A2Y6YFVN.js";
+} from "./chunk-B3HJYUOF.js";
 import {
   NO_ATTESTATION
-} from "./chunk-XHV25KBM.js";
+} from "./chunk-5YOLBEQ6.js";
 import {
   NO_CLASSIFIED,
   guardClassifiedCompat,
   resolveClassifiedFields
-} from "./chunk-PR5LC5YX.js";
+} from "./chunk-MV43JSJF.js";
 import {
   NO_TIERS,
-  classifySealedShred
-} from "./chunk-H6HM6CVR.js";
+  classifySealedShred,
+  syncDerivedOutputs
+} from "./chunk-CDUQTA3Z.js";
 import {
   NO_PORTABILITY
-} from "./chunk-ODJWBC5I.js";
+} from "./chunk-K5IMOGHB.js";
 import {
   PERIODS_COLLECTION,
   PERIOD_ARCHIVES_COLLECTION,
   PERIOD_FREEZES_COLLECTION,
   PERIOD_TARGET_PURGES_COLLECTION,
   periodExclusiveUpperBound
-} from "./chunk-FXK4X4BL.js";
+} from "./chunk-DLG74CNB.js";
 import {
   TxContext,
+  bestEffortRevert,
   revertExecuted
-} from "./chunk-H44ZE4IE.js";
+} from "./chunk-MEFJPTZ4.js";
 import {
   DEFAULT_POSTURE,
   ViaGraph
-} from "./chunk-7QIXUSDQ.js";
+} from "./chunk-HTJQYHZP.js";
 import {
   buildLookupAltIndex,
   buildLookupSnapshotRows,
@@ -102,28 +106,29 @@ import {
   matchesReferencingValue,
   putDerivedOutput,
   registerLookupRefEdges,
+  reservedDictDepsOf,
   resolveDictSource,
   resolveLabelFromMap,
   resolveRollupDeleteIntents,
   runGraphDispatchWave,
   touchFor,
   updateReferencingRecords
-} from "./chunk-DGH65E7Q.js";
+} from "./chunk-4CTHCN4J.js";
 import {
   NO_AGGREGATE,
   Query,
   ScanBuilder
-} from "./chunk-H6CZSDWK.js";
+} from "./chunk-454JXE57.js";
 import {
   EXPORT_AUDIT_COLLECTION,
   createExportBlobsHandle,
   runCompaction
-} from "./chunk-QYPKGVT4.js";
+} from "./chunk-NWSGI5C7.js";
 import {
   LazyQuery,
   decodeIdxId,
   encodeIdxId
-} from "./chunk-3CNQ7FQ3.js";
+} from "./chunk-M4CV6BRT.js";
 import {
   IMPLICIT_LAZY,
   Lru,
@@ -131,17 +136,17 @@ import {
 } from "./chunk-NO272T7Q.js";
 import {
   canonicalGroupKey
-} from "./chunk-IGJHJYM6.js";
+} from "./chunk-LXEXBTKL.js";
 import {
   readPath
 } from "./chunk-IGJCYUT5.js";
 import {
   resolveManagedSecret,
   saveSealedPassphrase
-} from "./chunk-KPGX66PM.js";
+} from "./chunk-3LQ2YKO4.js";
 import {
   dictCollectionName
-} from "./chunk-ELNBMFOS.js";
+} from "./chunk-NJ4EOKMB.js";
 import {
   NO_I18N,
   getAtPath,
@@ -149,12 +154,12 @@ import {
   isDictKeyDescriptor,
   isI18nTextDescriptor,
   isStaticDictDescriptor
-} from "./chunk-BE7N3AXA.js";
+} from "./chunk-6JTIAGHD.js";
 import {
   installViaBinder,
   isViaInstalled,
   viaBinder
-} from "./chunk-ARSAMO24.js";
+} from "./chunk-4VNQOLML.js";
 import {
   NO_TEAM,
   enrollAuthenticator,
@@ -165,7 +170,7 @@ import {
   rotatePassphrase,
   updateAuthenticator,
   writeMagicLinkGrant
-} from "./chunk-IP2QBAGS.js";
+} from "./chunk-AUSTCW2X.js";
 import {
   hasRecoveryEnrolled,
   hasStrongRecoveryEnrolled,
@@ -175,7 +180,7 @@ import {
   mintShamirRecoveryEntry,
   savePaperRecoveryEntries,
   saveShamirRecoveryEntries
-} from "./chunk-6QILBDZU.js";
+} from "./chunk-EVVGJDRQ.js";
 import {
   INDEXED_STORE_POLICY
 } from "./chunk-VQNJ7UZL.js";
@@ -191,21 +196,26 @@ import {
   listUsers,
   loadKeyring,
   updateKeyringIdentity
-} from "./chunk-5ZOSG3RJ.js";
+} from "./chunk-J2ZX2XUV.js";
 import {
   persistDirectoryConfig,
   readDirectoryConfig
-} from "./chunk-4N5QFSNQ.js";
+} from "./chunk-4JBYV75E.js";
 import {
   NO_BROKER,
   buildCredentialBrokerHandle
-} from "./chunk-WTUNZACT.js";
+} from "./chunk-E5ZQT5KX.js";
 import {
   generateULID
 } from "./chunk-ZJADGNYF.js";
+import {
+  assertCutoverTierSafe,
+  assertTierWritable,
+  liveRecordIsElevated
+} from "./chunk-PN2XMATY.js";
 import {
   sha256Hex
-} from "./chunk-25NDNMQ7.js";
+} from "./chunk-Q5VNKNE5.js";
 import {
   NO_FORGET,
   addSubjectRef,
@@ -214,10 +224,10 @@ import {
   readDottedPath,
   rebuildSubjectIndex,
   removeSubjectRef
-} from "./chunk-DJ3VKYFA.js";
+} from "./chunk-5O3XF4DV.js";
 import {
   NO_SEALED_RECORD
-} from "./chunk-CIKY6I4W.js";
+} from "./chunk-QLWMEXCT.js";
 import {
   RecordCodec,
   SEALED_CEK_NS,
@@ -228,20 +238,20 @@ import {
   queryByDet,
   resolveStableCek,
   validateSchemaInput
-} from "./chunk-QQJXBZCO.js";
+} from "./chunk-XDYREZWE.js";
 import {
   buildDeleteMarker,
   buildTombstone,
   isDeleteMarker,
   isTombstone
-} from "./chunk-FQQF23MC.js";
+} from "./chunk-7DSTRQIJ.js";
 import {
   encrypt
-} from "./chunk-HUS3J5WM.js";
+} from "./chunk-CIE2BASH.js";
 import {
   NOYDB_FORMAT_VERSION,
   SealedHandle
-} from "./chunk-CKZW6P5V.js";
+} from "./chunk-JNAI2HN2.js";
 import {
   AlreadyElevatedError,
   AttestationError,
@@ -264,6 +274,7 @@ import {
   NoydbError,
   NumberingUncertaintyError,
   PermissionDeniedError,
+  PersistedIndexCompensationError,
   PolicyDeniedError,
   ReadOnlyError,
   RecoveryNotEnrolledError,
@@ -278,12 +289,13 @@ import {
   USER_ENVELOPE_COLLECTION,
   UniqueConstraintError,
   UnsupportedIndexOptionError,
+  UnsupportedTierCompositionError,
   ValidationError
-} from "./chunk-FH542DDY.js";
+} from "./chunk-BIOUI4HL.js";
 
 // src/port/by/default-provider.ts
 async function createDefaultCoordinationProvider(store) {
-  const { StoreCoordinationProvider } = await import("./store-coordination-provider-HPYVFJCV.js");
+  const { StoreCoordinationProvider } = await import("./store-coordination-provider-64OEZFGS.js");
   return new StoreCoordinationProvider(store);
 }
 
@@ -651,6 +663,34 @@ function exportRedact(coll, record) {
   return via2 ? via2.redactForExport(record) : record;
 }
 
+// src/kernel/lazy-count.ts
+var COUNT_PAGE_SIZE = 1e3;
+function isLive(env, storeCiphertext) {
+  return !!env && !isTombstone(env, storeCiphertext) && !isDeleteMarker(env) && (env._tier ?? 0) === 0;
+}
+async function countLiveEnvelopes(adapter, vault, name, storeCiphertext) {
+  let n = 0;
+  if (adapter.listPage) {
+    let cursor;
+    let page = await adapter.listPage(vault, name, cursor, COUNT_PAGE_SIZE);
+    while (true) {
+      for (const { envelope } of page.items) {
+        if (isLive(envelope, storeCiphertext)) n++;
+      }
+      if (page.nextCursor === null) break;
+      cursor = page.nextCursor;
+      page = await adapter.listPage(vault, name, cursor, COUNT_PAGE_SIZE);
+    }
+    return n;
+  }
+  const ids = await adapter.list(vault, name);
+  for (const id of ids) {
+    const env = await adapter.get(vault, name, id);
+    if (isLive(env, storeCiphertext)) n++;
+  }
+  return n;
+}
+
 // src/with-lookup/indexing/collection-facade.ts
 function readPersistedValue(record, field) {
   if (!field.includes(".")) return record[field];
@@ -736,6 +776,7 @@ async function rebuildIndexes(ctx) {
   for (const recordId of canonicalIds) {
     const envelope = await ctx.adapter.get(ctx.vault, ctx.name, recordId);
     if (!envelope) continue;
+    if ((envelope._tier ?? 0) > 0) continue;
     const record = await ctx.codec.decryptRecord(envelope, { skipValidation: true, id: recordId });
     if (record === null) continue;
     await maintainPersistedIndexesOnPut(ctx, recordId, record, null, envelope._v);
@@ -789,6 +830,7 @@ async function reconcileIndex(ctx, field, opts = {}) {
     if (id.startsWith("_")) continue;
     const env = await ctx.adapter.get(ctx.vault, ctx.name, id);
     if (!env) continue;
+    if ((env._tier ?? 0) > 0) continue;
     const record = await ctx.codec.decryptRecord(env, { skipValidation: true, id });
     if (record === null) continue;
     const live = readPersistedValue(record, field);
@@ -904,6 +946,66 @@ async function purgePersistedIndexes(ctx, id) {
   }
   return { purged, residue };
 }
+async function syncTierIndexes(ctx, id, record, version, priorEnvelope) {
+  if (!ctx.indexes && !ctx.persistedIndexes) return;
+  const prior = await resolveTierSyncPrior(ctx, id, priorEnvelope);
+  if (record === null) {
+    await purgePersistedIndexes(ctx, id);
+    if (prior) ctx.indexes?.remove(id, prior);
+  } else {
+    await maintainPersistedIndexesOnPut(ctx, id, record, prior, version);
+    ctx.indexes?.upsert(id, record, prior);
+  }
+}
+async function resolveTierSyncPrior(ctx, id, priorEnvelope) {
+  const cached = ctx.cache.get(id)?.record;
+  if (cached !== void 0) return cached;
+  if (!ctx.lazy || !priorEnvelope || (priorEnvelope._tier ?? 0) > 0) return null;
+  return await ctx.codec.decryptRecord(priorEnvelope, { skipValidation: true, id });
+}
+
+// src/with-commit/history/strategy.ts
+function notEnabled(op) {
+  return new Error(
+    `${op} requires the history strategy. Import \`{ withHistory }\` from "@noy-db/hub/history" and pass it to \`createNoydb({ historyStrategy: withHistory() })\`.`
+  );
+}
+var NO_HISTORY = {
+  async saveHistory() {
+  },
+  async getHistoryEntries() {
+    throw notEnabled("collection.history()");
+  },
+  async getVersionEnvelope() {
+    throw notEnabled("collection.getVersion()");
+  },
+  async pruneHistory() {
+    return 0;
+  },
+  async clearHistory() {
+    return 0;
+  },
+  async tombstoneHistory() {
+    return 0;
+  },
+  async rewrapHistory() {
+  },
+  async envelopePayloadHash() {
+    return "";
+  },
+  computePatch() {
+    return [];
+  },
+  diff() {
+    throw notEnabled("collection.diff()");
+  },
+  buildLedger() {
+    return null;
+  },
+  buildVaultInstant() {
+    throw notEnabled("vault.at() / vault.timeMachine()");
+  }
+};
 
 // src/with-lookup/indexing/strategy.ts
 var NO_INDEXING = {
@@ -939,10 +1041,53 @@ var PersistedIndexStore = class {
   timer = null;
   lastBuild;
   debounceMs;
+  /**
+   * Bumped by every purge (removePersisted). A save() captured under a since-stale
+   * epoch undoes its own effect once it settles, however it interleaves with the
+   * purge's own delete — a delete can never be overtaken by a save that was
+   * scheduled before it (#725).
+   *
+   * Subsumes the issue's variant (b) (a stale, pre-purge in-memory index getting
+   * paired with a live, post-purge fingerprint and TRUSTED by a cold load, defeating
+   * the fingerprint backstop) for free — no separate handling needed: removePersisted()
+   * always resets `index` to undefined in the SAME synchronous step that bumps the
+   * epoch (below), and the only two paths that can repopulate `index` (ensureBuilt's
+   * cold rebuild, rebuildAndPersist's rebuild) do so strictly from `lastBuild()`, which
+   * the collection wires to read its LIVE cache at call time — not a frozen snapshot.
+   * Cache eviction (the collection dropping the purged/forgotten record) always
+   * precedes removePersisted() in both the elevate and forget call paths (#721's
+   * syncCache eviction / forget's tombstone write both land before syncSearch /
+   * _purgeSearchIndex runs). So any rebuild that executes strictly after
+   * removePersisted() — the only way `index` becomes defined again post-purge —
+   * necessarily observes the post-purge cache, and any rebuild that predates
+   * removePersisted() has its `index` wiped by it. There is no ordering in which a
+   * stale (pre-purge) index survives to be skip-rebuilt and persisted under a
+   * matching live fingerprint. Regression-pinned in
+   * `search-persisted-index-store.test.ts` ("variant (b) is subsumed...").
+   */
+  epoch = 0;
+  /**
+   * Set when a compensating/purging remove() (`compensate()` undoing a stale
+   * save, or `removePersisted()`'s own purge, #764) fails. Unlike the routine
+   * best-effort swallow on the debounced flush path (markDirty's timer
+   * .catch(), below — safe there because the fingerprint backstop forces a
+   * rebuild on the next cold load), a failed removal leaves a resurrected or
+   * un-purged blob at rest whose fingerprint can still match the live cache —
+   * a cold load would TRUST it, not rebuild past it. So this is never silently
+   * dropped: every subsequent store entrypoint (ensureBuilt, rebuildAndPersist,
+   * removePersisted) retries the remove first and refuses to proceed past it
+   * until it succeeds (#725 review), and the raw adapter error is wrapped in
+   * {@link PersistedIndexCompensationError} (#764) so a caller can catch a
+   * stuck removal deliberately instead of an indistinguishable adapter error.
+   * A crash between a landed put and its compensating remove (before this
+   * flag or a retry can run) is a residual gap — see the class doc.
+   */
+  pendingCompensation = false;
   get built() {
     return this.index !== void 0;
   }
   async ensureBuilt(build) {
+    await this.retryPendingCompensation();
     this.lastBuild = build;
     if (this.index !== void 0) return this.index;
     const loaded = await this.cb.load();
@@ -971,26 +1116,70 @@ var PersistedIndexStore = class {
     }
     await this.rebuildAndPersist();
   }
-  /** Delete the persisted blob and drop the in-memory index (forget/erasure). */
+  /** Delete the persisted blob and drop the in-memory index (forget/erasure/tier
+   *  move). A failed purge is wrapped in {@link PersistedIndexCompensationError}
+   *  (#764) and left sticky (`pendingCompensation`) so the next store entrypoint
+   *  retries it — never silently dropped, same posture #725 established for a
+   *  stale save's own compensating remove. */
   async removePersisted() {
     if (this.timer) {
       clearTimeout(this.timer);
       this.timer = null;
     }
+    await this.retryPendingCompensation();
+    this.epoch++;
     this.index = void 0;
-    await this.cb.remove();
+    try {
+      await this.cb.remove();
+      this.pendingCompensation = false;
+    } catch (e) {
+      this.pendingCompensation = true;
+      throw new PersistedIndexCompensationError(e);
+    }
   }
   /** Rebuild using the last known build thunk, then persist. */
   async rebuildAndPersist() {
+    await this.retryPendingCompensation();
     if (this.lastBuild === void 0) return;
     if (this.index === void 0) {
       this.index = InvertedIndex.build(this.lastBuild());
     }
     await this.persist();
   }
+  /** Persist the current index, then undo it if a purge (removePersisted) landed
+   *  while the save was in flight — a delete can never be overtaken by a save
+   *  that was scheduled before it (#725). A failed undo does not silently vanish:
+   *  see `pendingCompensation`. */
   async persist() {
     if (this.index === void 0) return;
-    await this.cb.save(serializeIndex(this.index), this.cb.currentFingerprint());
+    const epoch = this.epoch;
+    await this.cb.save(serializeIndex(this.index), this.cb.currentFingerprint(), () => this.epoch !== epoch);
+    if (this.epoch !== epoch) await this.compensate();
+  }
+  /** Undo a stale save. Failure is sticky, not swallowed: see `pendingCompensation`.
+   *  Wraps the raw adapter error in {@link PersistedIndexCompensationError} (#764) so
+   *  a caller (e.g. the tier ops' `syncTierSearch`) can catch a stuck compensation
+   *  deliberately instead of treating it as an indistinguishable adapter failure. */
+  async compensate() {
+    try {
+      await this.cb.remove();
+      this.pendingCompensation = false;
+    } catch (e) {
+      this.pendingCompensation = true;
+      throw new PersistedIndexCompensationError(e);
+    }
+  }
+  /** Retries a sticky compensation before any store entrypoint proceeds. Failure
+   *  re-wraps the raw adapter error the same way `compensate()` does (#764) — the
+   *  flag stays set (untouched here) so the NEXT entrypoint retries again. */
+  async retryPendingCompensation() {
+    if (!this.pendingCompensation) return;
+    try {
+      await this.cb.remove();
+      this.pendingCompensation = false;
+    } catch (e) {
+      throw new PersistedIndexCompensationError(e);
+    }
   }
 };
 
@@ -1432,6 +1621,54 @@ function buildDescription(input) {
   };
 }
 
+// src/via/blob/binding.ts
+async function eraseBlobs(ctx, cfg) {
+  if (cfg.purgeBlobsForRecord) return cfg.purgeBlobsForRecord(ctx.id);
+  return { shredded: 0, residue: [] };
+}
+function buildBlobDescribeFragment(fields) {
+  return {
+    blobFields: Object.fromEntries(
+      Object.entries(fields).map(([field, p]) => [field, {
+        ...p.retainDays !== void 0 ? { retainDays: p.retainDays } : {},
+        ...p.evictWhen !== void 0 ? { evictWhen: true } : {},
+        ...p.legalHold !== void 0 ? { legalHold: true } : {},
+        ...p.retainUntil !== void 0 ? { retainUntil: true } : {},
+        ...p.external === true ? { external: true } : {},
+        ...p.public === true ? { public: true } : {},
+        ...p.backlink !== void 0 ? { backlink: p.backlink } : {}
+      }])
+    )
+  };
+}
+function blobBinding(cfg) {
+  return {
+    brand: "blob",
+    // encryptedAtRest: 'envelope' — blob chunks are AEAD-encrypted envelopes
+    // in `_blob_chunks` (service-side), not sealed record fields; queryable:
+    // 'none' — nothing indexes blob content; exportable — vault.exportBlobs()
+    // is a first-class door; forgettable — shredAllForRecord participates in
+    // vault.forget().
+    posture: { encryptedAtRest: "envelope", queryable: "none", exportable: true, forgettable: true },
+    covers: (field) => field in cfg.fields,
+    erase: (ctx) => eraseBlobs(ctx, cfg),
+    describeFragment: () => buildBlobDescribeFragment(cfg.fields)
+  };
+}
+function linkBlobVia() {
+  installViaBinder("blob", (c) => blobBinding(c));
+}
+
+// src/port/with/blob-strategy.ts
+linkBlobVia();
+var NO_BLOBS = {
+  openSlot() {
+    throw new Error(
+      'Blob storage is not enabled on this Noydb instance. Import `{ withBlobs }` from "@noy-db/hub/blobs" and pass `withBlobs()` to `createNoydb({ blobStrategy: withBlobs() })`.'
+    );
+  }
+};
+
 // src/with-formula/derivations/stale.ts
 var _staleByRegistry = /* @__PURE__ */ new WeakMap();
 var keyFor = (source, sourceId) => `${source}/${sourceId}`;
@@ -1468,7 +1705,7 @@ async function resolveStaleOnRead(accessor, outputCollection, id) {
     }
     const sourceWithId = { ...source, id };
     if (DerivationExecutor === null) {
-      ({ DerivationExecutor } = await import("./executor-XXGS4S3K.js"));
+      ({ DerivationExecutor } = await import("./executor-OVEXR6RT.js"));
     }
     const ctx = { vault: accessor.getReadOnlyFacade() };
     const result = await DerivationExecutor.run(spec, sourceWithId, 0, strategyHash, ctx);
@@ -1524,47 +1761,6 @@ var NO_CRDT = {
   }
 };
 
-// src/with-commit/history/strategy.ts
-function notEnabled(op) {
-  return new Error(
-    `${op} requires the history strategy. Import \`{ withHistory }\` from "@noy-db/hub/history" and pass it to \`createNoydb({ historyStrategy: withHistory() })\`.`
-  );
-}
-var NO_HISTORY = {
-  async saveHistory() {
-  },
-  async getHistoryEntries() {
-    throw notEnabled("collection.history()");
-  },
-  async getVersionEnvelope() {
-    throw notEnabled("collection.getVersion()");
-  },
-  async pruneHistory() {
-    return 0;
-  },
-  async clearHistory() {
-    return 0;
-  },
-  async tombstoneHistory() {
-    return 0;
-  },
-  async envelopePayloadHash() {
-    return "";
-  },
-  computePatch() {
-    return [];
-  },
-  diff() {
-    throw notEnabled("collection.diff()");
-  },
-  buildLedger() {
-    return null;
-  },
-  buildVaultInstant() {
-    throw notEnabled("vault.at() / vault.timeMachine()");
-  }
-};
-
 // src/with-party/team/sync-strategy.ts
 function notEnabled2(op) {
   return new Error(
@@ -1583,54 +1779,6 @@ var NO_SYNC = {
   }
 };
 
-// src/via/blob/binding.ts
-async function eraseBlobs(ctx, cfg) {
-  if (cfg.purgeBlobsForRecord) return cfg.purgeBlobsForRecord(ctx.id);
-  return { shredded: 0, residue: [] };
-}
-function buildBlobDescribeFragment(fields) {
-  return {
-    blobFields: Object.fromEntries(
-      Object.entries(fields).map(([field, p]) => [field, {
-        ...p.retainDays !== void 0 ? { retainDays: p.retainDays } : {},
-        ...p.evictWhen !== void 0 ? { evictWhen: true } : {},
-        ...p.legalHold !== void 0 ? { legalHold: true } : {},
-        ...p.retainUntil !== void 0 ? { retainUntil: true } : {},
-        ...p.external === true ? { external: true } : {},
-        ...p.public === true ? { public: true } : {},
-        ...p.backlink !== void 0 ? { backlink: p.backlink } : {}
-      }])
-    )
-  };
-}
-function blobBinding(cfg) {
-  return {
-    brand: "blob",
-    // encryptedAtRest: 'envelope' — blob chunks are AEAD-encrypted envelopes
-    // in `_blob_chunks` (service-side), not sealed record fields; queryable:
-    // 'none' — nothing indexes blob content; exportable — vault.exportBlobs()
-    // is a first-class door; forgettable — shredAllForRecord participates in
-    // vault.forget().
-    posture: { encryptedAtRest: "envelope", queryable: "none", exportable: true, forgettable: true },
-    covers: (field) => field in cfg.fields,
-    erase: (ctx) => eraseBlobs(ctx, cfg),
-    describeFragment: () => buildBlobDescribeFragment(cfg.fields)
-  };
-}
-function linkBlobVia() {
-  installViaBinder("blob", (c) => blobBinding(c));
-}
-
-// src/port/with/blob-strategy.ts
-linkBlobVia();
-var NO_BLOBS = {
-  openSlot() {
-    throw new Error(
-      'Blob storage is not enabled on this Noydb instance. Import `{ withBlobs }` from "@noy-db/hub/blobs" and pass `withBlobs()` to `createNoydb({ blobStrategy: withBlobs() })`.'
-    );
-  }
-};
-
 // src/kernel/via/compose.ts
 function via(...descriptors) {
   if (descriptors.length === 0) {
@@ -1908,6 +2056,34 @@ function resolveCollectionConfig(opts) {
       `Collection "${opts.name}": embeddings are not supported on CRDT collections (L2). Use a non-CRDT collection for semantic search.`
     );
   }
+  if (opts.tiers && opts.tiers.length > 0 && opts.blobFields !== void 0 && Object.keys(opts.blobFields).length > 0 && opts.perRecordKeys !== true) {
+    throw new UnsupportedTierCompositionError(
+      "blobs",
+      `Collection "${opts.name}": tiered collections that declare blobFields require \`perRecordKeys: true\` \u2014 legacy (non-perRecordKeys) blobs have no per-blob content CEK and cannot be tier-isolated on elevate/demote.`
+    );
+  }
+  if (opts.tiers && opts.tiers.length > 0 && opts.blobFields !== void 0) {
+    for (const [field, policy] of Object.entries(opts.blobFields)) {
+      if (policy?.external && policy.public === true) {
+        throw new UnsupportedTierCompositionError(
+          "blobs",
+          `Collection "${opts.name}": blob field "${field}" cannot be both \`external: true, public: true\` and declared on a tiered collection \u2014 the object key is deterministic and its bytes are world-readable by design, so tier-invisibility can never be enforced for it once elevated. Use a private/presigned external field (\`public\` omitted or \`false\`) or move this field to a non-tiered collection.`
+        );
+      }
+    }
+  }
+  if (opts.tiers && opts.tiers.length > 0 && opts.encrypted === false) {
+    throw new UnsupportedTierCompositionError(
+      "plaintext",
+      `Collection "${opts.name}": tiers are per-tier ENCRYPTION keys \u2014 a plaintext collection (\`encrypted: false\`) has nothing to re-key, so \`putAtTier\`/\`elevate\` would encrypt/decrypt incoherently. Use an encrypted collection.`
+    );
+  }
+  if (opts.tiers && opts.tiers.length > 0 && opts.crdt !== void 0 && ((opts.derivationSource?.registry().strategiesForSource(opts.name).length ?? 0) > 0 || (opts.materializedViewSource?.registry().mvsForSource(opts.name).length ?? 0) > 0)) {
+    throw new UnsupportedTierCompositionError(
+      "crdt-derivation",
+      `Collection "${opts.name}": tiers + crdt cannot be combined with this collection acting as a derivation/rollup source (#739) \u2014 the tier-aware pre-move decode \`syncDerived\` uses on elevate()/demote() does not resolve CRDT state, so a registered derivation/rollup reads raw CrdtState instead of the record and silently no-ops. Use a non-CRDT collection for a tiered derivation/rollup source, or move the derivation off this collection.`
+    );
+  }
   const effectiveViaFields = mergeViaFields(opts);
   const resolvedClassified = opts.classifiedFields !== void 0 ? resolveClassifiedFields(opts.name, opts.classifiedFields) : void 0;
   const allComputed = unifyComputedFields(opts, effectiveViaFields.computedFields);
@@ -2007,6 +2183,7 @@ function resolveCollectionConfig(opts) {
     reconcileOnOpen: opts.reconcileOnOpen ?? "off",
     getDEK: opts.getDEK,
     onDirty: opts.onDirty,
+    tabCoordinated: opts.tabCoordinated,
     historyConfig: opts.historyConfig ?? { enabled: true },
     historyConfigExplicit: opts.historyConfigExplicit ?? false,
     schema: opts.schema,
@@ -2056,7 +2233,9 @@ function resolveCollectionConfig(opts) {
     tiersStrategy: opts.tiersStrategy ?? NO_TIERS,
     searchStrategy: opts.searchStrategy ?? NO_SEARCH,
     tierMode: opts.tierMode ?? "invisibility",
+    blobTierPolicy: opts.blobTierPolicy ?? "isolate",
     onCrossTierAccess: opts.onCrossTierAccess,
+    addSubjectRef: opts.addSubjectRef,
     deterministicFields,
     sensitiveFields,
     vdigFields,
@@ -2069,7 +2248,7 @@ function resolveCollectionConfig(opts) {
 // src/with-formula/computed/lazy.ts
 var fn = null;
 async function loadEvalComputedFields() {
-  fn ??= (await import("./computed-W6MVAMWZ.js")).evalComputedFields;
+  fn ??= (await import("./computed-ZIQTYTDI.js")).evalComputedFields;
   return fn;
 }
 
@@ -2108,6 +2287,8 @@ var Collection = class {
   activeTxId;
   getDEK;
   onDirty;
+  /** #693: live check — true when multi-tab write-propagation is active; gates the #606 marker-id-set fallback read. */
+  tabCoordinated;
   historyConfig;
   /** True when the caller explicitly provided a `historyConfig` option (vs. inheriting the vault default). */
   historyConfigExplicit;
@@ -2123,6 +2304,8 @@ var Collection = class {
   blobStrategy;
   objectStore;
   blobFields;
+  blobTierPolicy;
+  // #724 T2/T3
   aggregateStrategy;
   crdtStrategy;
   tiersStrategy;
@@ -2134,6 +2317,20 @@ var Collection = class {
   // doesn't need a runtime branch on every cache access.
   cache = /* @__PURE__ */ new Map();
   hydrated = false;
+  /**
+   * #606: ids known to carry a delete marker in the store — lets the #589
+   * re-create version-continuity gate in `_putInternal` read the store ONLY
+   * for a known marker prior, instead of unconditionally on every insert.
+   * Populated on hydration (`ensureHydrated`/`hydrateFromSnapshot`), local
+   * delete (`_doDelete`), and the sync/tab/cutover choke point
+   * (`_invalidateCacheEntry`). Accepted drift: `vault._purgeDeleteMarkers`/
+   * `_purgeMarkersOn` remove markers directly on the raw store, bypassing
+   * Collection, so this set can hold stale ids after a purge on an
+   * already-loaded collection — perf-only and self-healing (a stale id just
+   * costs one `adapter.get` that returns non-marker/null, and version
+   * resolution falls back to 1 correctly). Do not try to wire purge into it.
+   */
+  markerIds = /* @__PURE__ */ new Set();
   /**
    * Lazy mode flag. `true` when constructed with `prefetch: false`.
    * In lazy mode the cache is bounded by an LRU and `list()`/`query()`
@@ -2162,8 +2359,7 @@ var Collection = class {
   indexState;
   /**
    * In-memory unique-constraint enforcement for eager mode.
-   * `null` when no `unique:true` indexes are declared on this collection,
-   * or when the collection is in lazy mode (which throws at registration).
+   * `null` when no `unique:true` indexes are declared on this collection, or when the collection is in lazy mode (which throws at registration).
    */
   uniqueConstraints;
   /**
@@ -2184,8 +2380,7 @@ var Collection = class {
     return this.indexState.getEagerIndexes();
   }
   /**
-   * Accessor for the persisted-mirror (lazy-mode) index. Returns `null`
-   * when indexing is disabled or the collection is in eager mode.
+   * Accessor for the persisted-mirror (lazy-mode) index. Returns `null` when indexing is disabled or the collection is in eager mode.
    */
   get persistedIndexes() {
     return this.indexState.getPersistedIndexes();
@@ -2348,11 +2543,10 @@ var Collection = class {
   tiers;
   tierMode;
   onCrossTierAccess;
+  addSubjectRef;
+  // #766: putAtTier's first-write subject-index registration (wired by the Vault; undefined ⇒ no forget-subject field declared)
   /**
-   * Optional reference to the vault-level hash-chained audit
-   * log. When present, every successful `put()` and `delete()` appends
-   * an entry to the ledger AFTER the adapter write succeeds (so a
-   * failed adapter write never produces an orphan ledger entry).
+   * Optional reference to the vault-level hash-chained audit log. When present, every successful `put()` and `delete()` appends an entry to the ledger AFTER the adapter write succeeds (so a failed adapter write never produces an orphan ledger entry).
    *
    * The ledger is always a vault-wide singleton — all
    * collections in the same vault share the same LedgerStore.
@@ -2444,6 +2638,7 @@ var Collection = class {
     this.blobStrategy = cfg.blobStrategy;
     this.objectStore = cfg.objectStore;
     this.blobFields = cfg.blobFields;
+    this.blobTierPolicy = cfg.blobTierPolicy ?? "isolate";
     this.aggregateStrategy = cfg.aggregateStrategy;
     this.crdtStrategy = cfg.crdtStrategy;
     this.tiersStrategy = cfg.tiersStrategy;
@@ -2453,6 +2648,7 @@ var Collection = class {
     this.reconcileOnOpen = cfg.reconcileOnOpen;
     this.getDEK = cfg.getDEK;
     this.onDirty = cfg.onDirty;
+    this.tabCoordinated = cfg.tabCoordinated;
     this.historyConfig = cfg.historyConfig;
     this.historyConfigExplicit = cfg.historyConfigExplicit;
     this.schema = cfg.schema;
@@ -2488,6 +2684,7 @@ var Collection = class {
     this.tiers = cfg.tiers;
     this.tierMode = cfg.tierMode;
     this.onCrossTierAccess = cfg.onCrossTierAccess;
+    this.addSubjectRef = cfg.addSubjectRef;
     this.deterministicFields = cfg.deterministicFields;
     this.sensitiveFields = cfg.sensitiveFields;
     this.perRecordCek = cfg.perRecordCek;
@@ -2540,9 +2737,7 @@ var Collection = class {
         const remoteJson = await this.codec.decryptJsonString(remote, id);
         if (localJson === null) return local;
         if (remoteJson === null) return remote;
-        const localState = JSON.parse(localJson);
-        const remoteState = JSON.parse(remoteJson);
-        const merged = this.crdtStrategy.mergeCrdtStates(localState, remoteState);
+        const merged = this.crdtStrategy.mergeCrdtStates(JSON.parse(localJson), JSON.parse(remoteJson));
         const mergedVersion = Math.max(local._v, remote._v) + 1;
         const cek = this.perRecordCek ? await this.resolveRecordCek(id) : void 0;
         return this.codec.encryptJsonString(JSON.stringify(merged), mergedVersion, cek);
@@ -2611,6 +2806,7 @@ var Collection = class {
       lazy: this.lazy
     });
     this.indexes?.setCanonicalizer((f, v) => this.via?.canonicalizeIndexKey(f, v));
+    this.persistedIndexes?.setCanonicalizer((f, v) => this.via?.canonicalizeIndexKey(f, v));
     this.uniqueConstraints = buildUniqueConstraintSet(this.name, opts.indexes, {
       lazy: this.lazy,
       crdt: this.crdtMode != null,
@@ -2856,7 +3052,7 @@ var Collection = class {
     }
     await this.onAccess?.("find", "*");
     if (hits.length === 0) return [];
-    const { verifyDigestField } = await import("./verify-66RHOW7N.js");
+    const { verifyDigestField } = await import("./verify-ZASTRNPR.js");
     const policy = {
       normalize: spec.verifyNormalize ?? "password",
       notLastN: spec.notLastN ?? 0,
@@ -2956,6 +3152,7 @@ var Collection = class {
     const virtualMoney = resolveVirtualMoneyFields(Object.keys(moneyFields), (f) => this.via?.bindings.find((b) => b.brand === "computed")?.covers?.(f) ?? false);
     this.via = ViaPipeline.build([viaBinder("money")({ moneyFields, ...virtualMoney.size > 0 ? { virtualMoneyFields: virtualMoney } : {} }), ...this.via?.bindings ?? []], this.via?.taint);
     this.moneyFields = moneyFields;
+    if (this.hydrated) this.rebuildEagerIndexesFromCache();
   }
   /** @internal — attach computed fields post-construction. See {@link _applyMoneyFields}. */
   _applyComputed(computed) {
@@ -3040,6 +3237,20 @@ var Collection = class {
    *          `null` if not found.
    */
   async get(id, locale) {
+    const record = await this.#getRaw(id);
+    if (record === null) return null;
+    return this.applyLocaleToRecord(record, locale);
+  }
+  /**
+   * Raw fetch: cache/adapter → decrypt → tombstone-null, WITHOUT `present()`.
+   * Split out of `get()` (#684) so `lazyQuery()`'s `LazyQuerySource` can hand
+   * `LazyQuery`'s post-filter the RAW (stored-form) record a `clause.via`
+   * evaluator (e.g. money) needs — `present()`/locale decode is applied only
+   * to survivors, via `applyLocaleToRecord` (see `lazyQuery()` below). `get()`
+   * itself is unchanged: raw fetch, then `applyLocaleToRecord`, same order
+   * as before this split.
+   */
+  async #getRaw(id) {
     if (this.derivationSource !== void 0) {
       const registry = this.derivationSource.registry();
       if (registry.strategiesProducingOutput(this.name).length > 0) {
@@ -3047,7 +3258,7 @@ var Collection = class {
       }
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-NXPT56JA.js");
+      const { resolveStaleMVOnRead } = await import("./stale-OSQ7J3AA.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name, this.#dispatchCtx({ collection: this.name, id: "resolve-on-read" }));
     }
     let record;
@@ -3058,7 +3269,7 @@ var Collection = class {
       } else {
         const envelope = await this.adapter.get(this.vault, this.name, id);
         if (!envelope) return null;
-        if (isTombstone(envelope, this.storeCiphertext) || isDeleteMarker(envelope)) return null;
+        if (isTombstone(envelope, this.storeCiphertext) || isDeleteMarker(envelope) || (envelope._tier ?? 0) > 0) return null;
         record = await this.codec.decryptRecord(envelope, { id, sealedAsHandles: true });
         if (record === null) return null;
         this.lru.set(id, { record, version: envelope._v }, estimateRecordBytes(record));
@@ -3070,7 +3281,7 @@ var Collection = class {
     }
     if (record === null) return null;
     await this.onAccess?.("get", id);
-    return this.applyLocaleToRecord(record, locale);
+    return record;
   }
   /**
    * Return the raw CRDT state for a record.
@@ -3085,7 +3296,7 @@ var Collection = class {
       );
     }
     const envelope = await this.adapter.get(this.vault, this.name, id);
-    if (!envelope) return null;
+    if (!envelope || (envelope._tier ?? 0) > 0) return null;
     const json = await this.codec.decryptJsonString(envelope);
     if (json === null) return null;
     return JSON.parse(json);
@@ -3202,7 +3413,7 @@ var Collection = class {
       const cached = this.lru.get(id);
       if (cached) return cached.record;
       const env = await this.adapter.get(this.vault, this.name, id);
-      if (!env) return void 0;
+      if (!env || (env._tier ?? 0) > 0) return void 0;
       const rec = await this.codec.decryptRecord(env, { id });
       return rec === null ? void 0 : rec;
     }
@@ -3250,7 +3461,7 @@ var Collection = class {
       const cached2 = this.lru.get(id);
       if (cached2) return { record: cached2.record, version: cached2.version };
       const env = await this.adapter.get(this.vault, this.name, id);
-      if (!env) return { record: null, version: 0 };
+      if (!env || (env._tier ?? 0) > 0) return { record: null, version: 0 };
       return { record: await this.codec.decryptRecord(env, { skipValidation: true, id }) ?? null, version: env._v };
     }
     await this.ensureHydrated();
@@ -3272,7 +3483,7 @@ var Collection = class {
   async resolvePriorValues(id) {
     if (this.sensitiveFields.size > 0 || this.via?.hasAtRestHooks === true) {
       const env = await this.adapter.get(this.vault, this.name, id);
-      if (!env || isTombstone(env, this.storeCiphertext)) return void 0;
+      if (!env || isTombstone(env, this.storeCiphertext) || (env._tier ?? 0) > 0) return void 0;
       const rec = await this.codec.decryptRecord(env, { skipValidation: true, id });
       return rec === null ? void 0 : { record: rec, version: env._v };
     }
@@ -3284,11 +3495,8 @@ var Collection = class {
     if (!this.subsystemBus.gateNeedsPrior(point)) return { env: null, record: null, elided: true };
     const env = await this.adapter.get(this.vault, this.name, id);
     if (!env) return { env: null, record: null, elided: false };
-    try {
-      return { env, record: await this.codec.decryptRecord(env, { skipValidation: true, id }), elided: false };
-    } catch {
-      return { env, record: null, elided: false };
-    }
+    if ((env._tier ?? 0) > 0) return { env, record: null, elided: false };
+    return { env, record: await this.codec.decryptRecord(env, { skipValidation: true, id }), elided: false };
   }
   /**
    * Wraps {@link RecordCodec.toCacheRecord} with an additional strip for
@@ -3310,6 +3518,7 @@ var Collection = class {
     if (!hasWritePermission(this.keyring, this.name)) {
       throw new ReadOnlyError();
     }
+    await assertTierWritable(this.adapter, this.vault, this.name, id, this.tiers !== null);
     if (this.via) record = this.via.ingest(record);
     if (this.subsystemBus?.hasGateHandlers("beforePut")) {
       const { env: existingEnv, record: existingRecord } = await this.resolveGatePrior("beforePut", id);
@@ -3375,8 +3584,7 @@ var Collection = class {
             }
           }
         }
-        const arr = Array.isArray(record) ? record : [record];
-        crdtState = this.crdtStrategy.buildRgaState(arr, existingState, generateULID);
+        crdtState = this.crdtStrategy.buildRgaState(Array.isArray(record) ? record : [record], existingState, generateULID);
       } else {
         crdtState = { _crdt: "yjs", update: record };
       }
@@ -3388,9 +3596,7 @@ var Collection = class {
       const existingResolvedRecord = existingEnvelope ? await this.codec.decryptRecord(existingEnvelope, { skipValidation: true }) : null;
       const existingResolved = existingResolvedRecord !== null ? { record: existingResolvedRecord, version: existingVersion } : void 0;
       if (existingResolved && this.historyConfig.enabled !== false) {
-        const vdigCtx2 = this.vdigFields !== null ? { id, prev: existingEnvelope } : void 0;
-        const histEnvelope = await this.codec.encryptRecord(existingResolved.record, existingResolved.version, cek2, void 0, void 0, vdigCtx2, id);
-        await this.historyStrategy.saveHistory(this.adapter, this.vault, this.name, id, histEnvelope);
+        await this.historyStrategy.saveHistory(this.adapter, this.vault, this.name, id, await this.codec.encryptRecord(existingResolved.record, existingResolved.version, cek2, void 0, void 0, this.vdigFields !== null ? { id, prev: existingEnvelope } : void 0, id));
         this.emitter.emit("history:save", { vault: this.vault, collection: this.name, id, version: existingResolved.version });
         if (this.historyConfig.maxVersions) {
           await this.historyStrategy.pruneHistory(this.adapter, this.vault, this.name, id, { keepVersions: this.historyConfig.maxVersions });
@@ -3443,29 +3649,27 @@ var Collection = class {
     }
     let version = existing ? existing.version + 1 : 1;
     if (!existing && this.onDirty) {
-      if (priorRaw === null) priorRaw = await this.adapter.get(this.vault, this.name, id);
+      if (priorRaw === null && (this.markerIds.has(id) || this.tabCoordinated?.())) {
+        priorRaw = await this.adapter.get(this.vault, this.name, id);
+      }
       if (priorRaw && isDeleteMarker(priorRaw)) version = priorRaw._v + 1;
     }
     this.uniqueConstraints?.check(id, record);
     const cek = this.perRecordCek ? await this.resolveRecordCek(id) : void 0;
     const vdigCtx = this.vdigFields !== null ? { id, prev: await this.adapter.get(this.vault, this.name, id) } : void 0;
     if (existing && this.historyConfig.enabled !== false) {
-      const historyEnvelope = await this.codec.encryptRecord(existing.record, existing.version, cek, void 0, void 0, vdigCtx, id);
-      await this.historyStrategy.saveHistory(this.adapter, this.vault, this.name, id, historyEnvelope);
+      await this.historyStrategy.saveHistory(this.adapter, this.vault, this.name, id, await this.codec.encryptRecord(existing.record, existing.version, cek, void 0, void 0, vdigCtx, id));
       this.emitter.emit("history:save", {
         vault: this.vault,
         collection: this.name,
         id,
         version: existing.version
       });
-      if (this.historyConfig.maxVersions) {
-        await this.historyStrategy.pruneHistory(this.adapter, this.vault, this.name, id, {
-          keepVersions: this.historyConfig.maxVersions
-        });
-      }
+      if (this.historyConfig.maxVersions) await this.historyStrategy.pruneHistory(this.adapter, this.vault, this.name, id, { keepVersions: this.historyConfig.maxVersions });
     }
     const envelope = await this.codec.encryptRecord(record, version, cek, options?.source, options?.sourceTs, vdigCtx, id);
     await this.adapter.put(this.vault, this.name, id, envelope);
+    this.markerIds.delete(id);
     await this._ensureClassifiedMarker();
     if (this.embeddings) {
       await this.searchStrategy.embedOnWrite(this.searchContext(), id, record, version);
@@ -3523,7 +3727,7 @@ var Collection = class {
         if (wave?.seen(`mv\0${reg.spec.name}`)) continue;
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-GTVSUUBX.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-UNEH5ZYH.js"));
         }
         await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
@@ -3533,7 +3737,7 @@ var Collection = class {
         });
       } else if (mode === "lazy") {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-NXPT56JA.js");
+          staleHelpers = await import("./stale-OSQ7J3AA.js");
         }
         staleHelpers.markMVStale(registry, reg.spec.name);
       }
@@ -3737,7 +3941,7 @@ var Collection = class {
         continue;
       }
       if (DerivationExecutor === null) {
-        ({ DerivationExecutor } = await import("./executor-XXGS4S3K.js"));
+        ({ DerivationExecutor } = await import("./executor-OVEXR6RT.js"));
       }
       for (const run of runs) {
         const ctx = { vault: this.derivationSource.getReadOnlyFacade() };
@@ -3757,7 +3961,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-CKYFH33E.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-A765THMX.js");
             const prior = await loadFanoutSidecar(this.adapter, this.vault, spec.source, run.runId, key, this.getDEK, this.storeCiphertext);
             const prevKeys = new Set(prior?.keys ?? []);
             const newKeysList = out.entries.map((e) => e.key);
@@ -3867,13 +4071,11 @@ var Collection = class {
     }
   }
   /**
-   * @internal — bulk-rewrite every record through a cutover transform.
-   * Raw adapter path (bypasses the write gate + guards — the transform is
-   * trusted and runs only during the `migrating` phase). Bumps each
-   * record's `_v` and appends a ledger `op:'migration'` entry.
+   * @internal — bulk-rewrite every record through a cutover transform. Raw adapter path (bypasses the write gate + guards — the transform is trusted and runs only during the `migrating` phase). Bumps each record's `_v` and appends a ledger `op:'migration'` entry. #708: refuses BEFORE any rewrite if a live record is elevated (assertCutoverTierSafe) — demote it first.
    */
   async _applyCutoverTransform(transform) {
     const ids = await this.adapter.list(this.vault, this.name);
+    await assertCutoverTierSafe(this.adapter, this.vault, this.name, this.tiers !== null);
     let count = 0;
     for (const id of ids) {
       const env = await this.adapter.get(this.vault, this.name, id);
@@ -3884,8 +4086,7 @@ var Collection = class {
       const next = transform(record);
       const nextVersion = (env._v ?? 0) + 1;
       const cek = this.perRecordCek ? await this.resolveRecordCek(id) : void 0;
-      const newEnv = await this.codec.encryptRecord(next, nextVersion, cek, void 0, void 0, this.vdigFields !== null ? { id, prev: env } : void 0, id);
-      await this.adapter.put(this.vault, this.name, id, newEnv);
+      await this.adapter.put(this.vault, this.name, id, await this.codec.encryptRecord(next, nextVersion, cek, void 0, void 0, this.vdigFields !== null ? { id, prev: env } : void 0, id));
       await this._onRecordMutated(id, "put", "cutover");
       if (this.ledger) {
         await this.ledger.append({
@@ -3957,13 +4158,14 @@ var Collection = class {
         priorEnvelope: prior
       });
     }
-    await this._doDelete(id, true);
-    return true;
+    return await this._doDelete(id, true);
   }
   async _doDelete(id, internal) {
     if (!hasWritePermission(this.keyring, this.name)) {
       throw new ReadOnlyError();
     }
+    await assertTierWritable(this.adapter, this.vault, this.name, id, !internal && this.tiers !== null);
+    if (internal && this.tiers !== null && await liveRecordIsElevated(this.adapter, this.vault, this.name, id)) return false;
     if (this.subsystemBus?.hasGateHandlers("beforeDelete")) {
       const { env: existingEnv, record: existingRecord, elided } = await this.resolveGatePrior("beforeDelete", id);
       if (existingEnv || elided) {
@@ -4001,17 +4203,17 @@ var Collection = class {
     if (existing && this.historyConfig.enabled !== false) {
       const cek = this.perRecordCek ? await this.resolveRecordCek(id) : void 0;
       const prevForVdig = this.vdigFields !== null ? await this.adapter.get(this.vault, this.name, id) : null;
-      const historyEnvelope = await this.codec.encryptRecord(existing.record, existing.version, cek, void 0, void 0, this.vdigFields !== null ? { id, prev: prevForVdig } : void 0, id);
-      await this.historyStrategy.saveHistory(this.adapter, this.vault, this.name, id, historyEnvelope);
+      await this.historyStrategy.saveHistory(this.adapter, this.vault, this.name, id, await this.codec.encryptRecord(existing.record, existing.version, cek, void 0, void 0, this.vdigFields !== null ? { id, prev: prevForVdig } : void 0, id));
     }
     const previousEnvelope = await this.adapter.get(this.vault, this.name, id);
     const previousPayloadHash = await this.historyStrategy.envelopePayloadHash(previousEnvelope);
     let markerVersion;
     if (this.onDirty) {
       const live = previousEnvelope;
-      if (!live || isTombstone(live, this.storeCiphertext) || isDeleteMarker(live)) return;
+      if (!live || isTombstone(live, this.storeCiphertext) || isDeleteMarker(live)) return false;
       markerVersion = live._v + 1;
       await this.adapter.put(this.vault, this.name, id, buildDeleteMarker(markerVersion, this.keyring.userId));
+      this.markerIds.add(id);
     } else {
       await this.adapter.delete(this.vault, this.name, id);
     }
@@ -4043,6 +4245,7 @@ var Collection = class {
       await this.dispatchArrayDerivationsOnDelete(id);
       if (existing) await this.dispatchRollupsOnDelete(id, existing.record);
     }
+    return true;
   }
   /**
    * @internal — GDPR crypto-shred a LIVE record to a tombstone.
@@ -4116,7 +4319,7 @@ var Collection = class {
           continue;
         }
         if (helpers === null) {
-          helpers = await import("./fanout-sidecar-CKYFH33E.js");
+          helpers = await import("./fanout-sidecar-A765THMX.js");
         }
         const sidecar = await helpers.loadFanoutSidecar(this.adapter, this.vault, spec.source, id, outputKey, this.getDEK, this.storeCiphertext);
         if (!sidecar) continue;
@@ -4132,39 +4335,49 @@ var Collection = class {
   /**
    * Mirror of {@link dispatchMaterializedViews} for the delete/forget path — no `_materializedFrom`
    * skip (record's gone); the `internal` gate at `_doDelete` is the recursion guard. Returns the
-   * row count TOMBSTONED across every eager MV sourced here (#638 T6 — `forgetDerivedFanout`'s
-   * `derivedRecordsErased`); a lazy MV only flips its stale bit (0 contribution — resolved on read).
+   * row count TOMBSTONED across EVERY MV sourced here (#638 T6 — `forgetDerivedFanout`'s
+   * `derivedRecordsErased`) — eager AND lazy/manual `invalidateMVAtRest` purges both contribute now
+   * (#761 item 1, previously eager-only); lazy persists a stale mark for cold-session recompute;
+   * manual serves empty until `refreshView()`. `residueUndecodable`/`residueDeclined` (#776/#785) carry `outputCollection:id` entries whose ownership stamp `invalidateMVAtRest` could not decode, resp. decoded+stamp-matched but declined erasure — surfaced, not erased.
    * @internal
    */
   async dispatchMaterializedViewsOnDelete(id) {
-    if (this.materializedViewSource === void 0) return 0;
+    if (this.materializedViewSource === void 0) return { deleted: 0, residueUndecodable: [], residueDeclined: [] };
     const registry = this.materializedViewSource.registry();
     const mvs = registry.mvsForSource(this.name);
-    if (mvs.length === 0) return 0;
+    if (mvs.length === 0) return { deleted: 0, residueUndecodable: [], residueDeclined: [] };
     let executor = null;
     let staleHelpers = null;
     let deleted = 0;
+    const residueUndecodable = [];
+    const residueDeclined = [];
     for (const reg of mvs) {
       const mode = reg.spec.refresh;
       if (mode === "eager") {
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-GTVSUUBX.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-UNEH5ZYH.js"));
         }
-        deleted += (await executor.refresh(reg, {
+        const rr = await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
           getActiveTxContext: () => this.materializedViewSource.getActiveTxContext(),
           getQueryContext: () => this.materializedViewSource.getQueryContext(),
           dispatchCtx: this.#dispatchCtx({ collection: this.name, id })
-        })).deleted;
-      } else if (mode === "lazy") {
+        });
+        deleted += rr.deleted;
+        residueUndecodable.push(...rr.residueUndecodable);
+        residueDeclined.push(...rr.residueDeclined);
+      } else {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-NXPT56JA.js");
+          staleHelpers = await import("./stale-OSQ7J3AA.js");
         }
-        staleHelpers.markMVStale(registry, reg.spec.name);
+        const inv = await staleHelpers.invalidateMVAtRest(this.materializedViewSource, reg, mode);
+        deleted += inv.deleted;
+        residueUndecodable.push(...inv.residueUndecodable.map((rid) => `${reg.outputCollection}:${rid}`));
+        residueDeclined.push(...inv.residueDeclined.map((rid) => `${reg.outputCollection}:${rid}`));
       }
     }
-    return deleted;
+    return { deleted, residueUndecodable, residueDeclined };
   }
   /**
    * List all records in the collection.
@@ -4183,7 +4396,7 @@ var Collection = class {
       );
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-NXPT56JA.js");
+      const { resolveStaleMVOnRead } = await import("./stale-OSQ7J3AA.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name, this.#dispatchCtx({ collection: this.name, id: "resolve-on-read" }));
     }
     await this.ensureHydrated();
@@ -4222,6 +4435,11 @@ var Collection = class {
   similarTo(vector, opts = {}) {
     return this.searchStrategy.similarTo(this.searchContext(), vector, opts);
   }
+  /** Opt-in bulk `_vec` re-derive (#788) — a plain collection has nothing to rebuild; gated behind `searchStrategy: withSearch()` otherwise. */
+  rebuildEmbeddings() {
+    if (!this.embeddings) return Promise.resolve({ rebuilt: 0, skipped: 0 });
+    return this.searchStrategy.rebuildEmbeddings(this.searchContext());
+  }
   /**
    * Bind the {@link SearchContext} the search/retrieval surface needs. The
    * `cache` is the SAME `Map` reference the eager read/write path owns (passed
@@ -4341,8 +4559,7 @@ var Collection = class {
           if (op.collectionName === this.name) {
             await this._invalidateCacheEntry(op.id);
           } else if (this.derivationSource) {
-            const sibling = this.derivationSource.getCollection(op.collectionName);
-            await sibling._invalidateCacheEntry(op.id);
+            await this.derivationSource.getCollection(op.collectionName)._invalidateCacheEntry(op.id);
           }
         } catch {
         }
@@ -4552,8 +4769,10 @@ var Collection = class {
       id,
       options
     );
+    if (await liveRecordIsElevated(this.adapter, this.vault, this.name, id)) return [];
     const entries = [];
     for (const env of envelopes) {
+      if ((env._tier ?? 0) > 0) continue;
       const record = await this.codec.decryptRecord(env, { skipValidation: true, id });
       if (record === null) continue;
       entries.push({
@@ -4582,7 +4801,7 @@ var Collection = class {
       id,
       version
     );
-    if (!envelope) return null;
+    if (!envelope || (envelope._tier ?? 0) > 0 || await liveRecordIsElevated(this.adapter, this.vault, this.name, id)) return null;
     return this.codec.decryptRecord(envelope, { skipValidation: true, id });
   }
   /** Revert a record to a past version. Creates a new version with the old content. */
@@ -4600,8 +4819,7 @@ var Collection = class {
    */
   async diff(id, versionA, versionB) {
     const recordA = versionA === 0 ? null : await this.resolveVersion(id, versionA);
-    const recordB = versionB === void 0 || versionB === 0 ? versionB === 0 ? null : await this.resolveCurrentOrVersion(id) : await this.resolveVersion(id, versionB);
-    return this.historyStrategy.diff(recordA, recordB);
+    return this.historyStrategy.diff(recordA, versionB === void 0 || versionB === 0 ? versionB === 0 ? null : await this.resolveCurrentOrVersion(id) : await this.resolveVersion(id, versionB));
   }
   /** Resolve a version: try history first, then check if it's the current version. */
   async resolveVersion(id, version) {
@@ -4643,14 +4861,13 @@ var Collection = class {
   /**
    * Count records in the collection.
    *
-   * In eager mode this returns the in-memory cache size (instant). In
-   * lazy mode it asks the adapter via `list()` to enumerate ids — slower
-   * but still correct, and avoids loading any record bodies into memory.
+   * In eager mode this returns the in-memory cache size (instant). In lazy
+   * mode it counts only LIVE tier-0 envelopes via envelope inspection — no
+   * record bodies loaded — matching eager's tombstone/tier exclusion (#706).
    */
   async count() {
     if (this.lazy) {
-      const ids = await this.adapter.list(this.vault, this.name);
-      return ids.length;
+      return countLiveEnvelopes(this.adapter, this.vault, this.name, this.storeCiphertext);
     }
     await this.ensureHydrated();
     return this.cache.size;
@@ -4690,7 +4907,7 @@ var Collection = class {
     for (let i = start; i < end; i++) {
       const id = ids[i];
       const envelope = await this.adapter.get(this.vault, this.name, id);
-      if (envelope) {
+      if (envelope && (envelope._tier ?? 0) === 0) {
         const record = await this.codec.decryptRecord(envelope, { id, sealedAsHandles: true });
         if (record === null) continue;
         items.push(record);
@@ -4772,6 +4989,7 @@ var Collection = class {
   async decryptPage(items) {
     const out = [];
     for (const { id, envelope } of items) {
+      if ((envelope._tier ?? 0) > 0) continue;
       const record = await this.codec.decryptRecord(envelope, { id, sealedAsHandles: true });
       if (record === null) continue;
       out.push({ id, record, version: envelope._v });
@@ -4813,17 +5031,18 @@ var Collection = class {
   async _compensateRevertedWrite(id) {
     await this._invalidateCacheEntry(id);
     await this.onDirty?.(this.name, id, "revert", 0);
-    const restored = await this.get(id);
-    this.emitter.emit("change", { vault: this.vault, collection: this.name, id, action: restored !== null ? "put" : "delete" });
+    this.emitter.emit("change", { vault: this.vault, collection: this.name, id, action: await this.get(id) !== null ? "put" : "delete" });
   }
   async _invalidateCacheEntry(id) {
     if (this.lazy && this.lru) {
       this.lru.remove(id);
       return;
     }
+    const envelope = await this.adapter.get(this.vault, this.name, id);
+    if (envelope && isDeleteMarker(envelope)) this.markerIds.add(id);
+    else this.markerIds.delete(id);
     if (!this.hydrated) return;
     const previous = this.cache.get(id);
-    const envelope = await this.adapter.get(this.vault, this.name, id);
     if (!envelope) {
       this.cache.delete(id);
       if (previous) {
@@ -4872,6 +5091,10 @@ var Collection = class {
    * @internal
    */
   async _onRecordMutated(id, action, origin, ctx) {
+    if (this.onDirty && !this.lazy) {
+      if (action === "delete") this.markerIds.add(id);
+      else this.markerIds.delete(id);
+    }
     switch (origin) {
       case "local-write": {
         const record = ctx.record;
@@ -4923,10 +5146,12 @@ var Collection = class {
     const ids = await this.adapter.list(this.vault, this.name);
     for (const id of ids) {
       const envelope = await this.adapter.get(this.vault, this.name, id);
-      if (envelope && !isTombstone(envelope, this.storeCiphertext) && !isDeleteMarker(envelope)) {
+      if (envelope && !isTombstone(envelope, this.storeCiphertext) && !isDeleteMarker(envelope) && (envelope._tier ?? 0) === 0) {
         const record = await this.codec.decryptRecord(envelope, { id, sealedAsHandles: true });
         if (record === null) continue;
         this.cache.set(id, { record, version: envelope._v });
+      } else if (envelope && isDeleteMarker(envelope)) {
+        this.markerIds.add(id);
       }
     }
     this.hydrated = true;
@@ -4936,7 +5161,11 @@ var Collection = class {
   /** Hydrate from a pre-loaded snapshot (used by Vault). */
   async hydrateFromSnapshot(records) {
     for (const [id, envelope] of Object.entries(records)) {
-      if (isTombstone(envelope, this.storeCiphertext) || isDeleteMarker(envelope)) continue;
+      if (isDeleteMarker(envelope)) {
+        this.markerIds.add(id);
+        continue;
+      }
+      if (isTombstone(envelope, this.storeCiphertext) || (envelope._tier ?? 0) > 0) continue;
       const record = await this.codec.decryptRecord(envelope, { id, sealedAsHandles: true });
       if (record === null) continue;
       this.cache.set(id, { record, version: envelope._v });
@@ -5057,6 +5286,8 @@ var Collection = class {
       encrypted: this.storeCiphertext,
       userId: this.keyring.userId,
       erasableBlobs: this.perRecordCek,
+      tiersActive: this.tiers !== null,
+      keyring: this.keyring,
       debugPlaintext: this.keyring.debugPlaintext === true,
       ...this.objectStore !== void 0 ? { objectStore: this.objectStore } : {},
       ...this.blobFields !== void 0 ? { blobFields: this.blobFields } : {}
@@ -5149,7 +5380,7 @@ var Collection = class {
   /** Drop a record's encrypted _vec sidecar on erasure (a vector is text-invertible).
    *  Called by vault.ts forget() inside a resilient try/catch; residue is reported in ForgetResult. */
   async _purgeVector(id) {
-    await this.adapter.delete(this.vault, "_vec", id);
+    await this.adapter.delete(this.vault, "_vec", encodeVecId(this.name, id));
     this.vectorSet?.markDirty();
   }
   /** Drop the persisted lexical-index blob (forget/erasure): an opaque
@@ -5290,8 +5521,13 @@ var Collection = class {
     const source = {
       collectionName: this.name,
       persistedIndexes: persisted,
+      canonicalizeIndexKey: (f, v) => this.via?.canonicalizeIndexKey(f, v),
       ensurePersistedIndexesLoaded: () => this.ensurePersistedIndexesLoaded(),
-      getRecord: (id) => this.get(id)
+      // #684: raw-fetch seam — post-filter runs against the RAW record;
+      // only survivors are decoded via `decodeRecord` below.
+      getRawRecord: (id) => this.#getRaw(id),
+      decodeRecord: (record) => this.applyLocaleToRecord(record, void 0),
+      via: () => this.via
     };
     return new LazyQuery(source);
   }
@@ -5313,14 +5549,14 @@ var Collection = class {
   /** C-A/R10: persist the classified marker once per classified handle (store I/O in config-drift.ts). */
   async _ensureClassifiedMarker() {
     if (this._markerPersisted || this.vdigFields === null) return;
-    const { persistClassifiedMarkerForFields } = await import("./classified-marker-LQWWQNIJ.js");
+    const { persistClassifiedMarkerForFields } = await import("./classified-marker-CZKA6ITE.js");
     await persistClassifiedMarkerForFields(this.adapter, this.vault, this.name, this.vdigFields, await this.getDEK(this.name));
     this._markerPersisted = true;
   }
   /** C-A/R10 drift signal — the marker's declared digest-only set, memoized to one store read per handle (see config-drift.ts). */
   async _classifiedMarkerDigestOnly() {
     if (this._markerDigestOnlyCache !== void 0) return this._markerDigestOnlyCache;
-    const { readClassifiedMarkerDigestOnly } = await import("./classified-marker-LQWWQNIJ.js");
+    const { readClassifiedMarkerDigestOnly } = await import("./classified-marker-CZKA6ITE.js");
     this._markerDigestOnlyCache = await readClassifiedMarkerDigestOnly(this.adapter, this.vault, this.name, await this.getDEK(this.name));
     return this._markerDigestOnlyCache;
   }
@@ -5360,7 +5596,7 @@ var Collection = class {
     };
   }
   // ─── Hierarchical Access ──────────────────────────
-  /** tier-aware put — gated behind `tiersStrategy: withTiers()`. */
+  /** tier-aware put — gated behind `tiersStrategy: withTiers()`. `searchResidue: true` = stuck search compensation (#774, mirroring #764's elevate/demote posture); the write itself always completes. */
   putAtTier(id, record, tier, opts) {
     return this.tiersStrategy.putAtTier(this.tiersContext(), id, record, tier, opts);
   }
@@ -5372,18 +5608,16 @@ var Collection = class {
   listAtTier() {
     return this.tiersStrategy.listAtTier(this.tiersContext());
   }
-  /** elevate a record to a higher tier — gated behind `withTiers()`. */
+  /** elevate a record to a higher tier — gated behind `withTiers()`. `searchResidue: true` = stuck search compensation (#764); the move itself always completes. */
   elevate(id, toTier) {
     return this.tiersStrategy.elevate(this.tiersContext(), id, toTier);
   }
-  /** demote a record to a lower tier — gated behind `withTiers()`. */
+  /** demote a record to a lower tier — gated behind `withTiers()`. Same `searchResidue` posture as {@link elevate} (#764). */
   demote(id, toTier) {
     return this.tiersStrategy.demote(this.tiersContext(), id, toTier);
   }
   /**
-   * Emit a cross-tier access event. The subscriber sink stays collection-
-   * resident (it captures `onCrossTierAccess`); the tiers module reaches it
-   * via the {@link TiersContext.emitCrossTierEvent} callback.
+   * Emit a cross-tier access event. The subscriber sink stays collection-resident (it captures `onCrossTierAccess`); the tiers module reaches it via the {@link TiersContext.emitCrossTierEvent} callback.
    */
   emitCrossTierEvent(event) {
     try {
@@ -5424,9 +5658,7 @@ var Collection = class {
     if (patch.presentForJoin) this.presentForJoin = patch.presentForJoin;
   }
   /**
-   * Bind the {@link TiersContext} the tier ops need. The `cekCache` is passed
-   * by reference (the SAME `Lru` the kernel's read/write path owns) so an
-   * elevate/demote CEK re-wrap stays synchronous with cache eviction.
+   * Bind the {@link TiersContext} the tier ops need — `cekCache` by reference (same `Lru` the read/write path owns) for a synchronous re-wrap; `syncDerived` closes over `this` for {@link syncDerivedOutputs} (#722).
    */
   tiersContext() {
     return {
@@ -5436,19 +5668,43 @@ var Collection = class {
       keyring: this.keyring,
       codec: this.codec,
       cekCache: this.cekCache,
+      syncCache: (id, e) => {
+        if (e) this.cache.set(id, e);
+        else this.cache.delete(id);
+        this.lru?.remove(id);
+      },
+      syncIndexes: (id, rec, version, priorEnvelope) => syncTierIndexes(this.indexingContext(), id, rec, version, priorEnvelope),
+      syncSearch: (id, rec, version) => syncTierSearch(this.searchContext(), id, rec, version),
+      syncHistory: async (id, fromDek, toDek) => this.historyStrategy.rewrapHistory(this.adapter, this.vault, this.name, id, fromDek, toDek, await this.getDEK(this.name)),
+      saveHistorySnapshot: async (id, envelope) => {
+        if (this.historyConfig.enabled === false) return;
+        await this.historyStrategy.saveHistory(this.adapter, this.vault, this.name, id, envelope);
+        this.emitter.emit("history:save", { vault: this.vault, collection: this.name, id, version: envelope._v });
+        if (this.historyConfig.maxVersions) await this.historyStrategy.pruneHistory(this.adapter, this.vault, this.name, id, { keepVersions: this.historyConfig.maxVersions });
+      },
+      historyEnabled: this.historyConfig.enabled !== false && this.historyStrategy !== NO_HISTORY,
+      // #728/#737: lets putAtTier skip decrypting `existing` when no real history strategy is wired
+      syncBlobs: (id, fromTier, toTier) => this.blobStrategy !== NO_BLOBS ? this.blob(id).syncTierMove(fromTier, toTier, this.blobTierPolicy) : Promise.resolve(),
+      // #724 I1: gate on blob storage enabled (not on declared blobFields) so undeclared-field blobs still rehome; #746: syncTierMove mints/resumes the rehome journal marker; self-no-ops on an empty slot map
+      syncLedger: async (id) => {
+        await this.ledger?.purgeRecordDeltas(this.name, id);
+      },
+      syncDerived: (id, record, elevated, version) => syncDerivedOutputs(this, id, record, elevated, version),
+      hasDerivedOutputs: this.materializedViewSource !== void 0 && this.materializedViewSource.registry().mvsForSource(this.name).length > 0 || this.derivationSource !== void 0 && this.derivationSource.registry().strategiesForSource(this.name).length > 0,
+      // #737: source-grained (was vault-grained) — a derivation-free tiered collection skips the pre-move decode even when other collections in the vault have derivations
       provenance: this.provenance,
       tiers: this.tiers,
       tierMode: this.tierMode,
       getDEK: (key) => this.getDEK(key),
-      emitCrossTierEvent: (event) => this.emitCrossTierEvent(event)
+      emitCrossTierEvent: (event) => this.emitCrossTierEvent(event),
+      addSubjectRef: (id, record) => this.addSubjectRef?.(id, record) ?? Promise.resolve()
     };
   }
   /**
    * Bind the {@link IndexingContext} the index-maintenance surface needs. The
    * eager `cache` Map and the index / unique-constraint / persisted mirrors are
    * passed by reference (the SAME instances the query path reads, never
-   * copied); the `persistedIndexesLoaded` flag and `ensure*` hydration stay
-   * collection-resident, reached via callbacks.
+   * copied); the `persistedIndexesLoaded` flag and `ensure*` hydration stay collection-resident, reached via callbacks.
    */
   indexingContext() {
     return {
@@ -5499,9 +5755,12 @@ var ElevatedHandle = class {
    */
   collection(name) {
     return {
+      // #779 — surface `_elevatedPut`'s `TierMoveResult` (searchResidue) instead of
+      // discarding it, so a stuck search compensation on this convenience path is
+      // observable by the caller, mirroring `putAtTier`'s direct-call parity (#774).
       put: async (id, record) => {
         this.assertActive();
-        await this.vault._elevatedPut(name, id, record, this.tier, this.reason);
+        return await this.vault._elevatedPut(name, id, record, this.tier, this.reason);
       }
     };
   }
@@ -6718,7 +6977,7 @@ var VaultLinks = class {
 // src/with-shape/links/lazy-handle.ts
 function makeLazyLinkSetHandle(d) {
   let engine = null;
-  const load = () => engine ??= import("./link-set-MNADSH5M.js").then(
+  const load = () => engine ??= import("./link-set-Z7Q2ASFX.js").then(
     ({ LinkSet }) => new LinkSet(d.adapter, d.vault, d.name, d.spec, d.encrypted, d.getDEK, d.actor, d.emitter, d.endpointExists)
   );
   return {
@@ -7155,7 +7414,7 @@ var SatelliteRegistry = class {
   locks = /* @__PURE__ */ new Map();
   register(spec) {
     if (this.byBase.has(spec.base)) {
-      throw new SatelliteConfigError(`R-S1: base "${spec.base}" already has satellite "${this.byBase.get(spec.base).satellite}" \u2014 v1 allows exactly one satellite per base.`);
+      throw new SatelliteConfigError(`R-S10: base "${spec.base}" already has satellite "${this.byBase.get(spec.base).satellite}" \u2014 v1 allows exactly one satellite per base.`);
     }
     if (this.byBase.has(spec.satellite)) {
       throw new SatelliteConfigError(`R-S3: "${spec.satellite}" is itself registered as a base (of "${this.byBase.get(spec.satellite).satellite}") \u2014 no satellite-of-satellite chains.`);
@@ -7256,7 +7515,7 @@ function declareSatellite(ctx, collectionName, options, existingRegistry) {
   ctx.forEachSyncEngine((e) => e.remirrorPairResolvers([spec.base, spec.satellite]));
   const registry = reg;
   const baseSchema = ctx.getBaseSchema(spec.base);
-  void import("./post-register-HAWO3O7O.js").then((m) => m.postRegister(ctx.adapter, ctx.vaultName, spec, ctx.getDEK, baseSchema, registry)).catch(() => {
+  void import("./post-register-JTH76BLY.js").then((m) => m.postRegister(ctx.adapter, ctx.vaultName, spec, ctx.getDEK, baseSchema, registry)).catch(() => {
   });
   return reg;
 }
@@ -7269,14 +7528,9 @@ function unwrap(handle) {
   return handle[RAW_TARGET] ?? handle;
 }
 async function revertAndCompensate(deps, executed) {
-  for (const leg of [...executed].reverse()) {
-    try {
-      if (leg.prior !== null) await deps.adapter.put(deps.vaultName, leg.coll, leg.id, leg.prior);
-      else await deps.adapter.delete(deps.vaultName, leg.coll, leg.id);
-      await leg.handle._compensateRevertedWrite(leg.id);
-    } catch {
-    }
-  }
+  await bestEffortRevert(executed, deps.adapter, async (leg) => {
+    if (leg.wrote) await leg.handle._compensateRevertedWrite(leg.id);
+  });
 }
 async function joinedPut(deps, id, record) {
   deps.registry.assertNotPoisoned(deps.spec.satellite);
@@ -7291,8 +7545,17 @@ async function joinedPut(deps, id, record) {
   return deps.registry.withPairLock(deps.spec.base, async () => {
     const executed = [];
     const run = async (handle, coll, rec) => {
-      executed.push({ coll, id, prior: await deps.adapter.get(deps.vaultName, coll, id), handle });
+      const leg = {
+        vaultName: deps.vaultName,
+        collectionName: coll,
+        id,
+        prior: await deps.adapter.get(deps.vaultName, coll, id),
+        handle,
+        wrote: false
+      };
+      executed.push(leg);
       await handle.put(id, rec);
+      leg.wrote = true;
     };
     try {
       await run(base, deps.spec.base, baseRec);
@@ -7309,8 +7572,17 @@ async function pairDelete(deps, id) {
   return deps.registry.withPairLock(deps.spec.base, async () => {
     const executed = [];
     const run = async (handle, coll) => {
-      executed.push({ coll, id, prior: await deps.adapter.get(deps.vaultName, coll, id), handle });
+      const leg = {
+        vaultName: deps.vaultName,
+        collectionName: coll,
+        id,
+        prior: await deps.adapter.get(deps.vaultName, coll, id),
+        handle,
+        wrote: false
+      };
+      executed.push(leg);
       await handle.delete(id);
+      leg.wrote = true;
     };
     try {
       await run(satellite, deps.spec.satellite);
@@ -7563,6 +7835,17 @@ function expandRefsWithSatellites(refs, registry) {
   return anySat ? out : refs;
 }
 
+// src/with-shape/satellites/migrate-cek.ts
+async function migrateSatelliteCek(name, coll) {
+  if (coll.getConfig()?.perRecordKeys !== true) {
+    throw new SatelliteConfigError(
+      `migrateSatellitePerRecordKeys: collection "${name}" was already opened this session without perRecordKeys (construction-only); migrate before its first open, or restart the session.`
+    );
+  }
+  const migrated = await coll._applyCutoverTransform((doc) => doc);
+  return { migrated };
+}
+
 // src/with-shape/schema-update/gate.ts
 var SchemaUpdateGate = class {
   #decision;
@@ -8226,7 +8509,7 @@ var Vault = class {
         const strategies = options.schemaUpdate ?? [];
         const work = (async () => {
           const dek = await this.getDEK(collectionName);
-          const { persistSchemaIfNeeded } = await import("./register-VCKOBWKT.js");
+          const { persistSchemaIfNeeded } = await import("./register-VAHONCID.js");
           const result = await persistSchemaIfNeeded({
             store: this.adapter,
             vault: this.name,
@@ -8263,6 +8546,8 @@ var Vault = class {
         schemaFence: this.schemaFence,
         getDEK: this.getDEK,
         onDirty: this.onDirty,
+        tabCoordinated: () => this.noydb._tabCoordinationActive,
+        // #693: re-create gate fallback
         historyConfig: effectiveHistoryConfig,
         historyConfigExplicit: options?.historyConfig !== void 0,
         // thread the vault-wide blob strategy into every
@@ -8337,9 +8622,7 @@ var Vault = class {
       if (options?.sensitive !== void 0) {
         collOpts.sensitive = options.sensitive;
       }
-      if (options?.perRecordKeys !== void 0) {
-        collOpts.perRecordKeys = options.perRecordKeys;
-      }
+      if (options?.perRecordKeys !== void 0) collOpts.perRecordKeys = options.perRecordKeys;
       const subjectKey = this.forgetStrategy.subjects[collectionName];
       if (subjectKey !== void 0) {
         if (options?.perRecordKeys === false) {
@@ -8349,11 +8632,16 @@ var Vault = class {
         }
         collOpts.perRecordKeys = true;
         collOpts.subjectKeyField = subjectKey;
+        collOpts.addSubjectRef = async (id, record) => {
+          const value = readDottedPath(record, subjectKey);
+          if (value !== void 0 && value !== null) await this._addSubjectRef(coerceSubjectId(value), { collection: collectionName, id });
+        };
       }
       if (options?.provenance !== void 0) collOpts.provenance = options.provenance;
       if (options?.ramCiphertext !== void 0) collOpts.ramCiphertext = options.ramCiphertext;
       if (options?.tiers !== void 0) collOpts.tiers = options.tiers;
       if (options?.tierMode !== void 0) collOpts.tierMode = options.tierMode;
+      if (options?.blobTierPolicy !== void 0) collOpts.blobTierPolicy = options.blobTierPolicy;
       collOpts.onCrossTierAccess = (event) => this.emitCrossTier(event);
       if (this.syncAdapter !== void 0) collOpts.syncAdapter = this.syncAdapter;
       if (options?.i18nFields !== void 0) collOpts.i18nFields = options.i18nFields;
@@ -8420,7 +8708,7 @@ var Vault = class {
         const work = (async () => {
           try {
             const dek = await this.getDEK(collectionName);
-            await (await import("./register-VCKOBWKT.js")).persistSchemaIfNeeded({
+            await (await import("./register-VAHONCID.js")).persistSchemaIfNeeded({
               store: this.adapter,
               vault: this.name,
               collectionName,
@@ -8457,6 +8745,16 @@ var Vault = class {
       registry: this.satelliteRegistry
     });
   }
+  /**
+   * Migrate an existing satellite's records onto per-record CEKs (#599) —
+   * unblocks R-S7 when a base gains forget coverage after its satellite was
+   * already declared without `perRecordKeys`. Call BEFORE re-declaring with
+   * `{ satelliteOf, perRecordKeys: true }` AND before this collection serves
+   * writes (unfenced walk — see {@link migrateSatelliteCek}); resumable.
+   */
+  async migrateSatellitePerRecordKeys(satelliteName) {
+    return migrateSatelliteCek(satelliteName, this.collection(satelliteName, { perRecordKeys: true }));
+  }
   /**
    * Await all background persisted-schema writes triggered by
    * `collection({ persistJsonSchema: true })` calls on this vault.
@@ -8517,6 +8815,12 @@ var Vault = class {
   _reservedLookupCollectionNames() {
     return [...this.reservedLookupCollections.keys()];
   }
+  /** @internal #653 — one-hop reserved-dict deps of `names`, for `SyncEngine`'s partial-sync
+   *  filter expansion. Provably complete at one hop: `vault.collection()` refuses `_dict_*`
+   *  names, so a dict can never itself declare lookup fields (no dict-of-dict chain). */
+  _reservedDictDepsOf(names) {
+    return reservedDictDepsOf(names, this.dictKeyFieldRegistry);
+  }
   /** @internal #638 Task 4 — open a graph-dispatch touch batch (sync pull()/push()/cutover). */
   _beginGraphBatch() {
     this._graphBatch = /* @__PURE__ */ new Map();
@@ -9278,6 +9582,8 @@ var Vault = class {
     if (Object.keys(this.forgetStrategy.subjects).length === 0) {
       throw new ForgetStrategyNotConfiguredError();
     }
+    const ledger = this.getLedgerOrNull();
+    if (!ledger) throw new Error('vault.forget() requires the history strategy for the erasure-proof ledger entry. Pass `historyStrategy: withHistory()` from "@noy-db/hub/history" to createNoydb().');
     const refs = await lookupSubject(this.adapter, this.name, this.getDEK, this.encrypted, subjectId);
     const allRefs = expandRefsWithSatellites(refs, this.satelliteRegistry);
     let recordsShredded = 0;
@@ -9290,12 +9596,14 @@ var Vault = class {
     let indexPostingsPurged = 0;
     let sealedFieldsShredded = 0;
     let sealedCekEnvelopesPurged = 0;
+    let ledgerDeltasPurged = 0;
     const sealedCekResidue = [];
     const sealedResidue = [];
     const indexResidue = [];
+    const ledgerDeltaResidue = [];
     const blobsEnabled = this.blobStrategy !== void 0;
     const actor = this.keyring.userId;
-    const fanoutStats = { recordsErased: 0, aggregatesRecomputed: 0, residueFrozen: [], lookupReferencesCascaded: 0, lookupReferencesNullified: 0, lookupReferencesResidue: [] };
+    const fanoutStats = { recordsErased: 0, aggregatesRecomputed: 0, residueFrozen: [], lookupReferencesCascaded: 0, lookupReferencesNullified: 0, lookupReferencesResidue: [], derivedResidueUndecodable: [], derivedResidueDeclined: [] };
     const { partitionSealedCekKeys, shouldSkipBlobScan, bumpResidueCount, residueNoticesFromMap } = await import("./purge-scope-FGNNLWHD.js");
     const scopedPurge = this.forgetStrategy.scopedPurge === true;
     const sealedCekScopedSkipped = /* @__PURE__ */ new Map();
@@ -9340,6 +9648,13 @@ var Vault = class {
       } catch {
         sealedCekResidue.push(`${ref2.collection}:${ref2.id}`);
       }
+      if (blobsEnabled && !shouldSkipBlobScan(scopedPurge, this.blobFieldsRegistry.has(ref2.collection))) {
+        try {
+          await coll.blob(ref2.id).mintShredIntent(live?._tier ?? 0);
+        } catch {
+          blobResidueCollections.add(ref2.collection);
+        }
+      }
       let shred;
       try {
         shred = await coll._writeTombstone(ref2.id, actor);
@@ -9364,6 +9679,11 @@ var Vault = class {
         actor,
         this.encrypted
       );
+      try {
+        ledgerDeltasPurged += await ledger.purgeRecordDeltas(ref2.collection, ref2.id);
+      } catch {
+        ledgerDeltaResidue.push(`${ref2.collection}:${ref2.id}`);
+      }
       const idxPurge = await coll._purgePersistedIndexes(ref2.id);
       indexPostingsPurged += idxPurge.purged;
       for (const field of idxPurge.residue) indexResidue.push(`${ref2.collection}:${ref2.id}:${field}`);
@@ -9375,14 +9695,14 @@ var Vault = class {
       if (blobsEnabled && shouldSkipBlobScan(scopedPurge, this.blobFieldsRegistry.has(ref2.collection))) {
         bumpResidueCount(blobScopedSkipped, ref2.collection, 1);
       } else if (blobsEnabled) {
-        const r = await this.collection(ref2.collection).blob(ref2.id).shredAllForRecord();
+        const r = await this.collection(ref2.collection).blob(ref2.id).shredAllForRecord(live?._tier ?? 0);
         blobsShredded += r.shredded.length;
         blobsRetainedShared += r.retainedShared.length;
         if (r.residue.length > 0) blobResidueCollections.add(ref2.collection);
       } else {
         try {
-          const slotIds = await this.adapter.list(this.name, `_blob_slots_${ref2.collection}`);
-          if (slotIds.includes(ref2.id)) blobResidueCollections.add(ref2.collection);
+          const [slotIds, verKeys] = await Promise.all([this.adapter.list(this.name, `_blob_slots_${ref2.collection}`), this.adapter.list(this.name, `_blob_versions_${ref2.collection}`)]);
+          if (slotIds.includes(ref2.id) || verKeys.some((k) => k.startsWith(`${ref2.id}::`))) blobResidueCollections.add(ref2.collection);
         } catch {
         }
       }
@@ -9396,12 +9716,6 @@ var Vault = class {
       }
     }
     const subjectHash = await sha256Hex(subjectId);
-    const ledger = this.getLedgerOrNull();
-    if (!ledger) {
-      throw new Error(
-        'vault.forget() requires the history strategy for the erasure-proof ledger entry. Pass `historyStrategy: withHistory()` from "@noy-db/hub/history" to createNoydb().'
-      );
-    }
     const ledgerEntry = await ledger.append({
       op: "forget",
       collection: "",
@@ -9422,7 +9736,9 @@ var Vault = class {
         sealedFieldsShredded,
         sealedCekEnvelopesPurged,
         sealedCekResidueCount: sealedCekResidue.length,
-        sealedResidueCount: sealedResidue.length
+        sealedResidueCount: sealedResidue.length,
+        ledgerDeltasPurged,
+        ledgerDeltaResidueCount: ledgerDeltaResidue.length
       })
     });
     const scopedPurgeResidue = [...residueNoticesFromMap(sealedCekScopedSkipped, "skipped-undeclared-sealed-cek"), ...residueNoticesFromMap(blobScopedSkipped, "skipped-undeclared-blob-scan")];
@@ -9448,8 +9764,13 @@ var Vault = class {
       lookupReferencesCascaded: fanoutStats.lookupReferencesCascaded,
       lookupReferencesNullified: fanoutStats.lookupReferencesNullified,
       lookupReferencesResidue: fanoutStats.lookupReferencesResidue,
-      scopedPurgeResidue
-      // #650 Task 5 (+ review Important fix: residue) + #633
+      scopedPurgeResidue,
+      ledgerDeltasPurged,
+      ledgerDeltaResidue,
+      // #650 Task 5 (+ review Important fix: residue) + #633 + #734
+      derivedResidueUndecodable: fanoutStats.derivedResidueUndecodable,
+      derivedResidueDeclined: fanoutStats.derivedResidueDeclined
+      // #776/#785
     };
   }
   // ─── Record-scoped CEK sealing ─────────────────────────────────────
@@ -9572,7 +9893,7 @@ var Vault = class {
   async _initDerivations(handles) {
     if (handles.length === 0) return;
     const [{ DerivationRegistry }, { ReadOnlyVaultFacade }] = await Promise.all([
-      import("./registry-BZFLJNEH.js"),
+      import("./registry-EPKPD5SM.js"),
       import("./read-only-facade-CHCKSEPD.js")
     ]);
     const registry = new DerivationRegistry();
@@ -9604,7 +9925,7 @@ var Vault = class {
    */
   async _initMaterializedViews(handles) {
     if (handles.length === 0) return;
-    const { MaterializedViewRegistry } = await import("./registry-YJEYSYI5.js");
+    const { MaterializedViewRegistry } = await import("./registry-7MLVD3VO.js");
     const registry = new MaterializedViewRegistry();
     this.materializedViewRegistry = registry;
     const db = this;
@@ -9629,7 +9950,7 @@ var Vault = class {
    */
   async _initOverlayedViews(handles) {
     if (handles.length === 0) return;
-    const { OverlayedViewRegistry } = await import("./registry-72UKJ2L4.js");
+    const { OverlayedViewRegistry } = await import("./registry-P5T7PS2U.js");
     const registry = new OverlayedViewRegistry();
     const mvRegistry = this.materializedViewRegistry;
     const overlayNames = /* @__PURE__ */ new Set();
@@ -9664,27 +9985,27 @@ var Vault = class {
   /**
    * Manual re-materialize for a single registered MV (`refresh: 'manual'` consumers,
    * stale-bit recovery on vault reopen, bulk-recompute escape hatch after a strategy
-   * change). Returns `{ written, deleted, failed }` (`deleted` always 0 without
-   * tombstoning). Throws if `name` is not a registered MV.
+   * change). Returns `{ written, deleted, failed, residueUndecodable, residueDeclined }` (`deleted`
+   * always 0 without tombstoning; #785 splits the #782 leftovers — undecodable vs #718-declined). Throws if not registered.
    */
   async refreshView(name) {
     const registry = this.materializedViewRegistry;
     if (registry === null) {
-      return { written: 0, deleted: 0, failed: 0 };
+      return { written: 0, deleted: 0, failed: 0, residueUndecodable: [], residueDeclined: [] };
     }
     const reg = registry.byName(name);
     if (!reg) {
       throw new Error(`refreshView: no MV registered with name "${name}"`);
     }
-    const { MaterializedViewExecutor } = await import("./executor-GTVSUUBX.js");
+    const { MaterializedViewExecutor } = await import("./executor-UNEH5ZYH.js");
     const result = await MaterializedViewExecutor.refresh(reg, {
       getCollection: (n) => this.collection(n),
       getActiveTxContext: () => this.noydb._activeTxContextOrNull,
       getQueryContext: () => this,
       dispatchCtx: this._dispatchCtx({ collection: name, id: "refreshView" })
     });
-    const { clearMVStale } = await import("./stale-NXPT56JA.js");
-    clearMVStale(registry, name);
+    const { clearMVStaleFully } = await import("./stale-OSQ7J3AA.js");
+    await clearMVStaleFully(this.adapter, this.name, registry, name);
     return result;
   }
   /**
@@ -9696,7 +10017,7 @@ var Vault = class {
     if (registry === null) return { derived: 0, failed: 0, skippedFrozen: 0 };
     const strategies = registry.strategiesForSource(sourceCollection);
     if (strategies.length === 0) return { derived: 0, failed: 0, skippedFrozen: 0 };
-    const { DerivationExecutor } = await import("./executor-XXGS4S3K.js");
+    const { DerivationExecutor } = await import("./executor-OVEXR6RT.js");
     const sourceColl = this.collection(sourceCollection);
     const records = await sourceColl.list();
     const ctx = { vault: this.derivationFacade ?? new (await import("./read-only-facade-CHCKSEPD.js")).ReadOnlyVaultFacade(this, "derivation") };
@@ -9723,7 +10044,7 @@ var Vault = class {
           if (!outSpec) continue;
           const outputColl = this.collection(outSpec.collection);
           if (out.kind === "array") {
-            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-CKYFH33E.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-A765THMX.js");
             const prior = await loadFanoutSidecar(this.adapter, this.name, spec.source, id, key, this.getDEK, this.encrypted);
             const prevKeys = new Set(prior?.keys ?? []);
             const newKeysList = out.entries.map((e) => e.key);
@@ -9950,7 +10271,7 @@ var Vault = class {
    * collection.
    */
   async delegate(opts) {
-    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-OPUU3R2E.js");
+    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-W7ZV2322.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."
@@ -9972,7 +10293,7 @@ var Vault = class {
    * if the id does not exist.
    */
   async revokeDelegation(id) {
-    const { revokeDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-OPUU3R2E.js");
+    const { revokeDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-W7ZV2322.js");
     await revokeDelegation(this.adapter, this.name, id);
     void DELEGATIONS_COLLECTION;
   }
@@ -10057,11 +10378,11 @@ var Vault = class {
    * Internal — invoked by an `ElevatedHandle.collection().put()` call.
    * Routes through the existing `Collection.putAtTier` code path with
    * the elevation context attached so the cross-tier event reflects
-   * the right authorization class.
+   * the right authorization class. Returns `putAtTier`'s `TierMoveResult` (#779).
    */
   async _elevatedPut(collectionName, id, record, tier, reason) {
     const coll = this.collection(collectionName);
-    await coll.putAtTier(id, record, tier, {
+    return coll.putAtTier(id, record, tier, {
       elevation: { reason, fromTier: 0 }
     });
   }
@@ -10220,7 +10541,7 @@ var Vault = class {
    * @see docs/superpowers/specs/2026-05-22-schema-dump-design.md
    */
   async dumpSchema(opts = {}) {
-    const { dumpVaultSchema } = await import("./walk-2RWEOCAS.js");
+    const { dumpVaultSchema } = await import("./walk-SVNDIZ62.js");
     return dumpVaultSchema(this, opts);
   }
   /**
@@ -10355,7 +10676,7 @@ var Vault = class {
    * @see https://github.com/vLannaAi/noy-db-docs/blob/main/content/docs/services/public-envelope.md
    */
   async getPublicEnvelope(opts = {}) {
-    const { readPublicEnvelope } = await import("./public-envelope-NJVB7LPA.js");
+    const { readPublicEnvelope } = await import("./public-envelope-B4KNWVUA.js");
     return readPublicEnvelope(this.adapter, this.name, opts);
   }
   /**
@@ -10370,7 +10691,7 @@ var Vault = class {
    * both modes round-trip cleanly.
    */
   async dump() {
-    const { dumpVault } = await import("./backup-XA5STIYQ.js");
+    const { dumpVault } = await import("./backup-BJ57IKAO.js");
     return dumpVault(this.backupContext());
   }
   /**
@@ -10422,7 +10743,7 @@ var Vault = class {
    * — there's no chain to verify against.
    */
   async load(backupJson) {
-    const { loadVault } = await import("./backup-XA5STIYQ.js");
+    const { loadVault } = await import("./backup-BJ57IKAO.js");
     return loadVault(this.backupContext(), backupJson);
   }
   /**
@@ -10454,7 +10775,7 @@ var Vault = class {
    * way to detect tampering of an in-place vault.
    */
   async verifyBackupIntegrity() {
-    const { verifyBackupIntegrity } = await import("./backup-XA5STIYQ.js");
+    const { verifyBackupIntegrity } = await import("./backup-BJ57IKAO.js");
     return verifyBackupIntegrity(this.backupContext());
   }
   /**
@@ -10672,7 +10993,7 @@ var Vault = class {
    * is the live validator object, not a serialization of it).
    */
   async exportJSON(opts = {}) {
-    const { exportVaultJSON } = await import("./backup-XA5STIYQ.js");
+    const { exportVaultJSON } = await import("./backup-BJ57IKAO.js");
     return exportVaultJSON(this.backupContext(), opts);
   }
 };
@@ -12543,7 +12864,7 @@ 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-GZWMTOXB.js");
+      const { GuardExecutor } = await import("./executor-KGWTNEQD.js");
       for (const g of guards) {
         await GuardExecutor.checkFrozenFields(g, e.docId, existing, incoming, e.computedFieldNames);
       }
@@ -12765,6 +13086,7 @@ var Noydb = class {
       engine.setCacheInvalidator((collection, id, action) => comp._invalidateSyncApplied(collection, id, action));
       engine.setGraphBatchController({ begin: () => comp._beginGraphBatch(), flush: () => comp._flushGraphBatch() });
       engine.setReservedLookupSource({ collections: () => comp._reservedLookupCollectionNames() });
+      engine.setReservedDictExpander((names) => comp._reservedDictDepsOf(names));
     });
     await comp._initGuards(this.options.guardStrategies ?? []);
     await comp._initDerivations(this.options.derivationStrategies ?? []);
@@ -13539,6 +13861,16 @@ var Noydb = class {
   get coordination() {
     return this.coordinationProvider;
   }
+  /**
+   * #693: true when multi-tab coordination is active at all — presence/election
+   * alone (`propagateWrites: false`) or full write-propagation — a peer tab can
+   * write this instance's shared store out-of-band either way, so per-collection
+   * marker-id sets are not authoritative and the re-create gate must fall back to
+   * a store read. Live (tab coordination is enable/disable-able at runtime).
+   */
+  get _tabCoordinationActive() {
+    return this.tabCoordinator !== void 0;
+  }
   /**
    * Soft-lock a single vault: clear its in-memory keyring, DEKs, vault
    * instance, sync engine, policy enforcer, and active-tier entry —
@@ -13811,7 +14143,7 @@ var Noydb = class {
         "setPublicEnvelope: the public-envelope feature is not enabled. Pass `publicEnvelope: true` (or a schema object) to `createNoydb`."
       );
     }
-    const { loadPublicEnvelope, savePublicEnvelope, resolveSchema, validatePublicEnvelopeInput } = await import("./public-envelope-NJVB7LPA.js");
+    const { loadPublicEnvelope, savePublicEnvelope, resolveSchema, validatePublicEnvelopeInput } = await import("./public-envelope-B4KNWVUA.js");
     const schema = resolveSchema(this.options.publicEnvelope);
     validatePublicEnvelopeInput(input, schema);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -13840,7 +14172,7 @@ var Noydb = class {
    * regardless).
    */
   async getPublicEnvelope(vault, opts = {}) {
-    const { readPublicEnvelope } = await import("./public-envelope-NJVB7LPA.js");
+    const { readPublicEnvelope } = await import("./public-envelope-B4KNWVUA.js");
     return readPublicEnvelope(this.options.store, vault, opts);
   }
   // ─── Auth introspection ─────────────────────────────────────────
@@ -14031,9 +14363,9 @@ async function createNoydb(options) {
     throw new ValidationError("A secret (passphrase) or getKeyring callback is required when encryption is enabled");
   }
   if (!options.coordinationStrategy) options = { ...options, coordinationStrategy: await createDefaultCoordinationProvider(options.store) };
-  if (!options.userApiFactory) options = { ...options, userApiFactory: (await import("./api-YGMINAET.js")).createUserApi };
+  if (!options.userApiFactory) options = { ...options, userApiFactory: (await import("./api-ZGS6LCOF.js")).createUserApi };
   if (!options.policyFactory) {
-    const policyModule = await import("./policy-JTFOPPUU.js");
+    const policyModule = await import("./policy-Z3RUAIY2.js");
     options = { ...options, policyFactory: policyModule.createNoydbPolicy, policyCheckGateFn: policyModule.checkGate };
   }
   return new Noydb(options);
@@ -14070,4 +14402,4 @@ export {
   Noydb,
   createNoydb
 };
-//# sourceMappingURL=chunk-A2QF4JUE.js.map
+//# sourceMappingURL=chunk-X7QBD67R.js.map