@quaesitor-textus/mongo 0.2.0

package/dist/chunk-RXTFVXXU.js

@@ -0,0 +1,42 @@
+import {
+  createLiveSearch,
+  formatSse,
+  sseComment
+} from "./chunk-AUIK33V2.js";
+
+// src/adapters/shared.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive"
+};
+function runLiveSearch(opts, write) {
+  const sendEvent = (e) => write(formatSse(e));
+  const live = createLiveSearch({
+    sync: opts.sync,
+    collection: opts.collection,
+    config: opts.config,
+    filter: opts.filter,
+    sort: opts.sort,
+    cap: opts.cap,
+    sendEvent
+  });
+  const hb = setInterval(() => write(sseComment()), opts.heartbeatMs ?? 25e3);
+  return {
+    stop: () => {
+      clearInterval(hb);
+      live.stop();
+    }
+  };
+}
+function streamToNodeResponse(req, res, opts) {
+  res.writeHead(200, SSE_HEADERS);
+  const { stop } = runLiveSearch(opts, (chunk) => res.write(chunk));
+  req.on("close", stop);
+}
+
+export {
+  SSE_HEADERS,
+  runLiveSearch,
+  streamToNodeResponse
+};

package/dist/index.cjs

@@ -0,0 +1,288 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_NAMESPACE: () => DEFAULT_NAMESPACE,
+  DEFAULT_NGRAM_SIZES: () => DEFAULT_NGRAM_SIZES,
+  SEARCH_FIELDS_VERSION: () => SEARCH_FIELDS_VERSION,
+  buildTextSearchFilter: () => buildTextSearchFilter,
+  computeSearchFields: () => computeSearchFields,
+  createLiveSearch: () => createLiveSearch,
+  createSearchIndexes: () => createSearchIndexes,
+  escapeRegex: () => escapeRegex,
+  formatSse: () => formatSse,
+  modeKey: () => modeKey,
+  searchFieldsVersion: () => searchFieldsVersion,
+  searchIndexSpecs: () => searchIndexSpecs,
+  sseComment: () => sseComment,
+  startSearchSync: () => startSearchSync,
+  targetModes: () => targetModes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var DEFAULT_NAMESPACE = "_qt";
+var DEFAULT_NGRAM_SIZES = [2, 3];
+
+// src/modes.ts
+function modeKey(o = {}) {
+  let k = "norm";
+  if (o.caseSensitive) k += "_cs";
+  if (o.diacriticSensitive) k += "_ds";
+  return k;
+}
+function targetModes(t) {
+  const modes = [t.options ?? {}, ...t.queryModes ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const m of modes) {
+    const k = modeKey(m);
+    if (!seen.has(k)) {
+      seen.add(k);
+      out.push(m);
+    }
+  }
+  return out;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/computeSearchFields.ts
+var import_core = require("@quaesitor-textus/core");
+
+// src/version.ts
+var SEARCH_FIELDS_VERSION = 2;
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null";
+  if (Array.isArray(v)) return "[" + v.map(stableStringify).join(",") + "]";
+  const obj = v;
+  return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+function cyrb53(str) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+function searchFieldsVersion(config) {
+  const sig = stableStringify({
+    ns: config.namespace ?? DEFAULT_NAMESPACE,
+    sizes: config.ngramSizes ?? DEFAULT_NGRAM_SIZES,
+    targets: config.targets
+  });
+  return `${SEARCH_FIELDS_VERSION}:${cyrb53(sig)}`;
+}
+
+// src/computeSearchFields.ts
+function computeSearchFields(doc, config) {
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  const sizes = config.ngramSizes ?? DEFAULT_NGRAM_SIZES;
+  const targets = {};
+  for (const [name, target] of Object.entries(config.targets)) {
+    const corpus = (0, import_core.buildCorpus)(doc, target.fields);
+    const entry = {
+      // n-grams are built on the fully-folded corpus (the coarsest fold) so the
+      // index is a superset filter valid for every query mode.
+      ngrams: (0, import_core.toNgrams)((0, import_core.normalizeText)(corpus, {}), sizes)
+    };
+    for (const mode of targetModes(target)) {
+      entry[modeKey(mode)] = (0, import_core.normalizeText)(corpus, mode);
+    }
+    targets[name] = entry;
+  }
+  targets._v = searchFieldsVersion(config);
+  return { [ns]: targets };
+}
+
+// src/searchIndexes.ts
+function searchIndexSpecs(config) {
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  return Object.keys(config.targets).map((name) => ({
+    key: { [`${ns}.${name}.ngrams`]: 1 },
+    name: `${ns}_${name}_ngrams`
+  }));
+}
+async function createSearchIndexes(collection, config) {
+  for (const spec of searchIndexSpecs(config)) {
+    await collection.createIndex(spec.key, { name: spec.name });
+  }
+}
+
+// src/buildTextSearchFilter.ts
+var import_core2 = require("@quaesitor-textus/core");
+function buildTextSearchFilter(target, patterns, config, options) {
+  if (patterns.length === 0) return {};
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  const sizes = config.ngramSizes ?? DEFAULT_NGRAM_SIZES;
+  const t = config.targets[target];
+  if (!t) throw new Error(`Unknown search target: ${target}`);
+  const mode = options ?? t.options ?? {};
+  const ngramField = `${ns}.${target}.ngrams`;
+  const verifyField = `${ns}.${target}.${modeKey(mode)}`;
+  const ngramTerms = [
+    ...new Set(patterns.flatMap((p) => (0, import_core2.toNgrams)((0, import_core2.normalizeText)(p, {}), sizes)))
+  ];
+  const verifyConditions = patterns.map((p) => ({
+    [verifyField]: { $regex: escapeRegex((0, import_core2.normalizeText)(p, mode)) }
+  }));
+  return { $and: [{ [ngramField]: { $all: ngramTerms } }, ...verifyConditions] };
+}
+
+// src/startSearchSync.ts
+function startSearchSync(collection, config, options = {}) {
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  const { idleMs = 750, backfill = false } = options;
+  const stream = collection.watch([], { fullDocument: "updateLookup" });
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = (e) => {
+    for (const l of listeners) l(e);
+  };
+  let active = false;
+  let count = 0;
+  let startedAt = 0;
+  let idleTimer;
+  stream.on("change", (change) => {
+    if (!["insert", "update", "replace"].includes(change.operationType)) return;
+    const doc = change.fullDocument;
+    if (!doc) return;
+    const derived = computeSearchFields(doc, config);
+    if (JSON.stringify(doc[ns]) === JSON.stringify(derived[ns])) return;
+    if (!active) {
+      active = true;
+      count = 0;
+      startedAt = Date.now();
+      emit({ type: "indexing-started" });
+    }
+    count += 1;
+    void collection.updateOne({ _id: doc._id }, { $set: { [ns]: derived[ns] } }).then(() => emit({ type: "indexed", id: doc._id })).catch(() => {
+    });
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      active = false;
+      emit({ type: "indexing-finished", count, durationMs: Date.now() - startedAt });
+    }, idleMs);
+  });
+  if (backfill) void runBackfill();
+  async function runBackfill() {
+    const startedAt2 = Date.now();
+    let n = 0;
+    emit({ type: "indexing-started" });
+    const version = searchFieldsVersion(config);
+    const cursor = collection.find({
+      $or: [{ [ns]: { $exists: false } }, { [`${ns}._v`]: { $ne: version } }]
+    });
+    for await (const doc of cursor) {
+      const derived = computeSearchFields(doc, config);
+      await collection.updateOne({ _id: doc._id }, { $set: { [ns]: derived[ns] } }).catch(() => {
+      });
+      n += 1;
+    }
+    emit({ type: "indexing-finished", count: n, durationMs: Date.now() - startedAt2 });
+  }
+  return {
+    on: (l) => {
+      listeners.add(l);
+    },
+    off: (l) => {
+      listeners.delete(l);
+    },
+    stop: async () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      listeners.clear();
+      await stream.close();
+    }
+  };
+}
+
+// src/createLiveSearch.ts
+function createLiveSearch(opts) {
+  const { sync, collection, config: _config, filter, sort, cap = 500, sendEvent } = opts;
+  const seen = /* @__PURE__ */ new Set();
+  let count = 0;
+  let capped = false;
+  const idOf = (doc) => String(doc._id);
+  const cursor = collection.find(filter);
+  if (sort) cursor.sort({ [sort.field]: sort.dir });
+  void cursor.limit(cap).toArray().then((items) => {
+    for (const it of items) seen.add(idOf(it));
+    count = items.length;
+    sendEvent({ type: "snapshot", items });
+    if (count >= cap) {
+      capped = true;
+      sendEvent({ type: "capped" });
+    }
+  }).catch(() => sendEvent({ type: "snapshot", items: [] }));
+  const listener = (e) => {
+    if (e.type !== "indexed" || capped) return;
+    void collection.findOne({ $and: [{ _id: e.id }, filter] }).then((doc) => {
+      if (!doc || capped) return;
+      const id = idOf(doc);
+      if (seen.has(id)) return;
+      seen.add(id);
+      count += 1;
+      sendEvent({ type: "match", item: doc });
+      if (count >= cap) {
+        capped = true;
+        sendEvent({ type: "capped" });
+      }
+    }).catch(() => {
+    });
+  };
+  sync.on(listener);
+  return { stop: () => sync.off(listener) };
+}
+
+// src/sse.ts
+function formatSse(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+function sseComment(text = "ping") {
+  return `: ${text}
+
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_NAMESPACE,
+  DEFAULT_NGRAM_SIZES,
+  SEARCH_FIELDS_VERSION,
+  buildTextSearchFilter,
+  computeSearchFields,
+  createLiveSearch,
+  createSearchIndexes,
+  escapeRegex,
+  formatSse,
+  modeKey,
+  searchFieldsVersion,
+  searchIndexSpecs,
+  sseComment,
+  startSearchSync,
+  targetModes
+});

package/dist/index.d.cts

@@ -0,0 +1,51 @@
+import { M as MongoSearchTarget, a as MongoSearchConfig, S as SearchSync } from './startSearchSync-Bk7Na8Do.cjs';
+export { D as DEFAULT_NAMESPACE, b as DEFAULT_NGRAM_SIZES, c as SearchSyncEvent, d as SearchSyncListener, e as StartSearchSyncOptions, s as startSearchSync } from './startSearchSync-Bk7Na8Do.cjs';
+import { SearchOptions } from '@quaesitor-textus/core';
+import { Collection, Filter, Document } from 'mongodb';
+
+declare function modeKey(o?: SearchOptions): string;
+declare function targetModes(t: MongoSearchTarget): SearchOptions[];
+declare function escapeRegex(s: string): string;
+
+declare function computeSearchFields(doc: unknown, config: MongoSearchConfig): Record<string, unknown>;
+
+declare const SEARCH_FIELDS_VERSION = 2;
+declare function searchFieldsVersion(config: MongoSearchConfig): string;
+
+declare function searchIndexSpecs(config: MongoSearchConfig): Array<{
+    key: Record<string, 1>;
+    name: string;
+}>;
+declare function createSearchIndexes(collection: Collection, config: MongoSearchConfig): Promise<void>;
+
+declare function buildTextSearchFilter(target: string, patterns: string[], config: MongoSearchConfig, options?: SearchOptions): Filter<Document>;
+
+type LiveEvent = {
+    type: 'snapshot';
+    items: Document[];
+} | {
+    type: 'match';
+    item: Document;
+} | {
+    type: 'capped';
+};
+interface CreateLiveSearchOptions {
+    sync: SearchSync;
+    collection: Collection;
+    config: MongoSearchConfig;
+    filter: Filter<Document>;
+    sort?: {
+        field: string;
+        dir: 1 | -1;
+    };
+    cap?: number;
+    sendEvent: (event: LiveEvent) => void;
+}
+declare function createLiveSearch(opts: CreateLiveSearchOptions): {
+    stop: () => void;
+};
+
+declare function formatSse(event: unknown): string;
+declare function sseComment(text?: string): string;
+
+export { type CreateLiveSearchOptions, type LiveEvent, MongoSearchConfig, MongoSearchTarget, SEARCH_FIELDS_VERSION, SearchSync, buildTextSearchFilter, computeSearchFields, createLiveSearch, createSearchIndexes, escapeRegex, formatSse, modeKey, searchFieldsVersion, searchIndexSpecs, sseComment, targetModes };

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { M as MongoSearchTarget, a as MongoSearchConfig, S as SearchSync } from './startSearchSync-Bk7Na8Do.js';
+export { D as DEFAULT_NAMESPACE, b as DEFAULT_NGRAM_SIZES, c as SearchSyncEvent, d as SearchSyncListener, e as StartSearchSyncOptions, s as startSearchSync } from './startSearchSync-Bk7Na8Do.js';
+import { SearchOptions } from '@quaesitor-textus/core';
+import { Collection, Filter, Document } from 'mongodb';
+
+declare function modeKey(o?: SearchOptions): string;
+declare function targetModes(t: MongoSearchTarget): SearchOptions[];
+declare function escapeRegex(s: string): string;
+
+declare function computeSearchFields(doc: unknown, config: MongoSearchConfig): Record<string, unknown>;
+
+declare const SEARCH_FIELDS_VERSION = 2;
+declare function searchFieldsVersion(config: MongoSearchConfig): string;
+
+declare function searchIndexSpecs(config: MongoSearchConfig): Array<{
+    key: Record<string, 1>;
+    name: string;
+}>;
+declare function createSearchIndexes(collection: Collection, config: MongoSearchConfig): Promise<void>;
+
+declare function buildTextSearchFilter(target: string, patterns: string[], config: MongoSearchConfig, options?: SearchOptions): Filter<Document>;
+
+type LiveEvent = {
+    type: 'snapshot';
+    items: Document[];
+} | {
+    type: 'match';
+    item: Document;
+} | {
+    type: 'capped';
+};
+interface CreateLiveSearchOptions {
+    sync: SearchSync;
+    collection: Collection;
+    config: MongoSearchConfig;
+    filter: Filter<Document>;
+    sort?: {
+        field: string;
+        dir: 1 | -1;
+    };
+    cap?: number;
+    sendEvent: (event: LiveEvent) => void;
+}
+declare function createLiveSearch(opts: CreateLiveSearchOptions): {
+    stop: () => void;
+};
+
+declare function formatSse(event: unknown): string;
+declare function sseComment(text?: string): string;
+
+export { type CreateLiveSearchOptions, type LiveEvent, MongoSearchConfig, MongoSearchTarget, SEARCH_FIELDS_VERSION, SearchSync, buildTextSearchFilter, computeSearchFields, createLiveSearch, createSearchIndexes, escapeRegex, formatSse, modeKey, searchFieldsVersion, searchIndexSpecs, sseComment, targetModes };

package/dist/index.js

@@ -0,0 +1,203 @@
+import {
+  createLiveSearch,
+  formatSse,
+  sseComment
+} from "./chunk-AUIK33V2.js";
+
+// src/config.ts
+var DEFAULT_NAMESPACE = "_qt";
+var DEFAULT_NGRAM_SIZES = [2, 3];
+
+// src/modes.ts
+function modeKey(o = {}) {
+  let k = "norm";
+  if (o.caseSensitive) k += "_cs";
+  if (o.diacriticSensitive) k += "_ds";
+  return k;
+}
+function targetModes(t) {
+  const modes = [t.options ?? {}, ...t.queryModes ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const m of modes) {
+    const k = modeKey(m);
+    if (!seen.has(k)) {
+      seen.add(k);
+      out.push(m);
+    }
+  }
+  return out;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/computeSearchFields.ts
+import { buildCorpus, normalizeText, toNgrams } from "@quaesitor-textus/core";
+
+// src/version.ts
+var SEARCH_FIELDS_VERSION = 2;
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null";
+  if (Array.isArray(v)) return "[" + v.map(stableStringify).join(",") + "]";
+  const obj = v;
+  return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+function cyrb53(str) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+function searchFieldsVersion(config) {
+  const sig = stableStringify({
+    ns: config.namespace ?? DEFAULT_NAMESPACE,
+    sizes: config.ngramSizes ?? DEFAULT_NGRAM_SIZES,
+    targets: config.targets
+  });
+  return `${SEARCH_FIELDS_VERSION}:${cyrb53(sig)}`;
+}
+
+// src/computeSearchFields.ts
+function computeSearchFields(doc, config) {
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  const sizes = config.ngramSizes ?? DEFAULT_NGRAM_SIZES;
+  const targets = {};
+  for (const [name, target] of Object.entries(config.targets)) {
+    const corpus = buildCorpus(doc, target.fields);
+    const entry = {
+      // n-grams are built on the fully-folded corpus (the coarsest fold) so the
+      // index is a superset filter valid for every query mode.
+      ngrams: toNgrams(normalizeText(corpus, {}), sizes)
+    };
+    for (const mode of targetModes(target)) {
+      entry[modeKey(mode)] = normalizeText(corpus, mode);
+    }
+    targets[name] = entry;
+  }
+  targets._v = searchFieldsVersion(config);
+  return { [ns]: targets };
+}
+
+// src/searchIndexes.ts
+function searchIndexSpecs(config) {
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  return Object.keys(config.targets).map((name) => ({
+    key: { [`${ns}.${name}.ngrams`]: 1 },
+    name: `${ns}_${name}_ngrams`
+  }));
+}
+async function createSearchIndexes(collection, config) {
+  for (const spec of searchIndexSpecs(config)) {
+    await collection.createIndex(spec.key, { name: spec.name });
+  }
+}
+
+// src/buildTextSearchFilter.ts
+import { normalizeText as normalizeText2, toNgrams as toNgrams2 } from "@quaesitor-textus/core";
+function buildTextSearchFilter(target, patterns, config, options) {
+  if (patterns.length === 0) return {};
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  const sizes = config.ngramSizes ?? DEFAULT_NGRAM_SIZES;
+  const t = config.targets[target];
+  if (!t) throw new Error(`Unknown search target: ${target}`);
+  const mode = options ?? t.options ?? {};
+  const ngramField = `${ns}.${target}.ngrams`;
+  const verifyField = `${ns}.${target}.${modeKey(mode)}`;
+  const ngramTerms = [
+    ...new Set(patterns.flatMap((p) => toNgrams2(normalizeText2(p, {}), sizes)))
+  ];
+  const verifyConditions = patterns.map((p) => ({
+    [verifyField]: { $regex: escapeRegex(normalizeText2(p, mode)) }
+  }));
+  return { $and: [{ [ngramField]: { $all: ngramTerms } }, ...verifyConditions] };
+}
+
+// src/startSearchSync.ts
+function startSearchSync(collection, config, options = {}) {
+  const ns = config.namespace ?? DEFAULT_NAMESPACE;
+  const { idleMs = 750, backfill = false } = options;
+  const stream = collection.watch([], { fullDocument: "updateLookup" });
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = (e) => {
+    for (const l of listeners) l(e);
+  };
+  let active = false;
+  let count = 0;
+  let startedAt = 0;
+  let idleTimer;
+  stream.on("change", (change) => {
+    if (!["insert", "update", "replace"].includes(change.operationType)) return;
+    const doc = change.fullDocument;
+    if (!doc) return;
+    const derived = computeSearchFields(doc, config);
+    if (JSON.stringify(doc[ns]) === JSON.stringify(derived[ns])) return;
+    if (!active) {
+      active = true;
+      count = 0;
+      startedAt = Date.now();
+      emit({ type: "indexing-started" });
+    }
+    count += 1;
+    void collection.updateOne({ _id: doc._id }, { $set: { [ns]: derived[ns] } }).then(() => emit({ type: "indexed", id: doc._id })).catch(() => {
+    });
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      active = false;
+      emit({ type: "indexing-finished", count, durationMs: Date.now() - startedAt });
+    }, idleMs);
+  });
+  if (backfill) void runBackfill();
+  async function runBackfill() {
+    const startedAt2 = Date.now();
+    let n = 0;
+    emit({ type: "indexing-started" });
+    const version = searchFieldsVersion(config);
+    const cursor = collection.find({
+      $or: [{ [ns]: { $exists: false } }, { [`${ns}._v`]: { $ne: version } }]
+    });
+    for await (const doc of cursor) {
+      const derived = computeSearchFields(doc, config);
+      await collection.updateOne({ _id: doc._id }, { $set: { [ns]: derived[ns] } }).catch(() => {
+      });
+      n += 1;
+    }
+    emit({ type: "indexing-finished", count: n, durationMs: Date.now() - startedAt2 });
+  }
+  return {
+    on: (l) => {
+      listeners.add(l);
+    },
+    off: (l) => {
+      listeners.delete(l);
+    },
+    stop: async () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      listeners.clear();
+      await stream.close();
+    }
+  };
+}
+export {
+  DEFAULT_NAMESPACE,
+  DEFAULT_NGRAM_SIZES,
+  SEARCH_FIELDS_VERSION,
+  buildTextSearchFilter,
+  computeSearchFields,
+  createLiveSearch,
+  createSearchIndexes,
+  escapeRegex,
+  formatSse,
+  modeKey,
+  searchFieldsVersion,
+  searchIndexSpecs,
+  sseComment,
+  startSearchSync,
+  targetModes
+};

package/dist/startSearchSync-Bk7Na8Do.d.cts

@@ -0,0 +1,39 @@
+import { Collection } from 'mongodb';
+import { SearchOptions } from '@quaesitor-textus/core';
+
+interface MongoSearchTarget {
+    fields: string[];
+    options?: SearchOptions;
+    queryModes?: SearchOptions[];
+}
+interface MongoSearchConfig {
+    namespace?: string;
+    ngramSizes?: number[];
+    targets: Record<string, MongoSearchTarget>;
+}
+declare const DEFAULT_NAMESPACE = "_qt";
+declare const DEFAULT_NGRAM_SIZES: number[];
+
+type SearchSyncEvent = {
+    type: 'indexing-started';
+} | {
+    type: 'indexing-finished';
+    count: number;
+    durationMs: number;
+} | {
+    type: 'indexed';
+    id: unknown;
+};
+type SearchSyncListener = (event: SearchSyncEvent) => void;
+interface SearchSync {
+    on(listener: SearchSyncListener): void;
+    off(listener: SearchSyncListener): void;
+    stop(): Promise<void>;
+}
+interface StartSearchSyncOptions {
+    idleMs?: number;
+    backfill?: boolean;
+}
+declare function startSearchSync(collection: Collection, config: MongoSearchConfig, options?: StartSearchSyncOptions): SearchSync;
+
+export { DEFAULT_NAMESPACE as D, type MongoSearchTarget as M, type SearchSync as S, type MongoSearchConfig as a, DEFAULT_NGRAM_SIZES as b, type SearchSyncEvent as c, type SearchSyncListener as d, type StartSearchSyncOptions as e, startSearchSync as s };