@noy-db/hub 0.2.0-pre.27 → 0.2.0-pre.29

package/dist/{chunk-KSKKLVPA.js → chunk-ZDW22N3E.js}

@@ -1,18 +1,19 @@
 import {
   StoreCoordinationProvider,
+  fuseRetrieval,
   loadFence,
   runDrainBarrier
-} from "./chunk-Z3BJF7SF.js";
+} from "./chunk-GGXN73NM.js";
 import {
   resolveSchema
 } from "./chunk-EMIGCR7X.js";
 import {
   TxContext,
   revertExecuted
-} from "./chunk-EJJTUDNI.js";
+} from "./chunk-BITB3T5Z.js";
 import {
   OverlayedCollection
-} from "./chunk-YYTM4U4J.js";
+} from "./chunk-MPIZQGFA.js";
 import {
   NO_AGGREGATE,
   Query,
@@ -22,39 +23,39 @@ import {
   decodeMoneyFields,
   quantizeMoneyFields,
   validateMoneyFieldPaths
-} from "./chunk-PS6PSEZL.js";
+} from "./chunk-QGBBQKDS.js";
 import {
   EXPORT_AUDIT_COLLECTION,
   createExportBlobsHandle,
   runCompaction
-} from "./chunk-RRCRITDM.js";
+} from "./chunk-XYW2CSCI.js";
 import {
   LazyQuery,
   decodeIdxId,
   encodeIdxId
-} from "./chunk-H4XFA2LM.js";
+} from "./chunk-4K4QKYK4.js";
 import {
   canonicalGroupKey
-} from "./chunk-C7UIT5XY.js";
+} from "./chunk-K6NVSHAH.js";
 import {
   readPath
-} from "./chunk-3BANVNDH.js";
+} from "./chunk-KJ3K5VZM.js";
 import {
   SCHEMAS_COLLECTION,
   loadPersistedSchema,
   resolveManagedSecret,
   savePersistedSchema,
   saveSealedPassphrase
-} from "./chunk-SID2NJNF.js";
+} from "./chunk-MRJPSXPE.js";
 import {
   writeNoydbBundle
-} from "./chunk-6ZKXFMUG.js";
+} from "./chunk-QBLPY44S.js";
 import {
   loadPublicEnvelope,
   readPublicEnvelope,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-2NYVA6FW.js";
+} from "./chunk-QWJCNXH2.js";
 import {
   buildTombstone,
   isTombstone,
@@ -63,19 +64,20 @@ import {
   rewrapBodyToDek,
   rotateRecordCek,
   sealRecordToHost
-} from "./chunk-K6PCTYAH.js";
+} from "./chunk-LXKBG52H.js";
 import {
   PERIODS_COLLECTION
-} from "./chunk-BOMH3637.js";
+} from "./chunk-553CK4E2.js";
 import {
   isDictCollectionName,
   isStaticDictDescriptor
-} from "./chunk-PFKAT4NT.js";
+} from "./chunk-REHF3HSJ.js";
 import {
   getAtPath,
   resolvePolicy,
-  setAtPathInPlace
-} from "./chunk-KD253AI5.js";
+  setAtPathInPlace,
+  stripI18nFilled
+} from "./chunk-QXWJQ7UU.js";
 import {
   ManagedRecoveryNotEnrolledError,
   PolicyDeniedError,
@@ -97,11 +99,11 @@ import {
   saveShamirRecoveryEntries,
   updateAuthenticator,
   writeMagicLinkGrant
-} from "./chunk-IWGVH2RR.js";
+} from "./chunk-AWU4JF7C.js";
 import {
   assertTierAccess,
   dekKey
-} from "./chunk-J73KU4AE.js";
+} from "./chunk-MSMDDDDJ.js";
 import {
   USER_ENVELOPE_COLLECTION,
   assertKeyringOpenAllowed,
@@ -126,7 +128,7 @@ import {
   rotateKeys,
   saveUserEnvelope,
   updateKeyringIdentity
-} from "./chunk-LXA2E3VI.js";
+} from "./chunk-ZCMOS4H2.js";
 import {
   INDEXED_STORE_POLICY
 } from "./chunk-2QR2PQTT.js";
@@ -136,7 +138,7 @@ import {
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
-} from "./chunk-6H4CAHMQ.js";
+} from "./chunk-2UT7HJJR.js";
 import {
   sha256Hex as sha256Hex2
 } from "./chunk-PDVP3C2I.js";
