@blinkk/root-cms 3.0.1-alpha.0 → 3.0.1-beta.2

package/dist/chunk-TRM4MQHU.js

@@ -0,0 +1,1180 @@
+import {
+  RootCMSClient,
+  getCmsPlugin
+} from "./chunk-F4SODS5S.js";
+
+// core/cron.ts
+import { Timestamp as Timestamp3 } from "firebase-admin/firestore";
+
+// core/search-index.ts
+import fs from "fs";
+import path from "path";
+import { Timestamp } from "firebase-admin/firestore";
+import MiniSearch from "minisearch";
+import glob from "tiny-glob";
+
+// core/search-extract.ts
+var MAX_FIELD_TEXT_CHARS = 2e3;
+function stripHtml(input) {
+  if (!input) {
+    return "";
+  }
+  const dropped = input.replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, " ");
+  const noTags = dropped.replace(/<[^>]+>/g, " ");
+  const decoded = noTags.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number(code))).replace(
+    /&#x([0-9a-f]+);/gi,
+    (_, code) => String.fromCharCode(parseInt(code, 16))
+  );
+  return decoded.replace(/\s+/g, " ").trim();
+}
+function extractListItems(items) {
+  if (!items?.length) {
+    return "";
+  }
+  const parts = [];
+  for (const item of items) {
+    if (item?.content) {
+      parts.push(stripHtml(item.content));
+    }
+    if (item?.items?.length) {
+      parts.push(extractListItems(item.items));
+    }
+  }
+  return parts.filter(Boolean).join(" ");
+}
+function extractRichText(data) {
+  if (!data || typeof data !== "object") {
+    return "";
+  }
+  const blocks = data.blocks;
+  if (!Array.isArray(blocks)) {
+    return "";
+  }
+  const parts = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") {
+      continue;
+    }
+    const type = block.type;
+    const d = block.data || {};
+    switch (type) {
+      case "paragraph":
+      case "heading":
+      case "quote":
+        if (typeof d.text === "string" && d.text) {
+          parts.push(stripHtml(d.text));
+        }
+        break;
+      case "orderedList":
+      case "unorderedList":
+        parts.push(extractListItems(d.items));
+        break;
+      case "table": {
+        const rows = Array.isArray(d.rows) ? d.rows : [];
+        for (const row of rows) {
+          const cells = Array.isArray(row?.cells) ? row.cells : [];
+          for (const cell of cells) {
+            parts.push(extractRichText({ blocks: cell?.blocks || [] }));
+          }
+        }
+        break;
+      }
+      case "html":
+        if (typeof d.html === "string" && d.html) {
+          parts.push(stripHtml(d.html));
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  return parts.filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+}
+function truncate(text) {
+  if (text.length <= MAX_FIELD_TEXT_CHARS) {
+    return text;
+  }
+  return text.slice(0, MAX_FIELD_TEXT_CHARS);
+}
+function fieldLabelOrId(field) {
+  if (field.label) {
+    return field.label;
+  }
+  if (field.id) {
+    return field.id;
+  }
+  return field.type;
+}
+function walkSchemaFields(fields, data, parentDeepKey, ctx, emit) {
+  if (!Array.isArray(fields) || !data || typeof data !== "object") {
+    return;
+  }
+  for (const field of fields) {
+    if (!field?.id) {
+      continue;
+    }
+    const deepKey = `${parentDeepKey}.${field.id}`;
+    const value = data[field.id];
+    walkField(field, value, deepKey, ctx, emit);
+  }
+}
+function walkField(field, value, deepKey, ctx, emit) {
+  const fieldLabel = fieldLabelOrId(field);
+  switch (field.type) {
+    case "string": {
+      if (typeof value === "string" && value.trim()) {
+        emitText(deepKey, fieldLabel, field.type, value, ctx, emit);
+      }
+      break;
+    }
+    case "select": {
+      if (typeof value === "string" && value.trim()) {
+        emitText(deepKey, fieldLabel, field.type, value, ctx, emit);
+      }
+      break;
+    }
+    case "multiselect": {
+      if (Array.isArray(value)) {
+        const text = value.filter((v) => typeof v === "string").join(" ");
+        if (text.trim()) {
+          emitText(deepKey, fieldLabel, field.type, text, ctx, emit);
+        }
+      }
+      break;
+    }
+    case "richtext": {
+      const text = extractRichText(value);
+      if (text) {
+        emitText(deepKey, fieldLabel, field.type, text, ctx, emit);
+      }
+      break;
+    }
+    case "object": {
+      const objectField = field;
+      if (value && typeof value === "object") {
+        walkSchemaFields(objectField.fields, value, deepKey, ctx, emit);
+      }
+      break;
+    }
+    case "array": {
+      const arrayField = field;
+      walkArray(arrayField, value, deepKey, ctx, emit);
+      break;
+    }
+    case "oneof": {
+      const oneOfField = field;
+      walkOneOf(oneOfField, value, deepKey, ctx, emit);
+      break;
+    }
+    // Non-text or non-searchable: number, date, datetime, boolean, image,
+    // file, reference, references — intentionally skipped.
+    default:
+      break;
+  }
+}
+function walkArray(field, value, deepKey, ctx, emit) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  const order = Array.isArray(value._array) ? value._array : [];
+  if (order.length === 0) {
+    return;
+  }
+  const itemField = field.of;
+  for (const autokey of order) {
+    if (typeof autokey !== "string" || !autokey) {
+      continue;
+    }
+    const itemValue = value[autokey];
+    if (itemValue === void 0 || itemValue === null) {
+      continue;
+    }
+    const itemDeepKey = `${deepKey}.${autokey}`;
+    if (itemField?.type === "object") {
+      walkSchemaFields(
+        itemField.fields,
+        itemValue,
+        itemDeepKey,
+        ctx,
+        emit
+      );
+    } else if (itemField?.type === "oneof") {
+      walkOneOf(itemField, itemValue, itemDeepKey, ctx, emit);
+    } else {
+    }
+  }
+}
+function walkOneOf(field, value, deepKey, ctx, emit) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  const typeName = typeof value._type === "string" ? value._type : "";
+  if (!typeName) {
+    return;
+  }
+  const types = field.types;
+  let matchedSchema = null;
+  if (Array.isArray(types)) {
+    for (const candidate of types) {
+      if (candidate && typeof candidate === "object") {
+        const schema = candidate;
+        if (schema.name === typeName) {
+          matchedSchema = schema;
+          break;
+        }
+      }
+    }
+  }
+  if (!matchedSchema) {
+    return;
+  }
+  walkSchemaFields(matchedSchema.fields, value, deepKey, ctx, emit);
+}
+function emitText(deepKey, fieldLabel, fieldType, rawText, ctx, emit) {
+  const text = truncate(rawText.replace(/\s+/g, " ").trim());
+  if (!text) {
+    return;
+  }
+  emit({
+    id: `${ctx.docId}#${deepKey}`,
+    docId: ctx.docId,
+    collection: ctx.collection,
+    slug: ctx.slug,
+    deepKey,
+    fieldType,
+    fieldLabel,
+    text
+  });
+}
+function extractDocRecords(schema, options) {
+  const records = [];
+  const docId = `${options.collection}/${options.slug}`;
+  const ctx = {
+    docId,
+    collection: options.collection,
+    slug: options.slug
+  };
+  walkSchemaFields(
+    schema.fields,
+    options.fields || {},
+    "fields",
+    ctx,
+    (rec) => records.push(rec)
+  );
+  return records;
+}
+
+// core/search-query.ts
+var SMART_QUOTES = /[“”„«»]/g;
+function parseQuery(input) {
+  const out = {
+    phrases: [],
+    terms: [],
+    excluded: [],
+    excludedPhrases: []
+  };
+  if (!input) {
+    return out;
+  }
+  const s = input.replace(SMART_QUOTES, '"');
+  let i = 0;
+  while (i < s.length) {
+    while (i < s.length && isSpace(s[i])) {
+      i++;
+    }
+    if (i >= s.length) {
+      break;
+    }
+    let negative = false;
+    if (s[i] === "-" && i + 1 < s.length && !isSpace(s[i + 1])) {
+      negative = true;
+      i++;
+    }
+    if (s[i] === '"') {
+      i++;
+      const start = i;
+      while (i < s.length && s[i] !== '"') {
+        i++;
+      }
+      const phrase = s.slice(start, i).trim();
+      if (i < s.length) {
+        i++;
+      }
+      if (phrase) {
+        if (negative) {
+          out.excludedPhrases.push(phrase);
+        } else {
+          out.phrases.push(phrase);
+        }
+      }
+    } else {
+      const start = i;
+      while (i < s.length && !isSpace(s[i]) && s[i] !== '"') {
+        i++;
+      }
+      const term = s.slice(start, i);
+      if (term && term.replace(/^-+$/, "")) {
+        if (negative) {
+          out.excluded.push(term);
+        } else {
+          out.terms.push(term);
+        }
+      }
+    }
+  }
+  return out;
+}
+function isSpace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+}
+function tokenize(s) {
+  return s.toLowerCase().split(/[\s\p{P}]+/u).filter(Boolean);
+}
+function containsPhrase(text, phrase) {
+  const phraseTokens = tokenize(phrase);
+  if (phraseTokens.length === 0) {
+    return true;
+  }
+  const textTokens = tokenize(text);
+  if (textTokens.length < phraseTokens.length) {
+    return false;
+  }
+  outer: for (let i = 0; i <= textTokens.length - phraseTokens.length; i++) {
+    for (let j = 0; j < phraseTokens.length; j++) {
+      if (textTokens[i + j] !== phraseTokens[j]) {
+        continue outer;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function isEmptyQuery(parsed) {
+  return parsed.phrases.length === 0 && parsed.terms.length === 0;
+}
+function executeQuery(index, parsed) {
+  if (isEmptyQuery(parsed)) {
+    return [];
+  }
+  let acc = null;
+  for (const phrase of parsed.phrases) {
+    const candidates = index.search(phrase, {
+      combineWith: "AND",
+      fuzzy: false,
+      prefix: false
+    });
+    const matched = candidates.filter(
+      (r) => containsPhrase(String(r.text || ""), phrase) || containsPhrase(String(r.fieldLabel || ""), phrase)
+    );
+    acc = mergeAnd(acc, matched);
+    if (acc.size === 0) {
+      return [];
+    }
+  }
+  if (parsed.terms.length > 0) {
+    const q = parsed.terms.join(" ");
+    const results = index.search(q, { combineWith: "AND" });
+    acc = mergeAnd(acc, results);
+  }
+  if (!acc || acc.size === 0) {
+    return [];
+  }
+  for (const term of parsed.excluded) {
+    for (const r of index.search(term)) {
+      acc.delete(String(r.id));
+    }
+  }
+  for (const phrase of parsed.excludedPhrases) {
+    const candidates = index.search(phrase, {
+      combineWith: "AND",
+      fuzzy: false,
+      prefix: false
+    });
+    for (const r of candidates) {
+      if (containsPhrase(String(r.text || ""), phrase) || containsPhrase(String(r.fieldLabel || ""), phrase)) {
+        acc.delete(String(r.id));
+      }
+    }
+  }
+  return Array.from(acc.values()).sort((a, b) => b.score - a.score).map((entry) => ({
+    ...entry.record,
+    score: entry.score,
+    terms: Array.from(entry.terms)
+  }));
+}
+function mergeAnd(acc, results) {
+  if (acc === null) {
+    const next2 = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      next2.set(String(r.id), {
+        score: r.score,
+        record: r,
+        terms: new Set(Array.isArray(r.terms) ? r.terms : [])
+      });
+    }
+    return next2;
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    byId.set(String(r.id), r);
+  }
+  const next = /* @__PURE__ */ new Map();
+  for (const [id, entry] of acc) {
+    const r = byId.get(id);
+    if (!r) {
+      continue;
+    }
+    const terms = new Set(entry.terms);
+    if (Array.isArray(r.terms)) {
+      for (const t of r.terms) {
+        terms.add(t);
+      }
+    }
+    next.set(id, {
+      score: entry.score + r.score,
+      record: entry.record,
+      terms
+    });
+  }
+  return next;
+}
+
+// core/search-index.ts
+var SHARD_MAX_CHARS = 5e5;
+var MAX_INDEX_SIZE_BYTES = 50 * 1024 * 1024;
+var VACUUM_EVERY_N_RUNS = 25;
+var SEARCH_INDEX_SUBCOLLECTION = "SearchIndex";
+var META_DOC_ID = "_meta";
+var DOC_MAP_DOC_ID = "_docMap";
+var TITLEY_KEYS = /* @__PURE__ */ new Set(["title", "name", "slug", "headline", "label"]);
+var MINISEARCH_OPTIONS = {
+  fields: ["text", "fieldLabel"],
+  storeFields: [
+    "docId",
+    "collection",
+    "slug",
+    "deepKey",
+    "fieldLabel",
+    "fieldType",
+    "text",
+    "weight"
+  ],
+  searchOptions: {
+    boost: { fieldLabel: 2 },
+    prefix: true,
+    fuzzy: 0.2
+  }
+};
+function toSetOrNull(values) {
+  if (!values || values.length === 0) {
+    return null;
+  }
+  return new Set(values);
+}
+function resolveSearchIndexFilters(config) {
+  return {
+    includeCollections: toSetOrNull(config?.includeCollections),
+    excludeCollections: toSetOrNull(config?.excludeCollections),
+    includeDocIds: toSetOrNull(config?.includeDocIds),
+    excludeDocIds: toSetOrNull(config?.excludeDocIds)
+  };
+}
+function isCollectionIndexable(filters, collectionId) {
+  if (filters.includeCollections && !filters.includeCollections.has(collectionId)) {
+    return false;
+  }
+  if (filters.excludeCollections?.has(collectionId)) {
+    return false;
+  }
+  return true;
+}
+function isDocIndexable(filters, docId) {
+  const slashIndex = docId.indexOf("/");
+  if (slashIndex < 0) {
+    return false;
+  }
+  const collectionId = docId.slice(0, slashIndex);
+  if (!isCollectionIndexable(filters, collectionId)) {
+    return false;
+  }
+  if (filters.includeDocIds && !filters.includeDocIds.has(docId)) {
+    return false;
+  }
+  if (filters.excludeDocIds?.has(docId)) {
+    return false;
+  }
+  return true;
+}
+function isTitleyDeepKey(deepKey) {
+  const last = deepKey.split(".").pop() || "";
+  return TITLEY_KEYS.has(last.toLowerCase());
+}
+function withWeight(rec) {
+  return { ...rec, weight: isTitleyDeepKey(rec.deepKey) ? 2 : 1 };
+}
+var SearchIndexService = class {
+  constructor(rootConfig, loadSchema, filtersOverride) {
+    this.cached = null;
+    this.rootConfig = rootConfig;
+    const cmsPlugin = getCmsPlugin(rootConfig);
+    const cmsPluginOptions = cmsPlugin.getConfig();
+    this.projectId = cmsPluginOptions.id || "default";
+    this.db = cmsPlugin.getFirestore();
+    this.loadSchema = loadSchema || ((id) => this.loadCollectionSchemaFromDist(id));
+    this.filters = resolveSearchIndexFilters(
+      filtersOverride ?? cmsPluginOptions.searchIndex
+    );
+  }
+  /** Returns true if the given collection passes the include/exclude filter. */
+  isCollectionIndexable(collectionId) {
+    return isCollectionIndexable(this.filters, collectionId);
+  }
+  /**
+   * Returns true if the given doc id passes the include/exclude filter (and
+   * its collection is itself indexable). Doc ids are `<collectionId>/<slug>`.
+   */
+  isDocIndexable(docId) {
+    return isDocIndexable(this.filters, docId);
+  }
+  /** Returns the MiniSearch options used by both writers and readers. */
+  static getMiniSearchOptions() {
+    return MINISEARCH_OPTIONS;
+  }
+  indexDocPath(docId) {
+    return `Projects/${this.projectId}/${SEARCH_INDEX_SUBCOLLECTION}/${docId}`;
+  }
+  indexCollectionPath() {
+    return `Projects/${this.projectId}/${SEARCH_INDEX_SUBCOLLECTION}`;
+  }
+  /**
+   * Lists collection ids by globbing `<rootDir>/collections/*.schema.ts`,
+   * filtered by the include/exclude config.
+   */
+  async listCollectionIds() {
+    const collectionsDir = path.join(this.rootConfig.rootDir, "collections");
+    if (!fs.existsSync(collectionsDir)) {
+      return [];
+    }
+    const fileNames = await glob("*.schema.ts", { cwd: collectionsDir });
+    return fileNames.map((f) => f.slice(0, -10)).filter((id) => this.isCollectionIndexable(id));
+  }
+  /**
+   * Default schema loader: reads `dist/collections/<id>.schema.json`. These
+   * files are produced by the CMS plugin's `preBuild` hook during a real
+   * `root build`. In dev there is no JSON file on disk, so callers should
+   * pass a dev-aware `loadSchema` callback to the constructor (the API
+   * endpoints do this — they delegate to the same Vite SSR path used by
+   * `/cms/api/collection.get`).
+   */
+  async loadCollectionSchemaFromDist(collectionId) {
+    const distPath = path.join(
+      this.rootConfig.rootDir,
+      "dist",
+      "collections",
+      `${collectionId}.schema.json`
+    );
+    if (!fs.existsSync(distPath)) {
+      return null;
+    }
+    const contents = fs.readFileSync(distPath, "utf8");
+    return JSON.parse(contents);
+  }
+  async readMeta() {
+    const ref = this.db.doc(this.indexDocPath(META_DOC_ID));
+    const snap = await ref.get();
+    if (!snap.exists) {
+      return null;
+    }
+    return snap.data() || null;
+  }
+  async readDocMap() {
+    const ref = this.db.doc(this.indexDocPath(DOC_MAP_DOC_ID));
+    const snap = await ref.get();
+    if (!snap.exists) {
+      return {};
+    }
+    const data = snap.data() || {};
+    const records = data.records || {};
+    return records;
+  }
+  /** Reads all shard docs and returns the concatenated MiniSearch JSON string. */
+  async readShards(shardCount) {
+    if (shardCount <= 0) {
+      return "";
+    }
+    const refs = Array.from(
+      { length: shardCount },
+      (_, i) => this.db.doc(this.indexDocPath(`shard-${i}`))
+    );
+    const snaps = await this.db.getAll(...refs);
+    const parts = [];
+    for (const snap of snaps) {
+      if (!snap.exists) {
+        throw new Error(`searchIndex: missing shard ${snap.ref.path}`);
+      }
+      const data = snap.data() || {};
+      parts.push(typeof data.data === "string" ? data.data : "");
+    }
+    return parts.join("");
+  }
+  /** Writes shards, _docMap, _meta in one batched commit. */
+  async writeIndex(serialized, docMap, counts, existingShardCount) {
+    if (serialized.length > MAX_INDEX_SIZE_BYTES) {
+      throw new Error(
+        `searchIndex: serialized index size (${serialized.length} chars) exceeds MAX_INDEX_SIZE_BYTES. Reduce indexed fields or migrate to Cloud Storage.`
+      );
+    }
+    const shards = [];
+    for (let i = 0; i < serialized.length; i += SHARD_MAX_CHARS) {
+      shards.push(serialized.slice(i, i + SHARD_MAX_CHARS));
+    }
+    const newShardCount = shards.length;
+    const batch = this.db.batch();
+    shards.forEach((data, i) => {
+      const ref = this.db.doc(this.indexDocPath(`shard-${i}`));
+      batch.set(ref, { shardId: i, data });
+    });
+    for (let i = newShardCount; i < existingShardCount; i++) {
+      const ref = this.db.doc(this.indexDocPath(`shard-${i}`));
+      batch.delete(ref);
+    }
+    const docMapRef = this.db.doc(this.indexDocPath(DOC_MAP_DOC_ID));
+    batch.set(docMapRef, { records: docMap });
+    const metaRef = this.db.doc(this.indexDocPath(META_DOC_ID));
+    const meta = {
+      lastRun: Timestamp.now(),
+      shardCount: newShardCount,
+      docCount: counts.docCount,
+      fieldCount: counts.fieldCount,
+      runsSinceVacuum: counts.runsSinceVacuum
+    };
+    batch.set(metaRef, meta);
+    await batch.commit();
+    await this.db.doc(`Projects/${this.projectId}`).set(
+      {
+        searchIndexLastRun: meta.lastRun,
+        searchIndexDocCount: counts.docCount,
+        searchIndexFieldCount: counts.fieldCount
+      },
+      { merge: true }
+    );
+    return { shardCount: newShardCount };
+  }
+  /** Drops every doc under the SearchIndex subcollection. */
+  async wipeIndex() {
+    const snap = await this.db.collection(this.indexCollectionPath()).get();
+    if (snap.empty) {
+      return;
+    }
+    const batch = this.db.batch();
+    snap.forEach((d) => batch.delete(d.ref));
+    await batch.commit();
+  }
+  /**
+   * Lists the full set of live (collection, slug, doc) tuples for `Drafts`,
+   * filtered by the include/exclude config.
+   */
+  async listAllDocs(collectionIds) {
+    const all = [];
+    for (const collectionId of collectionIds) {
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).get();
+      snap.forEach((d) => {
+        const docId = `${collectionId}/${d.id}`;
+        if (!this.isDocIndexable(docId)) {
+          return;
+        }
+        const data = d.data() || {};
+        if (!data.collection) data.collection = collectionId;
+        if (!data.slug) data.slug = d.id;
+        if (!data.id) data.id = docId;
+        all.push(data);
+      });
+    }
+    return all;
+  }
+  /**
+   * Lists docs modified since `lastRun` across every collection, filtered by
+   * the include/exclude config.
+   */
+  async listChangedDocs(collectionIds, lastRun) {
+    const all = [];
+    for (const collectionId of collectionIds) {
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const q = this.db.collection(path3).where("sys.modifiedAt", ">=", lastRun);
+      const snap = await q.get();
+      snap.forEach((d) => {
+        const docId = `${collectionId}/${d.id}`;
+        if (!this.isDocIndexable(docId)) {
+          return;
+        }
+        const data = d.data() || {};
+        if (!data.collection) data.collection = collectionId;
+        if (!data.slug) data.slug = d.id;
+        if (!data.id) data.id = docId;
+        all.push(data);
+      });
+    }
+    return all;
+  }
+  /**
+   * Returns true when no docs have been modified since `lastRun` AND no
+   * deletions are pending (i.e. the doc-id set in `_docMap` matches the live
+   * doc-id set across all collections).
+   */
+  async hasChangesSince(lastRun, docMap = null) {
+    const collectionIds = await this.listCollectionIds();
+    for (const collectionId of collectionIds) {
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const q = this.db.collection(path3).where("sys.modifiedAt", ">=", lastRun).limit(1);
+      const snap = await q.get();
+      if (!snap.empty) {
+        return true;
+      }
+    }
+    const map = docMap ?? await this.readDocMap();
+    const knownIds = new Set(Object.keys(map));
+    if (knownIds.size === 0) {
+      return false;
+    }
+    const liveIds = /* @__PURE__ */ new Set();
+    for (const collectionId of collectionIds) {
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).select().get();
+      snap.forEach((d) => {
+        const docId = `${collectionId}/${d.id}`;
+        if (this.isDocIndexable(docId)) {
+          liveIds.add(docId);
+        }
+      });
+    }
+    for (const id of knownIds) {
+      if (!liveIds.has(id)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Orchestrates a rebuild (incremental by default; full when `force: true`). */
+  async rebuildIndex(opts = {}) {
+    const start = Date.now();
+    const force = !!opts.force;
+    const collectionIds = await this.listCollectionIds();
+    if (force) {
+      const result2 = await this.fullRebuild(collectionIds);
+      return {
+        forced: true,
+        skipped: false,
+        docCount: result2.docCount,
+        fieldCount: result2.fieldCount,
+        shardCount: result2.shardCount,
+        durationMs: Date.now() - start
+      };
+    }
+    const meta = await this.readMeta();
+    if (!meta) {
+      const result2 = await this.fullRebuild(collectionIds);
+      return {
+        forced: false,
+        skipped: false,
+        docCount: result2.docCount,
+        fieldCount: result2.fieldCount,
+        shardCount: result2.shardCount,
+        durationMs: Date.now() - start
+      };
+    }
+    const result = await this.incrementalRebuild(collectionIds, meta);
+    return {
+      forced: false,
+      skipped: result.skipped,
+      docCount: result.docCount,
+      fieldCount: result.fieldCount,
+      shardCount: result.shardCount,
+      durationMs: Date.now() - start
+    };
+  }
+  async fullRebuild(collectionIds) {
+    await this.wipeIndex();
+    const index = new MiniSearch(MINISEARCH_OPTIONS);
+    const docMap = {};
+    let docCount = 0;
+    let fieldCount = 0;
+    for (const collectionId of collectionIds) {
+      const schema = await this.loadSchema(collectionId);
+      if (!schema) {
+        console.warn(
+          `searchIndex: skipping collection "${collectionId}" \u2014 schema not available. In dev, trigger the rebuild from Settings \u2192 Site Admin (the API endpoint loads schemas via Vite). In prod, ensure dist/collections/${collectionId}.schema.json exists.`
+        );
+        continue;
+      }
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).get();
+      snap.forEach((d) => {
+        const data = d.data() || {};
+        const slug = data.slug || d.id;
+        if (!this.isDocIndexable(`${collectionId}/${slug}`)) {
+          return;
+        }
+        const records = extractDocRecords(schema, {
+          collection: collectionId,
+          slug,
+          fields: data.fields || {}
+        });
+        if (records.length === 0) {
+          return;
+        }
+        const weighted = records.map(withWeight);
+        index.addAll(weighted);
+        docMap[`${collectionId}/${slug}`] = weighted.map((r) => r.id);
+        docCount += 1;
+        fieldCount += weighted.length;
+      });
+    }
+    const serialized = JSON.stringify(index.toJSON());
+    const { shardCount } = await this.writeIndex(
+      serialized,
+      docMap,
+      { docCount, fieldCount, runsSinceVacuum: 0 },
+      0
+    );
+    this.cached = null;
+    return { docCount, fieldCount, shardCount };
+  }
+  async incrementalRebuild(collectionIds, meta) {
+    const json = await this.readShards(meta.shardCount);
+    const index = json ? MiniSearch.loadJSON(json, MINISEARCH_OPTIONS) : new MiniSearch(MINISEARCH_OPTIONS);
+    const docMap = await this.readDocMap();
+    const lastRun = meta.lastRun;
+    const changedDocs = await this.listChangedDocs(collectionIds, lastRun);
+    const schemaCache = /* @__PURE__ */ new Map();
+    const getSchema = async (collectionId) => {
+      if (!schemaCache.has(collectionId)) {
+        schemaCache.set(collectionId, await this.loadSchema(collectionId));
+      }
+      return schemaCache.get(collectionId) || null;
+    };
+    let touched = 0;
+    for (const doc of changedDocs) {
+      const collectionId = doc.collection;
+      const slug = doc.slug;
+      const docId = `${collectionId}/${slug}`;
+      const schema = await getSchema(collectionId);
+      if (!schema) {
+        continue;
+      }
+      const oldIds = docMap[docId] || [];
+      for (const id of oldIds) {
+        if (index.has(id)) {
+          index.discard(id);
+        }
+      }
+      const records = extractDocRecords(schema, {
+        collection: collectionId,
+        slug,
+        fields: doc.fields || {}
+      });
+      if (records.length === 0) {
+        delete docMap[docId];
+        continue;
+      }
+      const weighted = records.map(withWeight);
+      index.addAll(weighted);
+      docMap[docId] = weighted.map((r) => r.id);
+      touched += 1;
+    }
+    const liveIds = /* @__PURE__ */ new Set();
+    for (const collectionId of collectionIds) {
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).select().get();
+      snap.forEach((d) => {
+        const docId = `${collectionId}/${d.id}`;
+        if (this.isDocIndexable(docId)) {
+          liveIds.add(docId);
+        }
+      });
+    }
+    let deletions = 0;
+    for (const docId of Object.keys(docMap)) {
+      if (!liveIds.has(docId)) {
+        const ids = docMap[docId] || [];
+        for (const id of ids) {
+          if (index.has(id)) {
+            index.discard(id);
+          }
+        }
+        delete docMap[docId];
+        deletions += 1;
+      }
+    }
+    const skipped = touched === 0 && deletions === 0;
+    if (skipped) {
+      const noopMeta = {
+        ...meta,
+        lastRun: Timestamp.now()
+      };
+      await this.db.doc(this.indexDocPath(META_DOC_ID)).set(noopMeta, { merge: true });
+      return {
+        skipped: true,
+        docCount: meta.docCount,
+        fieldCount: meta.fieldCount,
+        shardCount: meta.shardCount
+      };
+    }
+    let runsSinceVacuum = (meta.runsSinceVacuum || 0) + 1;
+    if (runsSinceVacuum >= VACUUM_EVERY_N_RUNS) {
+      await index.vacuum();
+      runsSinceVacuum = 0;
+    }
+    let docCount = 0;
+    let fieldCount = 0;
+    for (const ids of Object.values(docMap)) {
+      if (ids.length > 0) {
+        docCount += 1;
+        fieldCount += ids.length;
+      }
+    }
+    const serialized = JSON.stringify(index.toJSON());
+    const { shardCount } = await this.writeIndex(
+      serialized,
+      docMap,
+      { docCount, fieldCount, runsSinceVacuum },
+      meta.shardCount
+    );
+    this.cached = null;
+    return { skipped: false, docCount, fieldCount, shardCount };
+  }
+  /**
+   * Returns the cached MiniSearch index, loading it from Firestore if
+   * necessary. The cache is keyed off `meta.lastRun` and survives across
+   * requests in the same process.
+   */
+  async getIndex() {
+    const meta = await this.readMeta();
+    if (!meta) {
+      this.cached = null;
+      return null;
+    }
+    if (this.cached && this.cached.meta.lastRun.toMillis() === meta.lastRun.toMillis()) {
+      return this.cached;
+    }
+    const json = await this.readShards(meta.shardCount);
+    const index = json ? MiniSearch.loadJSON(json, MINISEARCH_OPTIONS) : new MiniSearch(MINISEARCH_OPTIONS);
+    const docMap = await this.readDocMap();
+    this.cached = { index, meta, docMap };
+    return this.cached;
+  }
+  /** Runs a query against the loaded index. */
+  async search(q, options = {}) {
+    const limit = Math.max(1, Math.min(options.limit || 25, 100));
+    const cached = await this.getIndex();
+    const status = await this.getStatus();
+    if (!cached || !q.trim()) {
+      return { hits: [], meta: status };
+    }
+    const raw = executeQuery(cached.index, parseQuery(q));
+    const hits = raw.slice(0, limit).map((r) => ({
+      id: String(r.id || ""),
+      docId: String(r.docId || ""),
+      collection: String(r.collection || ""),
+      slug: String(r.slug || ""),
+      deepKey: String(r.deepKey || ""),
+      fieldLabel: String(r.fieldLabel || ""),
+      fieldType: String(r.fieldType || ""),
+      text: String(r.text || ""),
+      score: typeof r.score === "number" ? r.score : 0,
+      terms: Array.isArray(r.terms) ? r.terms.map(String) : []
+    }));
+    return { hits, meta: status };
+  }
+  /** Lightweight metadata read for status endpoints / settings UI. */
+  async getStatus() {
+    const meta = await this.readMeta();
+    if (!meta) {
+      return { lastRun: null, docCount: 0, fieldCount: 0, shardCount: 0 };
+    }
+    return {
+      lastRun: meta.lastRun.toMillis(),
+      docCount: meta.docCount,
+      fieldCount: meta.fieldCount,
+      shardCount: meta.shardCount
+    };
+  }
+};
+
+// core/versions.ts
+import fs2 from "fs";
+import path2 from "path";
+import { Timestamp as Timestamp2 } from "firebase-admin/firestore";
+import glob2 from "tiny-glob";
+var DOCUMENT_SAVE_OFFSET = 5 * 60 * 1e3;
+var VersionsService = class {
+  constructor(rootConfig) {
+    this.rootConfig = rootConfig;
+    const cmsPlugin = getCmsPlugin(rootConfig);
+    const cmsPluginOptions = cmsPlugin.getConfig();
+    const projectId = cmsPluginOptions.id || "default";
+    this.projectId = projectId;
+    this.db = cmsPlugin.getFirestore();
+  }
+  /**
+   * Saves a version of all documents that have been edited since the last run.
+   */
+  async saveVersions() {
+    const lastRun = await this.getLastRun();
+    const lastRunWithOffset = lastRun === 0 ? lastRun : lastRun - DOCUMENT_SAVE_OFFSET;
+    const changedDocs = await this.getDocsModifiedAfter(lastRunWithOffset);
+    const now = Timestamp2.now().toMillis();
+    const versions = changedDocs.filter((doc) => {
+      const modifiedAt = doc.sys.modifiedAt.toMillis();
+      if (modifiedAt > now - DOCUMENT_SAVE_OFFSET) {
+        return false;
+      }
+      const publishedAt = doc.sys.publishedAt?.toMillis?.();
+      if (publishedAt && Math.abs(publishedAt - modifiedAt) < 5e3) {
+        return false;
+      }
+      return true;
+    });
+    if (versions.length > 0) {
+      this.saveVersionsToFirestore(versions);
+    }
+    this.saveLastRun(now);
+  }
+  async saveVersionsToFirestore(versions) {
+    const batch = this.db.batch();
+    versions.forEach((version) => {
+      if (!version.collection || !version.slug || !version.sys?.modifiedAt) {
+        return;
+      }
+      const modifiedAtMillis = version.sys.modifiedAt.toMillis();
+      const versionPath = `Projects/${this.projectId}/Collections/${version.collection}/Drafts/${version.slug}/Versions/${modifiedAtMillis}`;
+      console.log(versionPath);
+      const versionRef = this.db.doc(versionPath);
+      batch.set(versionRef, version);
+    });
+    await batch.commit();
+    console.log(`versions: saved ${versions.length} versions`);
+  }
+  /**
+   * Returns the last time (in millis) saveVersions() was run, or 0 if has
+   * never been run.
+   */
+  async getLastRun() {
+    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
+    const projectDoc = await projectDocRef.get();
+    if (projectDoc.exists) {
+      const data = projectDoc.data() || {};
+      const ts = data.versionsLastRun;
+      if (ts) {
+        return ts.toMillis();
+      }
+    }
+    return 0;
+  }
+  /**
+   * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.
+   */
+  async saveLastRun(millis) {
+    const ts = Timestamp2.fromMillis(millis);
+    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
+    await projectDocRef.set({ versionsLastRun: ts }, { merge: true });
+  }
+  /**
+   * Returns a list of all docs that were edited after a certain time.
+   */
+  async getDocsModifiedAfter(millis) {
+    const ts = Timestamp2.fromMillis(millis);
+    const results = [];
+    const collectionIds = await this.listCollections();
+    for (const collectionId of collectionIds) {
+      const collectionPath = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const query = this.db.collection(collectionPath).where("sys.modifiedAt", ">=", ts);
+      const querySnapshot = await query.get();
+      querySnapshot.forEach((doc) => {
+        results.push(doc.data());
+      });
+    }
+    return results;
+  }
+  /**
+   * Returns a list of collection ids for the Root project.
+   */
+  async listCollections() {
+    const collectionsDir = path2.join(this.rootConfig.rootDir, "collections");
+    if (!fs2.existsSync(collectionsDir)) {
+      return [];
+    }
+    const collectionIds = [];
+    const collectionFileNames = await glob2("*.schema.ts", {
+      cwd: collectionsDir
+    });
+    collectionFileNames.forEach((filename) => {
+      collectionIds.push(filename.slice(0, -10));
+    });
+    return collectionIds;
+  }
+};
+
+// core/cron.ts
+var SEARCH_INDEX_MIN_INTERVAL_MS = 5 * 60 * 1e3;
+async function runCronJobs(rootConfig, options = {}) {
+  await Promise.all([
+    runCronJob("publishScheduledDocs", runPublishScheduledDocs, rootConfig),
+    runCronJob(
+      "syncScheduledDataSources",
+      runSyncScheduledDataSources,
+      rootConfig
+    ),
+    runCronJob("saveVersions", runSaveVersions, rootConfig),
+    runCronJob(
+      "incrementalSearchIndex",
+      runIncrementalSearchIndex,
+      rootConfig,
+      options.loadSchema
+    )
+  ]);
+}
+async function runCronJob(name, fn, ...args) {
+  try {
+    await fn(...args);
+  } catch (err) {
+    console.log(`cron failed: ${name}`);
+    console.error(String(err.stack || err));
+    throw err;
+  }
+}
+async function runPublishScheduledDocs(rootConfig) {
+  const cmsClient = new RootCMSClient(rootConfig);
+  await cmsClient.publishScheduledDocs();
+  await cmsClient.publishScheduledReleases();
+}
+async function runSyncScheduledDataSources(rootConfig) {
+  const cmsClient = new RootCMSClient(rootConfig);
+  await cmsClient.syncScheduledDataSources();
+}
+async function runSaveVersions(rootConfig) {
+  const service = new VersionsService(rootConfig);
+  await service.saveVersions();
+}
+async function runIncrementalSearchIndex(rootConfig, loadSchema) {
+  const service = new SearchIndexService(rootConfig, loadSchema);
+  const status = await service.getStatus();
+  if (status.lastRun !== null) {
+    const elapsed = Date.now() - status.lastRun;
+    if (elapsed < SEARCH_INDEX_MIN_INTERVAL_MS) {
+      return;
+    }
+    const hasChanges = await service.hasChangesSince(
+      Timestamp3.fromMillis(status.lastRun)
+    );
+    if (!hasChanges) {
+      return;
+    }
+  }
+  await service.rebuildIndex({ force: false });
+}
+
+export {
+  SearchIndexService,
+  runCronJobs
+};