@noy-db/hub 0.3.0-pre.8 → 0.3.0

package/dist/chunk-OSDB5WW3.js

@@ -0,0 +1,739 @@
+import {
+  fuseRetrieval
+} from "./chunk-AURFOK3D.js";
+import {
+  getAtPath,
+  isStaticDictDescriptor,
+  stripI18nFilled
+} from "./chunk-6JTIAGHD.js";
+import {
+  liveRecordIsElevated
+} from "./chunk-PN2XMATY.js";
+import {
+  EmbeddingDimMismatchError,
+  EmbeddingModelMismatchError,
+  SearchNotEnabledError
+} from "./chunk-BIOUI4HL.js";
+
+// src/with-lookup/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/with-lookup/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/with-lookup/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/with-lookup/embeddings/vec-id.ts
+function encodeVecId(collection, recordId) {
+  if (collection.includes("/")) {
+    throw new Error(
+      `encodeVecId: collection name "${collection}" must not contain "/" \u2014 it would make the "${collection}/${recordId}" _vec id ambiguous against another collection's rows.`
+    );
+  }
+  return `${collection}/${recordId}`;
+}
+function decodeVecId(collection, vecId) {
+  const prefix = `${collection}/`;
+  if (!vecId.startsWith(prefix)) return null;
+  return vecId.slice(prefix.length);
+}
+function isVecIdFor(collection, vecId) {
+  return vecId.startsWith(`${collection}/`);
+}
+
+// src/with-lookup/search/tokenize.ts
+var WORD = /[\p{L}\p{N}]+/gu;
+var tokenize = (text) => {
+  if (!text) return [];
+  return text.normalize("NFKC").toLowerCase().match(WORD) ?? [];
+};
+
+// src/with-lookup/search/scan.ts
+var K1 = 1.2;
+var B = 0.75;
+function fieldText(record, field) {
+  const v = record[field];
+  if (typeof v === "string") return v;
+  if (v === null || v === void 0) return "";
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  return "";
+}
+function searchScan(entries, field, query, opts = {}, tokenizer = tokenize) {
+  const queryTerms = tokenizer(query);
+  if (queryTerms.length === 0) return [];
+  const match = opts.match ?? "any";
+  const usePrefix = opts.prefix ?? false;
+  const exactTerms = usePrefix ? queryTerms.slice(0, -1) : queryTerms;
+  const prefixTerm = usePrefix ? queryTerms[queryTerms.length - 1] : void 0;
+  const docs = entries.map((e) => ({ id: e.id, record: e.record, terms: tokenizer(fieldText(e.record, field)) }));
+  const N = docs.length || 1;
+  const df = /* @__PURE__ */ new Map();
+  let totalLen = 0;
+  for (const d of docs) {
+    totalLen += d.terms.length;
+    for (const t of new Set(d.terms)) df.set(t, (df.get(t) ?? 0) + 1);
+  }
+  const avgdl = totalLen / N || 1;
+  let prefixDf = 0;
+  if (prefixTerm !== void 0) {
+    for (const d of docs) {
+      if (d.terms.some((t) => t.startsWith(prefixTerm))) prefixDf++;
+    }
+  }
+  const requiredCount = exactTerms.length + (prefixTerm !== void 0 ? 1 : 0);
+  const results = [];
+  for (const d of docs) {
+    const tf = /* @__PURE__ */ new Map();
+    for (const t of d.terms) tf.set(t, (tf.get(t) ?? 0) + 1);
+    const matched = [];
+    for (const qt of exactTerms) {
+      const c = tf.get(qt) ?? 0;
+      if (c > 0) matched.push({ tf: c, df: df.get(qt) ?? 0 });
+    }
+    if (prefixTerm !== void 0) {
+      let ptf = 0;
+      for (const [t, c] of tf) if (t.startsWith(prefixTerm)) ptf += c;
+      if (ptf > 0) matched.push({ tf: ptf, df: prefixDf });
+    }
+    if (matched.length === 0) continue;
+    if (match === "all" && matched.length < requiredCount) continue;
+    let score = 0;
+    for (const m of matched) {
+      const idf = Math.log(1 + (N - m.df + 0.5) / (m.df + 0.5));
+      const denom = m.tf + K1 * (1 - B + B * (d.terms.length / avgdl));
+      score += idf * (m.tf * (K1 + 1) / (denom || 1));
+    }
+    results.push({ id: d.id, score, record: d.record });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return opts.limit !== void 0 ? results.slice(0, opts.limit) : results;
+}
+
+// src/with-lookup/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/with-lookup/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/with-lookup/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/with-lookup/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/with-lookup/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/with-lookup/search/active.ts
+function withSearch() {
+  return {
+    async search(ctx, field, query, opts) {
+      const { search: search2 } = await import("./collection-facade-TLWIPI76.js");
+      return search2(ctx, field, query, opts);
+    },
+    async retrieve(ctx, query, opts) {
+      const { retrieve: retrieve2 } = await import("./collection-facade-TLWIPI76.js");
+      return retrieve2(ctx, query, opts);
+    },
+    async similarTo(ctx, vector, opts) {
+      const { similarTo: similarTo2 } = await import("./collection-facade-TLWIPI76.js");
+      return similarTo2(ctx, vector, opts);
+    },
+    async warmIndex(ctx) {
+      const { warmIndex: warmIndex2 } = await import("./collection-facade-TLWIPI76.js");
+      return warmIndex2(ctx);
+    },
+    async flushIndex(ctx) {
+      const { flushIndex: flushIndex2 } = await import("./collection-facade-TLWIPI76.js");
+      return flushIndex2(ctx);
+    },
+    async embedOnWrite(ctx, id, record, version) {
+      const { embedOnWrite: embedOnWrite2 } = await import("./collection-facade-TLWIPI76.js");
+      return embedOnWrite2(ctx, id, record, version);
+    },
+    async rebuildEmbeddings(ctx) {
+      const { rebuildEmbeddings: rebuildEmbeddings2 } = await import("./collection-facade-TLWIPI76.js");
+      return rebuildEmbeddings2(ctx);
+    }
+  };
+}
+
+// src/with-lookup/search/strategy.ts
+var NO_SEARCH = {
+  async search() {
+    throw new SearchNotEnabledError();
+  },
+  async retrieve() {
+    throw new SearchNotEnabledError();
+  },
+  async similarTo() {
+    throw new SearchNotEnabledError();
+  },
+  async warmIndex() {
+    throw new SearchNotEnabledError();
+  },
+  async flushIndex() {
+    throw new SearchNotEnabledError();
+  },
+  async embedOnWrite() {
+    throw new SearchNotEnabledError();
+  },
+  async rebuildEmbeddings() {
+    throw new SearchNotEnabledError();
+  }
+};
+
+// src/with-lookup/search/collection-facade.ts
+async function search(ctx, field, query, opts = {}) {
+  if (ctx.lazy) {
+    throw new Error(
+      `Collection "${ctx.name}": search() (scan mode) requires eager mode (prefetch: true). A store-usable blind index for lazy / at-scale search is a separate gated opt-in (#308).`
+    );
+  }
+  await ctx.ensureHydrated();
+  const entries = [];
+  for (const [id, e] of ctx.cache) entries.push({ id, record: stripI18nFilled(e.record) });
+  return searchScan(entries, field, query, opts);
+}
+function buildRetrievalDocs(ctx, labelMaps, blobFilenames, only) {
+  const docs = [];
+  for (const [id, e] of ctx.cache) {
+    const rec = stripI18nFilled(e.record);
+    const fields = buildStringFieldEntries(rec, ctx.textIndexes ?? [], only);
+    if (ctx.i18nFields) fields.push(...buildI18nFieldEntries(rec, ctx.i18nFields, ctx.textIndexes ?? [], only));
+    if (ctx.dictKeyFields) fields.push(...buildDictKeyFieldEntries(rec, ctx.dictKeyFields, labelMaps, ctx.textIndexes ?? [], only));
+    const blobNames = blobFilenames.get(id);
+    if (blobNames) fields.push(...buildBlobFieldEntries(blobNames));
+    if (fields.length > 0) docs.push({ id, fields });
+  }
+  return docs;
+}
+function hasIndexedBlobFields(ctx, only) {
+  if (!ctx.blobFields || !ctx.textIndexes) return false;
+  const fields = only ? ctx.textIndexes.filter((f) => only.includes(f)) : ctx.textIndexes;
+  return fields.some((f) => f in ctx.blobFields);
+}
+async function resolveBlobFilenames(ctx, only) {
+  const out = /* @__PURE__ */ new Map();
+  if (!hasIndexedBlobFields(ctx, only)) return out;
+  const indexed = (only ? ctx.textIndexes.filter((f) => only.includes(f)) : ctx.textIndexes).filter((f) => f in ctx.blobFields);
+  const indexedSet = new Set(indexed);
+  for (const id of ctx.cache.keys()) {
+    let slots;
+    try {
+      slots = await ctx.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;
+}
+async function resolveDictLabelMaps(ctx) {
+  const maps = /* @__PURE__ */ new Map();
+  if (!ctx.dictKeyFields || !ctx.textIndexes) return maps;
+  for (const field of ctx.textIndexes) {
+    const desc = ctx.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 (ctx.getDictionary) {
+        const handle = await ctx.getDictionary(desc.name);
+        for (const e of await handle.list()) m.set(e.key, e.labels);
+      }
+    }
+    maps.set(field, m);
+  }
+  return maps;
+}
+async function flushIndex(ctx) {
+  if (!ctx.searchIndexStore) return;
+  await ctx.ensureHydrated();
+  const labelMaps = await resolveDictLabelMaps(ctx);
+  const blobFilenames = await resolveBlobFilenames(ctx);
+  await ctx.searchIndexStore.ensureBuilt(() => buildRetrievalDocs(ctx, labelMaps, blobFilenames));
+  await ctx.searchIndexStore.flush?.();
+}
+function buildVectorLoad(ctx) {
+  return async () => {
+    const ids = await ctx.adapter.list(ctx.vault, "_vec");
+    const out = [];
+    for (const vecId of ids) {
+      if (!isVecIdFor(ctx.name, vecId)) continue;
+      const id = decodeVecId(ctx.name, vecId);
+      if (await liveRecordIsElevated(ctx.adapter, ctx.vault, ctx.name, id)) continue;
+      const env = await ctx.adapter.get(ctx.vault, "_vec", vecId);
+      if (!env) continue;
+      let body;
+      try {
+        body = await ctx.codec.decryptJsonString(env);
+      } catch {
+        continue;
+      }
+      if (body === null) continue;
+      const parsed = JSON.parse(body);
+      out.push({ id, vec: new Float32Array(parsed.vec), model: parsed.model });
+    }
+    return out;
+  };
+}
+function buildPersistedIndexCallbacks(provideCtx) {
+  const FT = "_ftindex";
+  return {
+    load: async () => {
+      const ctx = provideCtx();
+      const env = await ctx.adapter.get(ctx.vault, FT, ctx.name);
+      if (!env) return null;
+      const body = await ctx.codec.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, isStale) => {
+      const ctx = provideCtx();
+      const body = JSON.stringify({ fp, idx: json });
+      const env = await ctx.codec.encryptJsonString(body, fp.count);
+      if (isStale()) return;
+      await ctx.adapter.put(ctx.vault, FT, ctx.name, env);
+    },
+    remove: async () => {
+      const ctx = provideCtx();
+      await ctx.adapter.delete(ctx.vault, FT, ctx.name);
+    },
+    currentFingerprint: () => {
+      const ctx = provideCtx();
+      let maxVersion = 0;
+      for (const e of ctx.cache.values()) if (e.version > maxVersion) maxVersion = e.version;
+      return { count: ctx.cache.size, maxVersion };
+    }
+  };
+}
+async function warmIndex(ctx) {
+  if (!ctx.searchIndexStore) return;
+  if (ctx.lazy) {
+    throw new Error(
+      `Collection "${ctx.name}": warmIndex() requires eager mode (prefetch: true).`
+    );
+  }
+  await ctx.ensureHydrated();
+  const built = ctx.searchIndexStore.built;
+  const labelMaps = built ? /* @__PURE__ */ new Map() : await resolveDictLabelMaps(ctx);
+  const blobFilenames = built ? /* @__PURE__ */ new Map() : await resolveBlobFilenames(ctx);
+  await ctx.searchIndexStore.ensureBuilt(() => buildRetrievalDocs(ctx, labelMaps, blobFilenames));
+}
+async function retrieve(ctx, query, opts = {}) {
+  const hits = opts.mode === "semantic" ? await retrieveSemantic(ctx, query, opts) : opts.mode === "hybrid" ? await retrieveHybrid(ctx, query, opts) : await retrieveLexical(ctx, query, opts);
+  return opts.within ? applyWithin(hits, opts.within) : hits;
+}
+function applyWithin(hits, within) {
+  const ids = new Set(within._idArray());
+  return hits.filter((h) => ids.has(h.id)).map((h, i) => ({ ...h, rank: i + 1 }));
+}
+async function retrieveLexical(ctx, query, opts) {
+  if (!ctx.searchIndexStore) {
+    throw new Error(`Collection "${ctx.name}": retrieve() requires a textIndexes config.`);
+  }
+  if (ctx.lazy) {
+    throw new Error(
+      `Collection "${ctx.name}": retrieve() requires eager mode (prefetch: true).`
+    );
+  }
+  await ctx.ensureHydrated();
+  const built = ctx.searchIndexStore.built;
+  const labelMaps = built ? /* @__PURE__ */ new Map() : await resolveDictLabelMaps(ctx);
+  const blobFilenames = built ? /* @__PURE__ */ new Map() : await resolveBlobFilenames(ctx);
+  const index = await ctx.searchIndexStore.ensureBuilt(() => buildRetrievalDocs(ctx, 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 = ctx.cache.get(h.id);
+        return e ? { record: stripI18nFilled(e.record) } : {};
+      })() : {}
+    };
+    return base;
+  });
+}
+async function retrieveHybrid(ctx, query, opts) {
+  if (!ctx.embeddings) {
+    throw new Error(`Collection "${ctx.name}": retrieve({mode:'hybrid'}) requires an embeddings config.`);
+  }
+  const [lex, sem] = await Promise.all([
+    retrieveLexical(ctx, query, opts),
+    retrieveSemantic(ctx, query, opts)
+  ]);
+  return fuseRetrieval([lex, sem], opts.limit !== void 0 ? { limit: opts.limit } : {});
+}
+async function retrieveSemantic(ctx, query, opts) {
+  if (!ctx.embeddings) throw new Error(`Collection "${ctx.name}": retrieve({mode:'semantic'}) requires an embeddings config.`);
+  if (ctx.lazy) throw new Error(`Collection "${ctx.name}": retrieve() requires eager mode (prefetch: true).`);
+  const qVec = await ctx.embeddings.encode(query);
+  return similarTo(ctx, qVec, {
+    ...opts.limit !== void 0 ? { k: opts.limit } : {},
+    ...opts.minScore !== void 0 ? { minScore: opts.minScore } : {},
+    ...opts.includeRecord ? { includeRecord: true } : {}
+  });
+}
+async function similarTo(ctx, vector, opts = {}) {
+  if (!ctx.embeddings || !ctx.vectorSet) throw new Error(`Collection "${ctx.name}": similarTo() requires an embeddings config.`);
+  if (ctx.lazy) throw new Error(`Collection "${ctx.name}": similarTo() requires eager mode (prefetch: true).`);
+  await ctx.ensureHydrated();
+  await ctx.vectorSet.ensureLoaded(buildVectorLoad(ctx));
+  const hits = ctx.vectorSet.cosineTopK(vector, opts.k ?? 10, {
+    ...opts.minScore !== void 0 ? { minScore: opts.minScore } : {},
+    expectModel: ctx.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 = ctx.cache.get(h.id);
+      if (e) base.record = stripI18nFilled(e.record);
+    }
+    return base;
+  });
+}
+async function embedOnWrite(ctx, id, record, version) {
+  if (!ctx.embeddings) return;
+  const text = embeddingSourceText(record, ctx.embeddings.source);
+  const vec = await ctx.embeddings.encode(text);
+  if (vec.length !== ctx.embeddings.dim) throw new EmbeddingDimMismatchError("embeddings", ctx.embeddings.dim, vec.length);
+  const body = JSON.stringify({ vec: Array.from(vec), model: ctx.embeddings.model, dim: ctx.embeddings.dim });
+  const vecEnv = await ctx.codec.encryptJsonString(body, version);
+  await ctx.adapter.put(ctx.vault, "_vec", encodeVecId(ctx.name, id), vecEnv);
+  ctx.vectorSet?.markDirty();
+}
+async function rebuildEmbeddings(ctx) {
+  if (!ctx.embeddings) return { rebuilt: 0, skipped: 0 };
+  const ids = await ctx.adapter.list(ctx.vault, ctx.name);
+  let rebuilt = 0;
+  let skipped = 0;
+  for (const id of ids) {
+    if (await liveRecordIsElevated(ctx.adapter, ctx.vault, ctx.name, id)) {
+      skipped++;
+      continue;
+    }
+    const env = await ctx.adapter.get(ctx.vault, ctx.name, id);
+    if (!env) {
+      skipped++;
+      continue;
+    }
+    const decoded = await ctx.codec.decryptRecord(env, { id });
+    if (decoded === null) {
+      skipped++;
+      continue;
+    }
+    await embedOnWrite(ctx, id, decoded, env._v ?? 1);
+    rebuilt++;
+  }
+  return { rebuilt, skipped };
+}
+async function syncTierSearch(ctx, id, record, version) {
+  if (!ctx.searchIndexStore && !ctx.vectorSet) return;
+  if (record === null) {
+    await ctx.adapter.delete(ctx.vault, "_vec", encodeVecId(ctx.name, id));
+    ctx.vectorSet?.markDirty();
+  } else {
+    await embedOnWrite(ctx, id, record, version ?? 1);
+  }
+  const store = ctx.searchIndexStore;
+  if (store && "removePersisted" in store) await store.removePersisted();
+  else store?.markDirty();
+}
+
+export {
+  VectorSet,
+  encodeVecId,
+  tokenize,
+  InvertedIndex,
+  MemoryIndexStore,
+  withSearch,
+  NO_SEARCH,
+  search,
+  buildRetrievalDocs,
+  hasIndexedBlobFields,
+  flushIndex,
+  buildPersistedIndexCallbacks,
+  warmIndex,
+  retrieve,
+  similarTo,
+  embedOnWrite,
+  rebuildEmbeddings,
+  syncTierSearch
+};
+//# sourceMappingURL=chunk-OSDB5WW3.js.map