@@ -148,11 +150,11 @@ import {
   readDottedPath,
   rebuildSubjectIndex,
   removeSubjectRef
-} from "./chunk-BMDVFBCL.js";
+} from "./chunk-SQXTKZL7.js";
 import {
   NOYDB_BACKUP_VERSION,
   NOYDB_FORMAT_VERSION
-} from "./chunk-AD6RNBAW.js";
+} from "./chunk-A7DNZVAV.js";
 import {
   decrypt,
   encrypt,
@@ -161,7 +163,7 @@ import {
   unwrapCek,
   wrapCek,
   wrapKey
-} from "./chunk-7JSP3E67.js";
+} from "./chunk-E2MDPPOC.js";
 import {
   AlreadyElevatedError,
   AttestationError,
@@ -172,6 +174,8 @@ import {
   DebugReservedFieldError,
   DerivationCapExceededError,
   ElevationExpiredError,
+  EmbeddingDimMismatchError,
+  EmbeddingModelMismatchError,
   ExportCapabilityError,
   ForgetStrategyNotConfiguredError,
   ImportCapabilityError,
@@ -199,7 +203,7 @@ import {
   UnknownDictCodeError,
   UnsupportedIndexOptionError,
   ValidationError
-} from "./chunk-DDOYOMAD.js";
+} from "./chunk-JZ5DS4DP.js";
 
 // src/policy/storage.ts
 var META_COLLECTION = "_meta";
@@ -418,6 +422,11 @@ var NO_I18N = {
   enforceScript(value) {
     return { value, warnings: [] };
   },
+  computeExemptFills() {
+    return /* @__PURE__ */ new Map();
+  },
+  densify() {
+  },
   buildDictionaryHandle() {
     throw notEnabled("vault.dictionary()");
   }
@@ -582,6 +591,354 @@ function searchScan(entries, field, query, opts = {}, tokenizer = tokenize) {
   return opts.limit !== void 0 ? results.slice(0, opts.limit) : results;
 }
 
+// src/search/segment.ts
+var SEGMENTER = new Intl.Segmenter(void 0, { granularity: "word" });
+var segmentTokens = (text) => {
+  const out = [];
+  if (!text) return out;
+  for (const s of SEGMENTER.segment(text)) {
+    if (s.isWordLike) out.push({ term: s.segment.normalize("NFKC").toLowerCase(), offset: s.index });
+  }
+  return out;
+};
+var segmentTokenizer = (text) => segmentTokens(text).map((t) => t.term);
+
+// src/search/inverted-index.ts
+var K12 = 1.2;
+var B2 = 0.75;
+var InvertedIndex = class _InvertedIndex {
+  // per field: df (term -> #docs), N (#docs), totalLen
+  fieldStats = /* @__PURE__ */ new Map();
+  docs = [];
+  static build(docs) {
+    const idx = new _InvertedIndex();
+    for (const d of docs) {
+      for (const f of d.fields) {
+        const tokens = segmentTokens(f.text);
+        const tf = /* @__PURE__ */ new Map();
+        const firstOffset = /* @__PURE__ */ new Map();
+        for (const t of tokens) {
+          tf.set(t.term, (tf.get(t.term) ?? 0) + 1);
+          if (!firstOffset.has(t.term)) firstOffset.set(t.term, t.offset);
+        }
+        const doc = { id: d.id, field: f.field, ...f.locale !== void 0 ? { locale: f.locale } : {}, text: f.text, len: tokens.length, tf, firstOffset };
+        idx.docs.push(doc);
+        let s = idx.fieldStats.get(f.field);
+        if (!s) {
+          s = { df: /* @__PURE__ */ new Map(), n: 0, totalLen: 0 };
+          idx.fieldStats.set(f.field, s);
+        }
+        s.n += 1;
+        s.totalLen += doc.len;
+        for (const term of tf.keys()) s.df.set(term, (s.df.get(term) ?? 0) + 1);
+      }
+    }
+    return idx;
+  }
+  query(query, opts = {}) {
+    const terms = segmentTokenizer(query);
+    if (terms.length === 0) return [];
+    const usePrefix = opts.prefix ?? false;
+    const exact = usePrefix ? terms.slice(0, -1) : terms;
+    const prefix = usePrefix ? terms[terms.length - 1] : void 0;
+    const match = opts.match ?? "any";
+    const required = exact.length + (prefix !== void 0 ? 1 : 0);
+    const best = /* @__PURE__ */ new Map();
+    for (const doc of this.docs) {
+      if (opts.fields !== void 0 && !opts.fields.includes(doc.field)) continue;
+      const stats = this.fieldStats.get(doc.field);
+      const avgdl = stats.totalLen / stats.n || 1;
+      let score = 0;
+      let matchedCount = 0;
+      let snippetOffset = -1;
+      const scoreTerm = (tf, df, offset) => {
+        if (tf <= 0) return;
+        matchedCount += 1;
+        if (snippetOffset < 0 && offset >= 0) snippetOffset = offset;
+        const idf = Math.log(1 + (stats.n - df + 0.5) / (df + 0.5));
+        const denom = tf + K12 * (1 - B2 + B2 * (doc.len / avgdl));
+        score += idf * (tf * (K12 + 1) / (denom || 1));
+      };
+      for (const qt of exact) scoreTerm(doc.tf.get(qt) ?? 0, stats.df.get(qt) ?? 0, doc.firstOffset.get(qt) ?? -1);
+      if (prefix !== void 0) {
+        const exactSet = new Set(exact);
+        let ptf = 0;
+        let poff = -1;
+        for (const [term, c] of doc.tf) {
+          if (term.startsWith(prefix) && !exactSet.has(term)) {
+            ptf += c;
+            if (poff < 0) poff = doc.firstOffset.get(term) ?? -1;
+          }
+        }
+        if (ptf > 0) {
+          let pdf = 0;
+          for (const d of this.docs) {
+            if (d.field === doc.field && [...d.tf.keys()].some((t) => t.startsWith(prefix))) pdf++;
+          }
+          scoreTerm(ptf, pdf || 1, poff);
+        }
+      }
+      if (matchedCount === 0) continue;
+      if (match === "all" && matchedCount < required) continue;
+      const hit = {
+        id: doc.id,
+        score,
+        field: doc.field,
+        text: doc.text,
+        offset: snippetOffset < 0 ? 0 : snippetOffset,
+        ...doc.locale !== void 0 ? { locale: doc.locale } : {}
+      };
+      const prev = best.get(doc.id);
+      if (!prev || hit.score > prev.score) best.set(doc.id, hit);
+    }
+    const results = [...best.values()].sort((a, b) => b.score - a.score);
+    return opts.limit !== void 0 ? results.slice(0, opts.limit) : results;
+  }
+  toSnapshot() {
+    return {
+      v: 1,
+      fieldStats: [...this.fieldStats].map(([f, s]) => [f, { df: [...s.df], n: s.n, totalLen: s.totalLen }]),
+      docs: this.docs.map((d) => ({
+        id: d.id,
+        field: d.field,
+        text: d.text,
+        len: d.len,
+        tf: [...d.tf],
+        firstOffset: [...d.firstOffset],
+        ...d.locale !== void 0 ? { locale: d.locale } : {}
+      }))
+    };
+  }
+  static fromSnapshot(s) {
+    const idx = new _InvertedIndex();
+    for (const [f, st] of s.fieldStats) idx.fieldStats.set(f, { df: new Map(st.df), n: st.n, totalLen: st.totalLen });
+    for (const d of s.docs) {
+      idx.docs.push({
+        id: d.id,
+        field: d.field,
+        text: d.text,
+        len: d.len,
+        tf: new Map(d.tf),
+        firstOffset: new Map(d.firstOffset),
+        ...d.locale !== void 0 ? { locale: d.locale } : {}
+      });
+    }
+    return idx;
+  }
+};
+
+// src/search/snippet.ts
+function extractSnippet(text, offset, window = 80) {
+  const chars = Array.from(text);
+  if (chars.length <= window) return text;
+  const cpOffset = Array.from(text.slice(0, Math.max(0, offset))).length;
+  const half = Math.floor(window / 2);
+  let start = Math.max(0, cpOffset - half);
+  const end = Math.min(chars.length, start + window);
+  start = Math.max(0, end - window);
+  const body = chars.slice(start, end).join("");
+  return `${start > 0 ? "\u2026" : ""}${body}${end < chars.length ? "\u2026" : ""}`;
+}
+
+// src/search/index-store.ts
+var MemoryIndexStore = class {
+  index;
+  get built() {
+    return this.index !== void 0;
+  }
+  async ensureBuilt(build) {
+    if (this.index === void 0) this.index = InvertedIndex.build(build());
+    return this.index;
+  }
+  markDirty() {
+    this.index = void 0;
+  }
+  async flush() {
+  }
+};
+
+// src/search/build-docs.ts
+function buildStringFieldEntries(record, textIndexes, only) {
+  const fields = only ? textIndexes.filter((f) => only.includes(f)) : textIndexes;
+  const out = [];
+  for (const field of fields) {
+    for (const leaf of getAtPath(record, field)) {
+      if (typeof leaf === "string" && leaf !== "") out.push({ field, text: leaf });
+    }
+  }
+  return out;
+}
+function buildI18nFieldEntries(record, i18nFields, textIndexes, only) {
+  const fields = (only ? textIndexes.filter((f) => only.includes(f)) : textIndexes).filter((f) => f in i18nFields);
+  const out = [];
+  for (const field of fields) {
+    for (const leaf of getAtPath(record, field)) {
+      if (!leaf || typeof leaf !== "object" || Array.isArray(leaf)) continue;
+      for (const [locale, val] of Object.entries(leaf)) {
+        if (typeof val === "string" && val !== "") out.push({ field, locale, text: val });
+      }
+    }
+  }
+  return out;
+}
+function buildDictKeyFieldEntries(record, dictKeyFields, labelMaps, textIndexes, only) {
+  const fields = (only ? textIndexes.filter((f) => only.includes(f)) : textIndexes).filter((f) => f in dictKeyFields);
+  const out = [];
+  for (const field of fields) {
+    const map = labelMaps.get(field);
+    if (!map) continue;
+    for (const leaf of getAtPath(record, field)) {
+      const keys = typeof leaf === "string" ? [leaf] : Array.isArray(leaf) ? leaf.filter((k) => typeof k === "string") : [];
+      for (const key of keys) {
+        const labels = map.get(key);
+        if (!labels) continue;
+        for (const [locale, label] of Object.entries(labels)) {
+          if (label !== "") out.push({ field, locale, text: label });
+        }
+      }
+    }
+  }
+  return out;
+}
+function buildBlobFieldEntries(filenamesByField) {
+  const out = [];
+  for (const [field, names] of filenamesByField) {
+    for (const name of names) if (name !== "") out.push({ field, text: name });
+  }
+  return out;
+}
+
+// src/search/serialize.ts
+function serializeIndex(idx) {
+  return JSON.stringify(idx.toSnapshot());
+}
+function deserializeIndex(json) {
+  return InvertedIndex.fromSnapshot(JSON.parse(json));
+}
+
+// src/search/persisted-index-store.ts
+function fpEqual(a, b) {
+  return a.count === b.count && a.maxVersion === b.maxVersion;
+}
+var PersistedIndexStore = class {
+  constructor(cb) {
+    this.cb = cb;
+    this.debounceMs = cb.debounceMs ?? 1e3;
+  }
+  cb;
+  index;
+  timer = null;
+  lastBuild;
+  debounceMs;
+  get built() {
+    return this.index !== void 0;
+  }
+  async ensureBuilt(build) {
+    this.lastBuild = build;
+    if (this.index !== void 0) return this.index;
+    const loaded = await this.cb.load();
+    if (loaded !== null && fpEqual(loaded.fingerprint, this.cb.currentFingerprint())) {
+      this.index = deserializeIndex(loaded.json);
+      return this.index;
+    }
+    this.index = InvertedIndex.build(build());
+    await this.persist();
+    return this.index;
+  }
+  markDirty() {
+    this.index = void 0;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.rebuildAndPersist().catch(() => {
+      });
+    }, this.debounceMs);
+  }
+  /** Force an immediate persist (cancels any pending debounce). */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.rebuildAndPersist();
+  }
+  /** Delete the persisted blob and drop the in-memory index (forget/erasure). */
+  async removePersisted() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.index = void 0;
+    await this.cb.remove();
+  }
+  /** Rebuild using the last known build thunk, then persist. */
+  async rebuildAndPersist() {
+    if (this.lastBuild === void 0) return;
+    if (this.index === void 0) {
+      this.index = InvertedIndex.build(this.lastBuild());
+    }
+    await this.persist();
+  }
+  async persist() {
+    if (this.index === void 0) return;
+    await this.cb.save(serializeIndex(this.index), this.cb.currentFingerprint());
+  }
+};
+
+// src/embeddings/cosine.ts
+function cosine(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i], y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+// src/embeddings/descriptor.ts
+function embeddingSourceText(record, source) {
+  const fields = typeof source === "string" ? [source] : source;
+  const parts = [];
+  for (const f of fields) {
+    for (const leaf of getAtPath(record, f)) {
+      if (typeof leaf === "string" && leaf !== "") parts.push(leaf);
+    }
+  }
+  return parts.join(" ");
+}
+
+// src/embeddings/vector-set.ts
+var VectorSet = class {
+  vectors;
+  get loaded() {
+    return this.vectors !== void 0;
+  }
+  async ensureLoaded(load) {
+    if (this.vectors === void 0) this.vectors = await load();
+  }
+  markDirty() {
+    this.vectors = void 0;
+  }
+  cosineTopK(query, k, opts = {}) {
+    const all = this.vectors ?? [];
+    const minScore = opts.minScore ?? -Infinity;
+    const hits = [];
+    for (const v of all) {
+      if (opts.expectModel !== void 0 && v.model !== opts.expectModel) {
+        throw new EmbeddingModelMismatchError(opts.expectModel, v.model);
+      }
+      const score = cosine(query, v.vec);
+      if (score >= minScore) hits.push({ id: v.id, score });
+    }
+    hits.sort((a, b) => b.score - a.score);
+    return hits.slice(0, k);
+  }
+};
+
 // src/indexing/unique-constraints.ts
 var UniqueConstraintSet = class {
   constructor(collectionName, uniqueDefs) {
@@ -913,7 +1270,7 @@ async function resolveStaleOnRead(accessor, outputCollection, id) {
     }
     const sourceWithId = { ...source, id };
     if (DerivationExecutor === null) {
-      ({ DerivationExecutor } = await import("./executor-VEZUBJNQ.js"));
+      ({ DerivationExecutor } = await import("./executor-DWVP4BSJ.js"));
     }
     const ctx = { vault: accessor.getReadOnlyFacade() };
     const result = await DerivationExecutor.run(spec, sourceWithId, 0, strategyHash, ctx);
@@ -1111,6 +1468,33 @@ var Collection = class {
    * Declared via the `i18nFields` collection option.
    */
   i18nFields;
+  /**
+   * #308 L1 — the configured string fields exposed to `retrieve()`. `undefined`
+   * for ordinary collections, so the search path costs nothing when unused.
+   */
+  textIndexes;
+  /**
+   * #308 L1 — the session-scoped lexical index store. `undefined` (so the dirty
+   * poke + retrieve are zero-cost) unless `textIndexes` is non-empty.
+   */
+  searchIndexStore;
+  /**
+   * #435 — the densify-enabled subset of {@link i18nFields} (fields whose
+   * descriptor opts in via `densifyOnWrite: true`). `undefined` when none opt
+   * in, so the write path skips all densify work for ordinary collections.
+   */
+  i18nDensifyFields;
+  /**
+   * #308 L2 — embedding config for write-time vector derivation. `undefined`
+   * for ordinary collections (zero cost). When set, `put()` encodes the
+   * source field(s) and stores an encrypted `_vec` sidecar.
+   */
+  embeddings;
+  /**
+   * #308 L2 — in-memory vector set, populated lazily from `_vec` sidecars.
+   * `undefined` when no embedding config is declared.
+   */
+  vectorSet;
   /**
    * Map of field name → `DictKeyDescriptor` for fields declared with
    * `dictKey()`. Used by `get()`/`list()` to add `<field>Label` virtual
@@ -1137,6 +1521,12 @@ var Collection = class {
    * Signature: `(dictName, key, locale, fallback?) => Promise<string | undefined>`
    */
   dictLabelResolver;
+  /**
+   * #308 L1 — async callback provided by the Vault to open a dynamic
+   * dictionary handle (for label-map pre-computation in the search index).
+   * Only used in `resolveDictLabelMaps()`; static dicts bypass this entirely.
+   */
+  getDictionary;
   /**
    * Synchronous callback provided by the Vault that validates
    * i18nText fields on `put()`. Throws `MissingTranslationError` when
@@ -1297,11 +1687,25 @@ var Collection = class {
     this.refEnforcer = opts.refEnforcer;
     this.joinResolver = opts.joinResolver;
     this.i18nFields = opts.i18nFields;
+    this.textIndexes = opts.textIndexes;
+    this.searchIndexStore = opts.textIndexes && opts.textIndexes.length > 0 ? opts.textIndexPersist ? new PersistedIndexStore(this.buildPersistedIndexCallbacks()) : new MemoryIndexStore() : void 0;
+    const densifyFields = opts.i18nFields ? Object.fromEntries(
+      Object.entries(opts.i18nFields).filter(([, d]) => d.options.densifyOnWrite === true)
+    ) : {};
+    this.i18nDensifyFields = Object.keys(densifyFields).length > 0 ? densifyFields : void 0;
+    if (opts.embeddings && opts.crdt) {
+      throw new Error(
+        `Collection "${opts.name}": embeddings are not supported on CRDT collections (L2). Use a non-CRDT collection for semantic search.`
+      );
+    }
+    this.embeddings = opts.embeddings;
+    this.vectorSet = opts.embeddings ? new VectorSet() : void 0;
     this.dictKeyFields = opts.dictKeyFields;
     if (opts.moneyFields) validateMoneyFieldPaths(opts.moneyFields);
     this.moneyFields = opts.moneyFields;
     this.computed = opts.computed;
     this.dictLabelResolver = opts.dictLabelResolver;
+    this.getDictionary = opts.getDictionary;
     this.i18nPutValidator = opts.i18nPutValidator;
     this.autoTranslateHook = opts.autoTranslateHook;
     this.defaultLocale = opts.defaultLocale;
@@ -1470,7 +1874,7 @@ var Collection = class {
       }
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-KKCHF2VB.js");
+      const { resolveStaleMVOnRead } = await import("./stale-IIIGOHBW.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name);
     }
     let record;
@@ -1616,6 +2020,32 @@ var Collection = class {
       if (busAfterPut) await this.subsystemBus.dispatch("afterPut", event);
     }
   }
+  /**
+   * #435 — resolve the prior stored record (with its `_i18nFilled` marker) for
+   * densify. Eager: in-memory cache; lazy: LRU then adapter. undefined if absent.
+   */
+  async resolveDensifyPrior(id) {
+    if (this.lazy && this.lru) {
+      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;
+      const rec = await this.decryptRecord(env);
+      return rec === null ? void 0 : rec;
+    }
+    await this.ensureHydrated();
+    return this.cache.get(id)?.record;
+  }
+  /**
+   * #435 — densify provenance for a record: which i18n slots were auto-filled,
+   * e.g. `{ name: ['en'] }`. undefined when nothing was filled. The marker is
+   * stripped from ordinary reads; this is the sanctioned audit accessor.
+   */
+  async i18nProvenance(id) {
+    const prior = await this.resolveDensifyPrior(id);
+    const marker = prior?.["_i18nFilled"];
+    return marker && Object.keys(marker).length > 0 ? marker : void 0;
+  }
   /**
    * Validate a record against this collection's schema WITHOUT writing it.
    * Returns the (possibly coerced) record on success; throws
@@ -1730,6 +2160,16 @@ var Collection = class {
         setAtPathInPlace(obj, field, translated);
       }
     }
+    let densifyPrior;
+    let exemptFills;
+    if (this.i18nDensifyFields) {
+      densifyPrior = await this.resolveDensifyPrior(id);
+      exemptFills = this.i18nStrategy.computeExemptFills(
+        densifyPrior,
+        record,
+        this.i18nDensifyFields
+      );
+    }
     if (this.i18nFields) {
       const obj = record;
       for (const [field, descriptor] of Object.entries(this.i18nFields)) {
@@ -1737,18 +2177,38 @@ var Collection = class {
         for (const leaf of getAtPath(obj, field)) {
           if (!leaf || typeof leaf !== "object" || Array.isArray(leaf)) continue;
           const leafMap = leaf;
-          const { value: cleaned } = this.i18nStrategy.enforceScript(
+          const { value: cleaned, warnings } = this.i18nStrategy.enforceScript(
             leafMap,
             field,
-            descriptor
+            descriptor,
+            exemptFills?.get(field)
           );
           if (cleaned !== leafMap) Object.assign(leafMap, cleaned);
+          const mode = descriptor.options.onScriptViolation;
+          if (mode === "warn" || mode === "filter") {
+            for (const w of warnings) {
+              this.emitter.emit("i18n:script-violation", {
+                vault: this.vault,
+                collection: this.name,
+                id,
+                mode,
+                warning: w
+              });
+            }
+          }
         }
       }
     }
     if (this.i18nPutValidator !== void 0) {
       this.i18nPutValidator(record);
     }
+    if (this.i18nDensifyFields) {
+      this.i18nStrategy.densify(
+        record,
+        densifyPrior,
+        this.i18nDensifyFields
+      );
+    }
     if (this.refEnforcer !== void 0) {
       await this.refEnforcer.enforceRefsOnPut(this.name, record);
     }
@@ -1827,6 +2287,7 @@ var Collection = class {
       }
       await this.onDirty?.(this.name, id, "put", version2);
       this.emitter.emit("change", { vault: this.vault, collection: this.name, id, action: "put" });
+      this.searchIndexStore?.markDirty();
       await this.onAccess?.("put", id);
       await this.dispatchDerivations(id, record, version2);
       await this.dispatchMaterializedViews(id, record);
@@ -1868,6 +2329,15 @@ var Collection = class {
     }
     const envelope = await this.encryptRecord(record, version, cek, options?.source, options?.sourceTs);
     await this.adapter.put(this.vault, this.name, id, envelope);
+    if (this.embeddings) {
+      const text = embeddingSourceText(record, this.embeddings.source);
+      const vec = await this.embeddings.encode(text);
+      if (vec.length !== this.embeddings.dim) throw new EmbeddingDimMismatchError("embeddings", this.embeddings.dim, vec.length);
+      const body = JSON.stringify({ vec: Array.from(vec), model: this.embeddings.model, dim: this.embeddings.dim });
+      const vecEnv = await this.encryptJsonString(body, version);
+      await this.adapter.put(this.vault, "_vec", id, vecEnv);
+      this.vectorSet?.markDirty();
+    }
     if (this.ledger) {
       const appendInput = {
         op: "put",
@@ -1898,6 +2368,7 @@ var Collection = class {
       id,
       action: "put"
     });
+    this.searchIndexStore?.markDirty();
     await this.onAccess?.("put", id);
     await this.dispatchDerivations(id, record, version);
     await this.dispatchMaterializedViews(id, record);
@@ -1929,7 +2400,7 @@ var Collection = class {
       if (mode === "eager") {
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-BIW4FT5R.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-HB2YMIYC.js"));
         }
         await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
@@ -1938,7 +2409,7 @@ var Collection = class {
         });
       } else if (mode === "lazy") {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-KKCHF2VB.js");
+          staleHelpers = await import("./stale-IIIGOHBW.js");
         }
         staleHelpers.markMVStale(registry, reg.spec.name);
       }
@@ -2112,7 +2583,7 @@ var Collection = class {
         continue;
       }
       if (DerivationExecutor === null) {
-        ({ DerivationExecutor } = await import("./executor-VEZUBJNQ.js"));
+        ({ DerivationExecutor } = await import("./executor-DWVP4BSJ.js"));
       }
       for (const run of runs) {
         const ctx = { vault: this.derivationSource.getReadOnlyFacade() };
@@ -2131,7 +2602,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-OC4QVTS2.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-BMT7I6FI.js");
             const prior = await loadFanoutSidecar(
               this.adapter,
               this.vault,
@@ -2421,6 +2892,7 @@ var Collection = class {
       id,
       action: "delete"
     });
+    this.searchIndexStore?.markDirty();
     await this.onAccess?.("delete", id);
     if (!internal) {
       await this.dispatchMaterializedViewsOnDelete(id);
@@ -2494,7 +2966,7 @@ var Collection = class {
       for (const [outputKey, outSpec] of Object.entries(spec.outputs)) {
         if (outSpec.shape !== "array") continue;
         if (helpers === null) {
-          helpers = await import("./fanout-sidecar-OC4QVTS2.js");
+          helpers = await import("./fanout-sidecar-BMT7I6FI.js");
         }
         const sidecar = await helpers.loadFanoutSidecar(
           this.adapter,
@@ -2534,7 +3006,7 @@ var Collection = class {
       if (mode === "eager") {
         if (executor === null) {
           ;
-          ({ MaterializedViewExecutor: executor } = await import("./executor-BIW4FT5R.js"));
+          ({ MaterializedViewExecutor: executor } = await import("./executor-HB2YMIYC.js"));
         }
         await executor.refresh(reg, {
           getCollection: (name) => this.materializedViewSource.getCollection(name),
@@ -2543,7 +3015,7 @@ var Collection = class {
         });
       } else if (mode === "lazy") {
         if (staleHelpers === null) {
-          staleHelpers = await import("./stale-KKCHF2VB.js");
+          staleHelpers = await import("./stale-IIIGOHBW.js");
         }
         staleHelpers.markMVStale(registry, reg.spec.name);
       }
@@ -2566,7 +3038,7 @@ var Collection = class {
       );
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-KKCHF2VB.js");
+      const { resolveStaleMVOnRead } = await import("./stale-IIIGOHBW.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name);
     }
     await this.ensureHydrated();
@@ -2602,9 +3074,255 @@ var Collection = class {
     }
     await this.ensureHydrated();
     const entries = [];
-    for (const [id, e] of this.cache) entries.push({ id, record: e.record });
+    for (const [id, e] of this.cache) entries.push({ id, record: stripI18nFilled(e.record) });
     return searchScan(entries, field, query, opts);
   }
+  /** #308 L1 — build IndexDoc[] for the configured text fields over the live cache. */
+  buildRetrievalDocs(labelMaps, blobFilenames, only) {
+    const docs = [];
+    for (const [id, e] of this.cache) {
+      const rec = stripI18nFilled(e.record);
+      const fields = buildStringFieldEntries(rec, this.textIndexes ?? [], only);
+      if (this.i18nFields) fields.push(...buildI18nFieldEntries(rec, this.i18nFields, this.textIndexes ?? [], only));
+      if (this.dictKeyFields) fields.push(...buildDictKeyFieldEntries(rec, this.dictKeyFields, labelMaps, this.textIndexes ?? [], only));
+      const blobNames = blobFilenames.get(id);
+      if (blobNames) fields.push(...buildBlobFieldEntries(blobNames));
+      if (fields.length > 0) docs.push({ id, fields });
+    }
+    return docs;
+  }
+  /** #308 L1 — true iff any configured text index is also a blob field (gates ALL slot I/O). */
+  hasIndexedBlobFields(only) {
+    if (!this.blobFields || !this.textIndexes) return false;
+    const fields = only ? this.textIndexes.filter((f) => only.includes(f)) : this.textIndexes;
+    return fields.some((f) => f in this.blobFields);
+  }
+  /**
+   * #308 L1 — resolve `recordId -> (blobField -> filenames[])` by listing slots
+   * for the configured blob fields of each cached record. Blob slot metadata is
+   * NOT inline on the record: it lives in a separate `_blob_slots_*` collection,
+   * so this costs ONE `blob(id).list()` (a `listSlots`) per record at build time
+   * — the heaviest indexing source. Fully gated by {@link hasIndexedBlobFields};
+   * non-blob (and blob-but-not-indexed) collections do ZERO slot I/O.
+   */
+  async resolveBlobFilenames(only) {
+    const out = /* @__PURE__ */ new Map();
+    if (!this.hasIndexedBlobFields(only)) return out;
+    const indexed = (only ? this.textIndexes.filter((f) => only.includes(f)) : this.textIndexes).filter((f) => f in this.blobFields);
+    const indexedSet = new Set(indexed);
+    for (const id of this.cache.keys()) {
+      let slots;
+      try {
+        slots = await this.blob(id).list();
+      } catch {
+        continue;
+      }
+      let byField;
+      for (const slot of slots) {
+        if (!indexedSet.has(slot.name) || !slot.filename) continue;
+        if (!byField) {
+          byField = /* @__PURE__ */ new Map();
+          out.set(id, byField);
+        }
+        const names = byField.get(slot.name);
+        if (names) names.push(slot.filename);
+        else byField.set(slot.name, [slot.filename]);
+      }
+    }
+    return out;
+  }
+  /** #308 L1 — field -> (key -> {locale->label}) for dictKey fields; static from table, dynamic via getDictionary().list(). */
+  async resolveDictLabelMaps() {
+    const maps = /* @__PURE__ */ new Map();
+    if (!this.dictKeyFields || !this.textIndexes) return maps;
+    for (const field of this.textIndexes) {
+      const desc = this.dictKeyFields[field];
+      if (!desc) continue;
+      const m = /* @__PURE__ */ new Map();
+      if (isStaticDictDescriptor(desc)) {
+        for (const [key, labels] of Object.entries(desc.table)) m.set(key, labels);
+      } else {
+        if (this.getDictionary) {
+          const handle = await this.getDictionary(desc.name);
+          for (const e of await handle.list()) m.set(e.key, e.labels);
+        }
+      }
+      maps.set(field, m);
+    }
+    return maps;
+  }
+  /** #308 L1.5 — force-persist the lexical index now (e.g. on save/idle). Persists only when textIndexPersist is enabled; a no-op otherwise. */
+  async flushIndex() {
+    if (!this.searchIndexStore) return;
+    await this.ensureHydrated();
+    const labelMaps = await this.resolveDictLabelMaps();
+    const blobFilenames = await this.resolveBlobFilenames();
+    await this.searchIndexStore.ensureBuilt(() => this.buildRetrievalDocs(labelMaps, blobFilenames));
+    await this.searchIndexStore.flush?.();
+  }
+  /** #308 L2 — load + decrypt all _vec sidecars into StoredVector[] for the VectorSet. */
+  buildVectorLoad() {
+    return async () => {
+      const ids = await this.adapter.list(this.vault, "_vec");
+      const out = [];
+      for (const id of ids) {
+        const env = await this.adapter.get(this.vault, "_vec", id);
+        if (!env) continue;
+        const body = await this.decryptJsonString(env);
+        if (body === null) continue;
+        const parsed = JSON.parse(body);
+        out.push({ id, vec: new Float32Array(parsed.vec), model: parsed.model });
+      }
+      return out;
+    };
+  }
+  /**
+   * #308 L1.5 — build the PersistedIndexCallbacks bridge: crypto lives here
+   * (collection has getDEK / encryptJsonString / decryptJsonString / adapter),
+   * the index store itself is crypto-free.
+   *
+   * Fingerprint encoding: body-wrap approach — save(json, fp) stores
+   * JSON.stringify({ fp, idx: json }) as the encrypted body so the standard
+   * EncryptedEnvelope shape is never extended. load() decrypts and JSON.parses
+   * the wrapper back out.
+   *
+   * Cache shape: this.cache stores { record, version } — currentFingerprint()
+   * iterates over e.version.
+   */
+  buildPersistedIndexCallbacks() {
+    const FT = "_ftindex";
+    return {
+      load: async () => {
+        const env = await this.adapter.get(this.vault, FT, this.name);
+        if (!env) return null;
+        const body = await this.decryptJsonString(env);
+        if (body === null) return null;
+        try {
+          const wrapped = JSON.parse(body);
+          return { json: wrapped.idx, fingerprint: wrapped.fp };
+        } catch {
+          return null;
+        }
+      },
+      save: async (json, fp) => {
+        const body = JSON.stringify({ fp, idx: json });
+        const env = await this.encryptJsonString(body, fp.count);
+        await this.adapter.put(this.vault, FT, this.name, env);
+      },
+      remove: async () => {
+        await this.adapter.delete(this.vault, FT, this.name);
+      },
+      currentFingerprint: () => {
+        let maxVersion = 0;
+        for (const e of this.cache.values()) if (e.version > maxVersion) maxVersion = e.version;
+        return { count: this.cache.size, maxVersion };
+      }
+    };
+  }
+  /** #308 L1 — pre-build the lexical index (e.g. on open) so the first retrieve() pays no build scan. */
+  async warmIndex() {
+    if (!this.searchIndexStore) return;
+    if (this.lazy) {
+      throw new Error(
+        `Collection "${this.name}": warmIndex() requires eager mode (prefetch: true).`
+      );
+    }
+    await this.ensureHydrated();
+    const built = this.searchIndexStore.built;
+    const labelMaps = built ? /* @__PURE__ */ new Map() : await this.resolveDictLabelMaps();
+    const blobFilenames = built ? /* @__PURE__ */ new Map() : await this.resolveBlobFilenames();
+    await this.searchIndexStore.ensureBuilt(() => this.buildRetrievalDocs(labelMaps, blobFilenames));
+  }
+  /** #308 — retrieval. mode: 'lexical' (default) | 'semantic' (L2) | 'hybrid' (L3). */
+  async retrieve(query, opts = {}) {
+    const hits = opts.mode === "semantic" ? await this.retrieveSemantic(query, opts) : opts.mode === "hybrid" ? await this.retrieveHybrid(query, opts) : await this.retrieveLexical(query, opts);
+    return opts.within ? this.applyWithin(hits, opts.within) : hits;
+  }
+  /** #308 L3 — keep only hits whose id matches the structured query, re-rank 1-based. */
+  applyWithin(hits, within) {
+    const ids = new Set(within._idArray());
+    return hits.filter((h) => ids.has(h.id)).map((h, i) => ({ ...h, rank: i + 1 }));
+  }
+  /** #308 L1 — client-side lexical retrieval; ranked { id, score, field, snippet, locale? }. */
+  async retrieveLexical(query, opts) {
+    if (!this.searchIndexStore) {
+      throw new Error(`Collection "${this.name}": retrieve() requires a textIndexes config.`);
+    }
+    if (this.lazy) {
+      throw new Error(
+        `Collection "${this.name}": retrieve() requires eager mode (prefetch: true).`
+      );
+    }
+    await this.ensureHydrated();
+    const built = this.searchIndexStore.built;
+    const labelMaps = built ? /* @__PURE__ */ new Map() : await this.resolveDictLabelMaps();
+    const blobFilenames = built ? /* @__PURE__ */ new Map() : await this.resolveBlobFilenames();
+    const index = await this.searchIndexStore.ensureBuilt(() => this.buildRetrievalDocs(labelMaps, blobFilenames));
+    const hits = index.query(query, {
+      ...opts.limit !== void 0 ? { limit: opts.limit } : {},
+      ...opts.match ? { match: opts.match } : {},
+      ...opts.prefix ? { prefix: opts.prefix } : {},
+      ...opts.fields ? { fields: opts.fields } : {}
+    });
+    const window = opts.snippetWindow ?? 80;
+    return hits.map((h, i) => {
+      const base = {
+        id: h.id,
+        score: h.score,
+        rank: i + 1,
+        field: h.field,
+        snippet: extractSnippet(h.text, h.offset, window),
+        ...h.locale !== void 0 ? { locale: h.locale } : {},
+        ...opts.includeRecord ? (() => {
+          const e = this.cache.get(h.id);
+          return e ? { record: stripI18nFilled(e.record) } : {};
+        })() : {}
+      };
+      return base;
+    });
+  }
+  /** #308 L3 — hybrid: fuse lexical (L1) + semantic (L2) by RRF. Requires embeddings. */
+  async retrieveHybrid(query, opts) {
+    if (!this.embeddings) {
+      throw new Error(`Collection "${this.name}": retrieve({mode:'hybrid'}) requires an embeddings config.`);
+    }
+    const [lex, sem] = await Promise.all([
+      this.retrieveLexical(query, opts),
+      this.retrieveSemantic(query, opts)
+    ]);
+    return fuseRetrieval([lex, sem], opts.limit !== void 0 ? { limit: opts.limit } : {});
+  }
+  /** #308 L2 — semantic branch of retrieve(): encode query → similarTo(). */
+  async retrieveSemantic(query, opts) {
+    if (!this.embeddings) throw new Error(`Collection "${this.name}": retrieve({mode:'semantic'}) requires an embeddings config.`);
+    if (this.lazy) throw new Error(`Collection "${this.name}": retrieve() requires eager mode (prefetch: true).`);
+    const qVec = await this.embeddings.encode(query);
+    return this.similarTo(qVec, {
+      ...opts.limit !== void 0 ? { k: opts.limit } : {},
+      ...opts.minScore !== void 0 ? { minScore: opts.minScore } : {},
+      ...opts.includeRecord ? { includeRecord: true } : {}
+    });
+  }
+  /** #308 L2 — raw-vector kNN over the encrypted vector set (decrypted in the trusted tier).
+   *  Snippet is '' for vector hits in v1 (semantic match isn't span-located). */
+  async similarTo(vector, opts = {}) {
+    if (!this.embeddings || !this.vectorSet) throw new Error(`Collection "${this.name}": similarTo() requires an embeddings config.`);
+    if (this.lazy) throw new Error(`Collection "${this.name}": similarTo() requires eager mode (prefetch: true).`);
+    await this.ensureHydrated();
+    await this.vectorSet.ensureLoaded(this.buildVectorLoad());
+    const hits = this.vectorSet.cosineTopK(vector, opts.k ?? 10, {
+      ...opts.minScore !== void 0 ? { minScore: opts.minScore } : {},
+      expectModel: this.embeddings.model
+    });
+    return hits.map((h, i) => {
+      const base = { id: h.id, score: h.score, rank: i + 1, field: "(vector)", snippet: "" };
+      if (opts.includeRecord) {
+        const e = this.cache.get(h.id);
+        if (e) base.record = stripI18nFilled(e.record);
+      }
+      return base;
+    });
+  }
   // ─── Bulk operations ─────────────────────────────────────
   /**
    * Put many records in one call. Each item is processed sequentially
@@ -2774,6 +3492,7 @@ var Collection = class {
       // back to a linear scan otherwise.
       getIndexes: () => this.getIndexes(),
       lookupById: (id) => this.cache.get(id)?.record,
+      snapshotEntries: () => [...this.cache.entries()].map(([id, e]) => ({ id, record: e.record })),
       ...this.moneyFields ? { moneyFields: this.moneyFields } : {}
     };
     const resolver = this.joinResolver;
@@ -3204,6 +3923,7 @@ var Collection = class {
   async _applyRemoteChange(id, action) {
     await this._invalidateCacheEntry(id);
     this.emitter.emit("change", { vault: this.vault, collection: this.name, id, action });
+    this.searchIndexStore?.markDirty();
   }
   /** @internal — the current in-memory record without a store read (for conflict capture). */
   _peekCached(id) {
@@ -3516,7 +4236,7 @@ var Collection = class {
     const hasStaticDisplay = hasDict && this.dictKeyFields !== void 0 && Object.values(this.dictKeyFields).some(
       (d) => isStaticDictDescriptor(d) && d.displayLocale !== void 0
     );
-    if (!locale && !hasStaticDisplay) return result;
+    if (!locale && !hasStaticDisplay) return stripI18nFilled(result);
     const layer = localeOpts?._layer ?? "read";
     if (locale && hasI18n && this.i18nFields) {
       result = this.i18nStrategy.applyI18nLocale(result, this.i18nFields, locale, localeOpts?.fallback, layer);
@@ -3583,7 +4303,7 @@ var Collection = class {
       }
       result = withLabels;
     }
-    return result;
+    return stripI18nFilled(result);
   }
   /**
    * Low-level: encrypt a pre-serialised JSON string into an EncryptedEnvelope.
@@ -3702,6 +4422,19 @@ var Collection = class {
     }
     return { purged, residue };
   }
+  /** #308 L2 — 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);
+    this.vectorSet?.markDirty();
+  }
+  /** #308 L1.5 — drop the persisted lexical-index blob (forget/erasure): an opaque
+   *  all-records index must not survive crypto-shred. Idempotent; no-op without persist. */
+  async _purgeSearchIndex() {
+    const store = this.searchIndexStore;
+    if (store && "removePersisted" in store) await store.removePersisted();
+    else store?.markDirty();
+  }
   /**
    * Bulk-load the persisted-index mirror from `_idx/<field>/*` side-cars
    * on first lazy-mode query. Idempotent — subsequent calls short-circuit
@@ -6966,6 +7699,10 @@ var Vault = class {
       collOpts.onCrossTierAccess = (event) => this.emitCrossTier(event);
       if (this.syncAdapter !== void 0) collOpts.syncAdapter = this.syncAdapter;
       if (options?.i18nFields !== void 0) collOpts.i18nFields = options.i18nFields;
+      if (options?.embeddings !== void 0) collOpts.embeddings = options.embeddings;
+      if (options?.textIndexes !== void 0) collOpts.textIndexes = options.textIndexes;
+      if (options?.warmIndexOnOpen !== void 0) collOpts.warmIndexOnOpen = options.warmIndexOnOpen;
+      if (options?.textIndexPersist !== void 0) collOpts.textIndexPersist = options.textIndexPersist;
       if (options?.moneyFields !== void 0) collOpts.moneyFields = options.moneyFields;
       if (options?.computed !== void 0) collOpts.computed = options.computed;
       if (options?.dictKeyFields !== void 0) {
@@ -6978,6 +7715,7 @@ var Vault = class {
           const handle = this.dictionary(dictName);
           return handle.resolveLabel(key, locale, fallback);
         };
+        collOpts.getDictionary = async (name) => this.dictionary(name);
         collOpts.dictKeyFields = options.dictKeyFields;
       }
       if (options?.i18nFields !== void 0 || options?.dictKeyFields !== void 0) {
@@ -6991,6 +7729,10 @@ var Vault = class {
       }
       coll = new Collection(collOpts);
       this.collectionCache.set(collectionName, coll);
+      if (options?.warmIndexOnOpen === true && options.prefetch !== false) {
+        void coll.warmIndex().catch(() => {
+        });
+      }
       if (options?.persistJsonSchema === true && options.schema !== void 0 && (options.schemaUpdate?.length ?? 0) === 0) {
         const validator = options.schema;
         const work = (async () => {
@@ -7100,6 +7842,16 @@ var Vault = class {
     this.#fenceWatcher = void 0;
     this.#fenceCoordinationStarted = false;
   }
+  /** @internal #308 L1.5 — best-effort flush of all open collections' persisted
+   *  lexical indexes on close(). Called fire-and-forget from noydb.close().
+   *  Correctness is backstopped by the fingerprint: a missed flush → rebuild on
+   *  next load. Only collections with textIndexPersist have a flush(); others no-op. */
+  async _flushSearchIndexes() {
+    for (const coll of this.collectionCache.values()) {
+      await coll.flushIndex().catch(() => {
+      });
+    }
+  }
   /** @internal Drive one heartbeat + watch cycle deterministically (tests). */
   async _fenceTick() {
     this._ensureFenceCoordination();
@@ -7646,12 +8398,12 @@ var Vault = class {
     if (!fieldSchema) {
       throw new AttestationError(`issueAttestation: collection '${collectionName}' has no attestation field-schema. Declare it via vault.collection('${collectionName}', { attestation: { fields: [...] } }).`);
     }
-    const { issueAttestationCore } = await import("./issue-ZZ2XPOGP.js");
+    const { issueAttestationCore } = await import("./issue-FZRTVGRE.js");
     const out = await issueAttestationCore(this.makeIssueContext(), { collection: collectionName, id, fieldSchema });
     return { docId: out.docId, qr: out.qr, keyId: out.keyId, publicKeyB64: out.publicKeyB64 };
   }
   async getDocumentSigningPublicKey() {
-    const { loadSigner, loadOrCreateSigner } = await import("./signer-SCJ6C6HQ.js");
+    const { loadSigner, loadOrCreateSigner } = await import("./signer-JMK6W2Y6.js");
     const existing = await loadSigner(this.adapter, this.name, this.getDEK);
     if (existing) return { keyId: existing.keyId, publicKeyB64: existing.publicKeyB64 };
     if (this.keyring.role !== "owner") {
@@ -7677,19 +8429,19 @@ var Vault = class {
     };
   }
   async revokeAttestation(docId) {
-    const { revokeDocCore } = await import("./revoke-QJ2HUM4W.js");
+    const { revokeDocCore } = await import("./revoke-AOCAVR56.js");
     await revokeDocCore(this.makeRevokeContext(), docId);
   }
   async unrevokeAttestation(docId) {
-    const { unrevokeDocCore } = await import("./revoke-QJ2HUM4W.js");
+    const { unrevokeDocCore } = await import("./revoke-AOCAVR56.js");
     await unrevokeDocCore(this.makeRevokeContext(), docId);
   }
   async getRevokedDocIds() {
-    const { getRevokedDocIdsCore } = await import("./revoke-QJ2HUM4W.js");
+    const { getRevokedDocIdsCore } = await import("./revoke-AOCAVR56.js");
     return getRevokedDocIdsCore(this.makeRevokeContext());
   }
   async publishRevocationList() {
-    const { publishRevocationListCore } = await import("./revoke-QJ2HUM4W.js");
+    const { publishRevocationListCore } = await import("./revoke-AOCAVR56.js");
     return publishRevocationListCore(this.makeRevokeContext());
   }
   makeRevokeContext() {
@@ -8174,6 +8926,11 @@ var Vault = class {
       const idxPurge = await coll._purgePersistedIndexes(ref2.id);
       indexPostingsPurged += idxPurge.purged;
       for (const field of idxPurge.residue) indexResidue.push(`${ref2.collection}:${ref2.id}:${field}`);
+      try {
+        await coll._purgeVector(ref2.id);
+      } catch {
+        indexResidue.push(`${ref2.collection}:${ref2.id}:_vec`);
+      }
       if (blobsEnabled) {
         const r = await this.collection(ref2.collection).blob(ref2.id).shredAllForRecord();
         blobsShredded += r.shredded.length;
@@ -8188,6 +8945,13 @@ var Vault = class {
       }
       await this._removeSubjectRef(subjectId, ref2);
     }
+    for (const collName of collections) {
+      try {
+        await this.collection(collName)._purgeSearchIndex();
+      } catch {
+        indexResidue.push(`${collName}:_ftindex`);
+      }
+    }
     const subjectHash = await sha256Hex2(subjectId);
     const ledger = this.getLedgerOrNull();
     if (!ledger) {
@@ -8348,7 +9112,7 @@ var Vault = class {
   async _initDerivations(handles) {
     if (handles.length === 0) return;
     const [{ DerivationRegistry }, { ReadOnlyVaultFacade }] = await Promise.all([
-      import("./registry-CMEVTOCN.js"),
+      import("./registry-IEU6ATO7.js"),
       import("./read-only-facade-EX6WZZBP.js")
     ]);
     const registry = new DerivationRegistry();
@@ -8379,7 +9143,7 @@ var Vault = class {
    */
   async _initMaterializedViews(handles) {
     if (handles.length === 0) return;
-    const { MaterializedViewRegistry } = await import("./registry-OUZ3VBZA.js");
+    const { MaterializedViewRegistry } = await import("./registry-53A55ZZE.js");
     const registry = new MaterializedViewRegistry();
     this.materializedViewRegistry = registry;
     const db = this;
@@ -8403,7 +9167,7 @@ var Vault = class {
    */
   async _initOverlayedViews(handles) {
     if (handles.length === 0) return;
-    const { OverlayedViewRegistry } = await import("./registry-XUBRO5JJ.js");
+    const { OverlayedViewRegistry } = await import("./registry-FKL4SLU4.js");
     const registry = new OverlayedViewRegistry();
     const mvRegistry = this.materializedViewRegistry;
     const overlayNames = /* @__PURE__ */ new Set();
@@ -8450,13 +9214,13 @@ var Vault = class {
     if (!reg) {
       throw new Error(`refreshView: no MV registered with name "${name}"`);
     }
-    const { MaterializedViewExecutor } = await import("./executor-BIW4FT5R.js");
+    const { MaterializedViewExecutor } = await import("./executor-HB2YMIYC.js");
     const result = await MaterializedViewExecutor.refresh(reg, {
       getCollection: (n) => this.collection(n),
       getActiveTxContext: () => this.noydb._activeTxContextOrNull,
       getQueryContext: () => this
     });
-    const { clearMVStale } = await import("./stale-KKCHF2VB.js");
+    const { clearMVStale } = await import("./stale-IIIGOHBW.js");
     clearMVStale(registry, name);
     return result;
   }
@@ -8472,7 +9236,7 @@ var Vault = class {
     if (registry === null) return { derived: 0, failed: 0 };
     const strategies = registry.strategiesForSource(sourceCollection);
     if (strategies.length === 0) return { derived: 0, failed: 0 };
-    const { DerivationExecutor } = await import("./executor-VEZUBJNQ.js");
+    const { DerivationExecutor } = await import("./executor-DWVP4BSJ.js");
     const sourceColl = this.collection(sourceCollection);
     const records = await sourceColl.list();
     const ctx = { vault: this.derivationFacade ?? new (await import("./read-only-facade-EX6WZZBP.js")).ReadOnlyVaultFacade(this, "derivation") };
@@ -8497,7 +9261,7 @@ var Vault = class {
           if (!outSpec) continue;
           const outputColl = this.collection(outSpec.collection);
           if (out.kind === "array") {
-            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-OC4QVTS2.js");
+            const { loadFanoutSidecar, saveFanoutSidecar } = await import("./fanout-sidecar-BMT7I6FI.js");
             const prior = await loadFanoutSidecar(this.adapter, this.name, spec.source, id, key);
             const prevKeys = new Set(prior?.keys ?? []);
             const newKeysList = out.entries.map((e) => e.key);
@@ -8719,7 +9483,7 @@ var Vault = class {
    * collection.
    */
   async delegate(opts) {
-    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-4JSMM6BB.js");
+    const { issueDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-ZEH4LKEM.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."
@@ -8741,7 +9505,7 @@ var Vault = class {
    * if the id does not exist.
    */
   async revokeDelegation(id) {
-    const { revokeDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-4JSMM6BB.js");
+    const { revokeDelegation, DELEGATIONS_COLLECTION } = await import("./delegation-ZEH4LKEM.js");
     await revokeDelegation(this.adapter, this.name, id);
     void DELEGATIONS_COLLECTION;
   }
@@ -9211,7 +9975,7 @@ var Vault = class {
    * @see docs/subsystems/public-envelope.md
    */
   async getPublicEnvelope(opts = {}) {
-    const { readPublicEnvelope: readPublicEnvelope2 } = await import("./public-envelope-O6X6AUUS.js");
+    const { readPublicEnvelope: readPublicEnvelope2 } = await import("./public-envelope-S2S2VR3F.js");
     return readPublicEnvelope2(this.adapter, this.name, opts);
   }
   /**
@@ -10931,7 +11695,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-3SVNESQ3.js");
+      const { GuardExecutor } = await import("./executor-HO3SIRSF.js");
       for (const g of guards) {
         await GuardExecutor.checkFrozenFields(g, e.docId, existing, incoming, e.computedFieldNames);
       }
@@ -11947,6 +12711,7 @@ var Noydb = class {
     }
     this.syncEngines.clear();
     for (const v of this.vaultCache.values()) v._stopFenceCoordination();
+    for (const v of this.vaultCache.values()) void v._flushSearchIndexes();
     this.disableTabCoordination();
     this.keyringCache.clear();
     this.vaultCache.clear();
@@ -13137,4 +13902,4 @@ export {
   Noydb,
   createNoydb
 };
-//# sourceMappingURL=chunk-KSKKLVPA.js.map
+//# sourceMappingURL=chunk-ZDW22N3E.js.map