@easy-cms/core 1.11.0 → 1.13.0

package/dist/{chunk-TMO4JTGJ.js → chunk-MHXQUX74.js}

@@ -59,6 +59,7 @@ var JOB_RUNS = "job-runs";
 var ROLES = "user-roles";
 var USER_IDENTITIES = "user-identities";
 var AUDIT_LOGS = "audit-logs";
+var OUTBOX = "outbox";
 var INTERNAL_COLLECTIONS = /* @__PURE__ */ new Set([
   SESSIONS,
   LOGIN_ATTEMPTS,
@@ -70,7 +71,8 @@ var INTERNAL_COLLECTIONS = /* @__PURE__ */ new Set([
   JOB_RUNS,
   ROLES,
   USER_IDENTITIES,
-  AUDIT_LOGS
+  AUDIT_LOGS,
+  OUTBOX
 ]);
 var DEFAULT_ROLES = ["admin", "editor"];
 var CREATED_BY_FIELD = {
@@ -519,6 +521,31 @@ var jobRunsCollection = {
     { name: "changedAt", type: "text" }
   ]
 };
+var outboxCollection = {
+  slug: OUTBOX,
+  access: { read: nobody, create: nobody, update: nobody, delete: nobody },
+  fields: [
+    // create | update | draft | delete, as the webhook event.
+    { name: "event", type: "text", required: true },
+    // The collection's or the global's slug.
+    { name: "target", type: "text", required: true },
+    { name: "global", type: "boolean" },
+    { name: "docId", type: "text" },
+    // The stored status before the save, for publish and unpublish events.
+    { name: "before", type: "text" },
+    // JSON: the document as saved (as deleted), the one before, and the user who saved.
+    { name: "doc", type: "textarea", required: true },
+    { name: "previousDoc", type: "textarea" },
+    { name: "user", type: "textarea" },
+    // Steps already done (hooks, webhooks, purge), so a retry runs only the rest.
+    { name: "done", type: "text" },
+    { name: "attempts", type: "number", required: true },
+    { name: "nextAttemptAt", type: "text", required: true, index: true },
+    // pending | running | failed
+    { name: "state", type: "text", required: true, index: true },
+    { name: "error", type: "text" }
+  ]
+};
 var emailDeliveriesCollection = {
   slug: EMAIL_DELIVERIES,
   access: { read: nobody, create: nobody, update: nobody, delete: nobody },
@@ -572,8 +599,8 @@ function cut(value) {
   if (typeof value === "string")
     return value.length > MAX_VALUE ? `${value.slice(0, MAX_VALUE)}\u2026` : value;
   if (value !== null && typeof value === "object") {
-    const json = JSON.stringify(value);
-    return json.length > MAX_VALUE ? "\u2026" : value;
+    const json2 = JSON.stringify(value);
+    return json2.length > MAX_VALUE ? "\u2026" : value;
   }
   return value;
 }
@@ -3797,7 +3824,8 @@ var VersionStore = class {
         snapshot: args.snapshot,
         createdAt: now,
         updatedAt: now
-      }
+      },
+      outbox: args.outbox
     });
     await this.prune(parent, doc, args.max);
     return toSummary(created);
@@ -4187,6 +4215,189 @@ function localizeSort(fields, sort, locale, locales = []) {
   );
 }
 
+// src/outbox.ts
+var DELAYS = [6e4, 5 * 6e4, 30 * 6e4, 2 * 36e5, 12 * 36e5];
+var LEASE = 5 * 6e4;
+var BATCH2 = 50;
+var later2 = (from, ms) => new Date(from.getTime() + ms).toISOString();
+var json = (value) => value === void 0 ? null : JSON.stringify(value);
+var parse2 = (value) => typeof value === "string" ? JSON.parse(value) : void 0;
+function withoutHash(value) {
+  if (!value || !("passwordHash" in value)) return value;
+  const { passwordHash: _, ...rest } = value;
+  return rest;
+}
+var Outbox = class {
+  constructor(db, logger, runner) {
+    this.db = db;
+    this.logger = logger;
+    this.runner = runner;
+  }
+  db;
+  logger;
+  runner;
+  draining;
+  again = false;
+  /** The row a save writes. For a create, `doc` has no id yet: it gets the written one. */
+  row(entry) {
+    return {
+      collection: OUTBOX,
+      data: (id) => {
+        const docId = entry.global ? null : String(entry.docId ?? id);
+        const doc = entry.event === "create" ? { ...entry.doc, id } : entry.doc;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        return {
+          event: entry.event,
+          target: entry.target,
+          global: entry.global,
+          docId,
+          before: entry.before,
+          doc: JSON.stringify(withoutHash(doc)),
+          previousDoc: json(withoutHash(entry.previousDoc)),
+          user: json(withoutHash(entry.user)),
+          done: null,
+          attempts: 0,
+          nextAttemptAt: now,
+          state: "pending",
+          error: null,
+          createdAt: now,
+          updatedAt: now
+        };
+      }
+    };
+  }
+  /** Runs what is due in the background, e.g. right after a save commits. */
+  kick() {
+    if (this.draining) {
+      this.again = true;
+      return;
+    }
+    this.draining = (async () => {
+      do {
+        this.again = false;
+        await this.run();
+      } while (this.again);
+    })().catch((error) => this.logger.error(`Outbox: ${error.message}`, { error })).finally(() => {
+      this.draining = void 0;
+    });
+  }
+  /** Waits until the background run started by `kick` is over. */
+  async flush() {
+    while (this.draining) await this.draining;
+  }
+  /**
+   * Runs entries that are due: new ones, retries whose time came, and those a stopped worker
+   * left claimed. Runs with scheduled jobs too, which catches what `kick` missed.
+   */
+  async run(now = /* @__PURE__ */ new Date()) {
+    let ran = 0;
+    let failed = 0;
+    for (; ; ) {
+      const { docs } = await this.db.find({
+        collection: OUTBOX,
+        where: {
+          and: [
+            { state: { in: ["pending", "running"] } },
+            { nextAttemptAt: { lte: now.toISOString() } }
+          ]
+        },
+        sort: ["nextAttemptAt", "id"],
+        limit: BATCH2,
+        page: 1
+      });
+      let claimed = 0;
+      for (const row of docs) {
+        const result = await this.runRow(row, now);
+        if (result === void 0) continue;
+        claimed++;
+        if (result) ran++;
+        else failed++;
+      }
+      if (docs.length < BATCH2 || claimed === 0) return { ran, failed };
+    }
+  }
+  /** Puts a failed entry back in line, e.g. from the admin. */
+  async retry(id) {
+    const row = await this.db.findById({ collection: OUTBOX, id });
+    if (!row || row.state !== "failed") return false;
+    const { id: _, ...data } = row;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = await this.db.update({
+      collection: OUTBOX,
+      id,
+      data: { ...data, state: "pending", attempts: 0, nextAttemptAt: now, updatedAt: now },
+      where: { state: { equals: "failed" } }
+    });
+    if (updated) this.kick();
+    return updated !== null;
+  }
+  /** `true` when it ran, `false` when it failed, `undefined` when another worker has it. */
+  async runRow(row, now) {
+    const { id, ...data } = row;
+    const attempts = Number(data.attempts ?? 0) + 1;
+    let current = {
+      ...data,
+      state: "running",
+      attempts,
+      nextAttemptAt: later2(now, LEASE),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const claimed = await this.db.update({
+      collection: OUTBOX,
+      id,
+      data: current,
+      where: {
+        and: [{ state: { equals: data.state } }, { nextAttemptAt: { equals: data.nextAttemptAt } }]
+      }
+    });
+    if (!claimed) return void 0;
+    const done = new Set(
+      String(data.done ?? "").split(",").filter(Boolean)
+    );
+    const mark = async (step) => {
+      done.add(step);
+      current = { ...current, done: [...done].join(","), updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      await this.db.update({ collection: OUTBOX, id, data: current });
+    };
+    try {
+      await this.runner(entryOf(data), done, mark);
+      await this.db.delete({ collection: OUTBOX, id });
+      return true;
+    } catch (error) {
+      const message2 = error instanceof Error ? error.message : String(error);
+      const delay = DELAYS[attempts - 1];
+      await this.db.update({
+        collection: OUTBOX,
+        id,
+        data: {
+          ...current,
+          state: delay === void 0 ? "failed" : "pending",
+          nextAttemptAt: later2(now, delay ?? 0),
+          error: message2,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      const what = `${data.event} of ${data.global ? "global " : ""}"${data.target}"`;
+      if (delay === void 0)
+        this.logger.error(`Outbox gave up on ${what} after ${attempts} attempts: ${message2}`);
+      else this.logger.warn(`Outbox: ${what} failed (${message2}); will retry`);
+      return false;
+    }
+  }
+};
+function entryOf(row) {
+  return {
+    event: row.event,
+    target: String(row.target),
+    global: row.global === true,
+    docId: typeof row.docId === "string" ? row.docId : null,
+    before: typeof row.before === "string" ? row.before : null,
+    doc: parse2(row.doc) ?? {},
+    previousDoc: parse2(row.previousDoc),
+    user: parse2(row.user) ?? null
+  };
+}
+
 // src/remote-file.ts
 import { lookup as dnsLookup } from "dns";
 import { request as httpRequest } from "http";
@@ -4426,7 +4637,7 @@ function read(response, maxBytes, deadline) {
 var keys = (list) => new Set(list.split(/\s+/).filter(Boolean));
 var CONFIG = keys(`secret db serverURL cors cronSecret timeZone webhooks events jobs localization routes admin
   upload auth collections globals endpoints cliCommands onRequest fieldTypes apiKeys email backups
-  audit logs countCacheSeconds maxPage httpCache plugins`);
+  audit logs countCacheSeconds maxPage httpCache outbox search plugins`);
 var ADMIN = keys("path locale brand siteURL nav commands modules pages dashboard switcher");
 var AUTH = keys(`roles rbac tokenExpiration maxLoginAttempts lockWindow trustedOrigins
   resetPasswordExpiration inviteExpiration providers providerSignUp password setupCode members emails`);
@@ -4436,7 +4647,7 @@ var BACKUPS = keys("frequency at keep dir storage sqlite encryptionKey");
 var AUDIT = keys("keepDays values failedLogins scope");
 var LOGS = keys("format requests");
 var COLLECTION = keys(`slug labels fields useAsTitle drafts versions schedule preview access hooks
-  admin httpCache`);
+  admin httpCache search`);
 var GLOBAL = keys(
   "slug label fields drafts versions schedule preview access hooks scope admin httpCache"
 );
@@ -4656,6 +4867,264 @@ function groupOf(group, ids, fallback) {
   return { id: `label:${JSON.stringify(group)}`, label: group };
 }
 
+// src/search.ts
+var SEARCHABLE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "email",
+  "slug",
+  "select",
+  "richText",
+  "array",
+  "group",
+  "blocks"
+]);
+function fieldAt(fields, path) {
+  const [name, ...rest] = path.split(".");
+  const field = fields.find((f) => f.name === name);
+  if (!field || rest.length === 0) return field;
+  return field.type === "group" ? fieldAt(field.fields, rest.join(".")) : void 0;
+}
+function textOf(field, value) {
+  if (value === null || value === void 0) return "";
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "email":
+    case "slug":
+      return typeof value === "string" ? value : "";
+    case "select":
+      return [value].flat().filter((v) => typeof v === "string").join(" ");
+    case "richText":
+      return richText(value);
+    case "group":
+      return typeof value === "object" ? fieldsText(field.fields, value) : "";
+    case "array":
+    case "blocks":
+      if (!Array.isArray(value) || !hasRows(field)) return "";
+      return value.map((row) => {
+        const fields = rowFields(field, row);
+        return fields && row && typeof row === "object" ? fieldsText(fields, row) : "";
+      }).filter(Boolean).join("\n");
+    default:
+      return "";
+  }
+}
+function fieldsText(fields, data) {
+  return fields.filter((f) => SEARCHABLE_TYPES.has(f.type) && !f.hidden).map((f) => textOf(f, data[f.name])).filter(Boolean).join("\n");
+}
+function richText(node) {
+  if (!node || typeof node !== "object") return "";
+  const { text: text3, content } = node;
+  if (typeof text3 === "string") return text3;
+  if (!Array.isArray(content)) return "";
+  const inline = content.some((child) => typeof child?.text === "string");
+  return content.map(richText).filter(Boolean).join(inline ? "" : "\n");
+}
+function searchText(fields, doc, paths) {
+  const text3 = {};
+  for (const path of paths) {
+    const field = fieldAt(fields, path);
+    let value = doc;
+    for (const name of path.split("."))
+      value = value && typeof value === "object" ? value[name] : void 0;
+    text3[path] = field ? textOf(field, value) : "";
+  }
+  return text3;
+}
+var segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+function words(text3) {
+  return [...segmenter.segment(text3.normalize("NFC").toLowerCase())].filter((s) => s.isWordLike).map((s) => s.segment);
+}
+function memorySearch() {
+  const entries = /* @__PURE__ */ new Map();
+  const key = (collection2, id, locale) => JSON.stringify([collection2, id, locale]);
+  return {
+    name: "memory",
+    apiVersion: 1,
+    ephemeral: true,
+    async index(list) {
+      for (const e of list) {
+        const fields = Object.values(e.text).map(words);
+        entries.set(key(e.collection, e.id, e.locale), {
+          collection: e.collection,
+          id: e.id,
+          locale: e.locale,
+          fields,
+          joined: fields.map((list2) => list2.join(""))
+        });
+      }
+    },
+    async remove(documents) {
+      const gone = new Set(documents.map((d) => JSON.stringify([d.collection, d.id])));
+      for (const [k, e] of entries)
+        if (gone.has(JSON.stringify([e.collection, e.id]))) entries.delete(k);
+    },
+    async clear(collection2) {
+      for (const [k, e] of entries) if (e.collection === collection2) entries.delete(k);
+    },
+    async search(q) {
+      const terms = [...new Set(words(q.query))];
+      if (terms.length === 0) return { hits: [], total: 0 };
+      const collections = new Set(q.collections);
+      const scored = [];
+      for (const e of entries.values()) {
+        if (!collections.has(e.collection) || q.locale !== null && e.locale !== q.locale) continue;
+        let score = 0;
+        for (const term of terms) {
+          let best = 0;
+          e.fields.forEach((list, i) => {
+            const weight = e.fields.length - i;
+            for (const w of list)
+              if (w === term) best = Math.max(best, weight * 4);
+              else if (w.startsWith(term)) best = Math.max(best, weight * 2);
+            if (best === 0 && e.joined[i]?.includes(term)) best = weight;
+          });
+          if (best === 0) {
+            score = 0;
+            break;
+          }
+          score += best;
+        }
+        if (score > 0) scored.push({ e, score });
+      }
+      scored.sort((a, b) => b.score - a.score);
+      return {
+        hits: scored.slice(q.offset, q.offset + q.limit).map(({ e }) => ({ collection: e.collection, id: e.id })),
+        total: scored.length
+      };
+    },
+    describe: () => [
+      { key: "index", value: "memory" },
+      { key: "entries", value: String(entries.size) }
+    ]
+  };
+}
+var SearchIndex = class {
+  constructor(adapter, collections, locales, logger, read2, pages2) {
+    this.adapter = adapter;
+    this.collections = collections;
+    this.locales = locales;
+    this.logger = logger;
+    this.read = read2;
+    this.pages = pages2;
+  }
+  adapter;
+  collections;
+  locales;
+  logger;
+  read;
+  pages;
+  /** Indexing started by saves, which searches wait for. */
+  pending = /* @__PURE__ */ new Set();
+  /** The first build of an `ephemeral` index. */
+  building;
+  /** The collection's `search`, or `undefined` when it isn't searchable. */
+  configOf(collection2) {
+    const config = this.collections.find((c) => c.slug === collection2);
+    return config?.search ? config : void 0;
+  }
+  /** Slugs of the searchable collections. */
+  get searchable() {
+    return this.collections.filter((c) => c.search).map((c) => c.slug);
+  }
+  /** Builds an `ephemeral` index in the background; searches wait for it. */
+  start() {
+    if (!this.adapter.ephemeral || this.searchable.length === 0) return;
+    this.building = this.reindex().then(
+      () => void 0,
+      (error) => this.logger.error(`Search: building the index failed: ${error.message}`, {
+        error
+      })
+    );
+  }
+  /**
+   * Indexes a document as it now is, or removes it when it isn't published (or is gone). Reading
+   * it again, rather than taking what a save had, makes running it twice or late harmless.
+   */
+  async sync(collection2, id) {
+    const config = this.configOf(collection2);
+    if (!config) return;
+    const entries = [];
+    for (const locale of this.locales) {
+      const doc = await this.read(collection2, String(id), locale);
+      if (!doc) {
+        await this.adapter.remove([{ collection: collection2, id: String(id) }]);
+        return;
+      }
+      entries.push(this.entry(config, doc, locale));
+    }
+    await this.adapter.index(entries);
+  }
+  /** `sync` after a save, in the background: failures are logged. */
+  syncLater(collection2, id) {
+    const run = this.sync(collection2, id).catch(
+      (error) => this.logger.error(
+        `Search: indexing ${collection2} ${String(id)} failed: ${error.message}; run \`easy-cms search:reindex\` to repair the index`,
+        { error }
+      )
+    ).finally(() => this.pending.delete(run));
+    this.pending.add(run);
+  }
+  /** Waits for indexing started so far. */
+  async flush() {
+    await this.building;
+    while (this.pending.size > 0) await Promise.all(this.pending);
+  }
+  /** Builds the index again from the database: every collection, or one. */
+  async reindex(collection2) {
+    const slugs = collection2 === void 0 ? this.searchable : [collection2];
+    for (const slug2 of slugs)
+      if (!this.configOf(slug2))
+        throw new QueryError(`"${slug2}" is not searchable: it has no \`search\` in the config`);
+    await this.adapter.setup?.(
+      slugs.map((slug2) => ({ slug: slug2, fields: this.configOf(slug2)?.search.fields ?? [] }))
+    );
+    const done = [];
+    for (const slug2 of slugs) {
+      const config = this.configOf(slug2);
+      await this.adapter.clear(slug2);
+      const ids = /* @__PURE__ */ new Set();
+      for (const locale of this.locales)
+        for await (const docs of this.pages(slug2, locale)) {
+          for (const doc of docs) ids.add(String(doc.id));
+          await this.adapter.index(docs.map((doc) => this.entry(config, doc, locale)));
+        }
+      done.push({ collection: slug2, documents: ids.size });
+    }
+    return done;
+  }
+  /** Hits for a query, as documents the reader may read, best match first. */
+  async search(query, readHits) {
+    await this.flush();
+    const found = await this.adapter.search(query);
+    const byCollection = /* @__PURE__ */ new Map();
+    for (const hit of found.hits)
+      byCollection.set(hit.collection, [...byCollection.get(hit.collection) ?? [], hit.id]);
+    const docs = /* @__PURE__ */ new Map();
+    await Promise.all(
+      [...byCollection].map(async ([collection2, ids]) => {
+        for (const doc of await readHits(collection2, ids))
+          docs.set(JSON.stringify([collection2, String(doc.id)]), doc);
+      })
+    );
+    const hits = [];
+    for (const hit of found.hits) {
+      const doc = docs.get(JSON.stringify([hit.collection, hit.id]));
+      if (doc) hits.push({ collection: hit.collection, doc });
+    }
+    return { hits, total: found.total };
+  }
+  entry(config, doc, locale) {
+    return {
+      collection: config.slug,
+      id: String(doc.id),
+      locale,
+      text: searchText(config.fields, doc, config.search.fields)
+    };
+  }
+};
+
 // src/webhooks.ts
 import { createHmac as createHmac5, randomUUID as randomUUID2 } from "crypto";
 var WEBHOOK_EVENTS = [
@@ -4694,6 +5163,23 @@ var Webhooks = class {
       this.track(this.deliver(hook, payload));
     }
   }
+  /**
+   * `emit` for the outbox: resolves once each delivery is saved in the queue (sent, without a
+   * queue), so the event can count as done. Throws when saving fails; nothing is sent then.
+   */
+  async emitSaved(event, target, doc) {
+    const payload = { event, ...target, doc, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    for (const hook of this.hooks) {
+      if (!matches(hook, payload)) continue;
+      if (!this.queue) {
+        await this.deliver(hook, payload);
+        continue;
+      }
+      await new Promise(
+        (saved, failed) => this.track(this.deliver(hook, payload, { saved: () => saved(), failed }))
+      );
+    }
+  }
   /** Waits for deliveries in progress, e.g. before a serverless function returns. */
   async flush() {
     while (this.pending.size > 0) await Promise.allSettled([...this.pending]);
@@ -4717,7 +5203,7 @@ var Webhooks = class {
       const claimed = await this.queue.claim(id, queued, {
         ...queued,
         attempts,
-        nextAttemptAt: later2(now, CLAIM2)
+        nextAttemptAt: later3(now, CLAIM2)
       });
       if (!claimed) continue;
       const result = await this.attempt(hook, queued.event, queued.body, queued.delivery);
@@ -4731,7 +5217,7 @@ var Webhooks = class {
       await this.queue.update(id, {
         ...queued,
         attempts,
-        nextAttemptAt: later2(now, delay ?? 0),
+        nextAttemptAt: later3(now, delay ?? 0),
         state: delay === void 0 ? "failed" : "pending",
         error: result.error
       });
@@ -4754,7 +5240,7 @@ var Webhooks = class {
     ).finally(() => this.pending.delete(tracked));
     this.pending.add(tracked);
   }
-  async deliver(hook, payload) {
+  async deliver(hook, payload, saving) {
     const delivery = randomUUID2();
     const body = JSON.stringify(payload);
     const { event } = payload;
@@ -4769,13 +5255,15 @@ var Webhooks = class {
       error
     });
     const { queue } = this;
-    const saved = queue ? this.saving.then(() => queue.add(entry(0, later2(/* @__PURE__ */ new Date(), CLAIM2), null))) : Promise.resolve(void 0);
+    const saved = queue ? this.saving.then(() => queue.add(entry(0, later3(/* @__PURE__ */ new Date(), CLAIM2), null))) : Promise.resolve(void 0);
     this.saving = saved.catch(() => {
     });
     let queued;
     try {
       queued = await saved;
+      saving?.saved();
     } catch (error) {
+      if (saving) return saving.failed(error);
       this.logger.error(`Could not save webhook delivery: ${error.message}`, { error });
     }
     for (let attempt = 0; ; attempt++) {
@@ -4788,7 +5276,7 @@ var Webhooks = class {
       if (delay === void 0) {
         if (queued === void 0 || !this.queue)
           return this.giveUp(hook, event, result.error, attempt + 1);
-        const next = later2(/* @__PURE__ */ new Date(), QUEUE_DELAYS2[0]);
+        const next = later3(/* @__PURE__ */ new Date(), QUEUE_DELAYS2[0]);
         await this.queue.update(queued, entry(attempt + 1, next, result.error));
         this.logger.warn(
           `Webhook ${hook.url} failed for ${event} (${result.error}); will retry later`
@@ -4833,7 +5321,7 @@ var Webhooks = class {
     );
   }
 };
-var later2 = (from, ms) => new Date(from.getTime() + ms).toISOString();
+var later3 = (from, ms) => new Date(from.getTime() + ms).toISOString();
 var isContentEvent = (event) => WEBHOOK_EVENTS.includes(event);
 function matches(hook, payload) {
   if (!isContentEvent(payload.event)) return hook.events?.includes(payload.event) === true;
@@ -4861,6 +5349,7 @@ var RESERVED_SLUGS = /* @__PURE__ */ new Set([
   "audit-logs",
   "api-keys",
   "jobs",
+  "outbox",
   "auth",
   "migrations",
   "access",
@@ -4892,6 +5381,8 @@ function validateConfig(config) {
   validateAudit(config, add);
   validateLogs(config, add);
   validateCountCache(config, add);
+  validateOutbox(config, add);
+  validateSearch(config, add);
   validateMaxPage(config, add);
   validateHttpCache(config, add);
   validateAuth(config, add);
@@ -5541,6 +6032,53 @@ function validateMaxPage(config, add) {
   if (max !== void 0 && !(Number.isInteger(max) && max >= 1))
     add("maxPage", "must be a whole number, 1 or more");
 }
+function validateOutbox(config, add) {
+  if (config.outbox !== void 0 && typeof config.outbox !== "boolean")
+    add("outbox", "must be true or false");
+}
+function validateSearch(config, add) {
+  const adapter = config.search;
+  if (adapter !== void 0) {
+    const a = adapter;
+    if (typeof a !== "object" || a === null || !["index", "remove", "clear", "search"].every((m) => typeof a[m] === "function"))
+      add("search", "must be a search adapter", "e.g. search: memorySearch()");
+    for (const c of config.collections ?? [])
+      if (c?.slug === "search")
+        add(
+          "collections.search.slug",
+          '"search" is the search route when `search` is set',
+          "choose another slug"
+        );
+  }
+  for (const c of config.collections ?? []) {
+    const search = c?.search;
+    if (search === void 0) continue;
+    const path = `collections.${c.slug}.search`;
+    if (adapter === void 0) {
+      add(path, "needs a search adapter in the config", "e.g. search: memorySearch()");
+      continue;
+    }
+    const fields = search?.fields;
+    if (!Array.isArray(fields) || fields.length === 0) {
+      add(
+        `${path}.fields`,
+        "must list the fields to index",
+        "e.g. search: { fields: ['title', 'body'] }"
+      );
+      continue;
+    }
+    for (const name of fields) {
+      const field = typeof name === "string" ? fieldAt(c.fields ?? [], name) : void 0;
+      if (!field) add(`${path}.fields`, `has no field "${String(name)}"`);
+      else if (!SEARCHABLE_TYPES.has(field.type) || field.hidden)
+        add(
+          `${path}.fields`,
+          `can't index "${name}" (${field.hidden ? "hidden" : field.type})`,
+          "text, textarea, email, slug, select, rich text, array, group and blocks fields hold text"
+        );
+    }
+  }
+}
 function validateCountCache(config, add) {
   const seconds = config.countCacheSeconds;
   if (seconds !== void 0 && !(typeof seconds === "number" && Number.isFinite(seconds) && seconds >= 0))
@@ -6283,6 +6821,7 @@ function validateAdapterVersions(config, add) {
     ["upload.privateStorage", config.upload?.privateStorage],
     ["backups.storage", config.backups?.storage],
     ["email", config.email],
+    ["search", config.search],
     ...(config.auth?.providers ?? []).map(
       (p, i) => [`auth.providers[${i}]`, p]
     )
@@ -6402,6 +6941,7 @@ async function resolveConfig(input) {
       ...config.apiKeys ? [apiKeysCollection] : [],
       ...config.email ? [emailDeliveriesCollection] : [],
       ...(config.jobs?.length ?? 0) > 0 ? [jobRunsCollection] : [],
+      ...config.outbox ? [outboxCollection] : [],
       databaseBackupsCollection,
       ...config.auth?.rbac ? [rolesCollection] : [],
       ...(config.auth?.providers?.length ?? 0) > 0 ? [userIdentitiesCollection] : [],
@@ -6490,8 +7030,23 @@ async function createEasyCMS(config, options = {}) {
     logger,
     interactive: options.interactive ?? false
   });
+  if (resolved3.outbox && db.outbox !== true) {
+    await db.destroy();
+    throw new ConfigError([
+      {
+        path: "outbox",
+        message: `needs a database adapter that writes outbox rows; "${resolved3.db.name}" doesn't`,
+        hint: "use @easy-cms/db-sqlite or @easy-cms/db-postgres 1.12 or later"
+      }
+    ]);
+  }
   const cms = new EasyCMS(resolved3, db, logger, storage, cwd);
-  const scheduling = [...resolved3.collections, ...resolved3.globals].some((c) => c.schedule) || (resolved3.webhooks?.length ?? 0) > 0 || resolved3.email !== void 0 || resolved3.jobs.length > 0;
+  if (resolved3.search?.ephemeral && process.env.NODE_ENV === "production")
+    logger.warn(
+      `Search: the "${resolved3.search.name ?? "custom"}" index lives in this process's memory: it is built again at each start, and each instance has its own. Use a search engine adapter for large sites or several instances.`
+    );
+  if (options.scheduler !== false) cms.startSearch();
+  const scheduling = [...resolved3.collections, ...resolved3.globals].some((c) => c.schedule) || (resolved3.webhooks?.length ?? 0) > 0 || resolved3.email !== void 0 || resolved3.jobs.length > 0 || resolved3.outbox === true;
   if (scheduling && options.scheduler !== false) cms.startScheduler();
   if (process.env.NODE_ENV === "production" && !resolved3.auth.setupCode && await cms.auth.hasUsers().catch(() => true) === false)
     logger.warn(
@@ -6531,6 +7086,10 @@ var EasyCMS = class {
   versions;
   webhooks;
   mailer;
+  /** With `outbox: true`: runs after hooks and events from rows saves write. */
+  outbox;
+  /** With `search`: keeps the index in step with published documents. */
+  searchIndex;
   /** @internal */
   constructor(config, db, logger = consoleLogger, storage = diskStorage({ dir: config.upload.dir }), cwd = process.cwd(), privateStorage) {
     this.config = config;
@@ -6558,6 +7117,19 @@ var EasyCMS = class {
       logger,
       config.collections.some((c) => c.slug === EMAIL_DELIVERIES) ? this.emailQueue() : void 0
     );
+    this.outbox = config.collections.some((c) => c.slug === OUTBOX) ? new Outbox(db, logger, (entry, done, mark) => this.runOutbox(entry, done, mark)) : void 0;
+    this.searchIndex = config.search ? new SearchIndex(
+      config.search,
+      config.collections,
+      config.localization ? config.localization.locales : [null],
+      logger,
+      (collection2, id, locale) => this.findById(collection2, id, {
+        draft: false,
+        depth: 0,
+        ...locale ? { locale } : {}
+      }),
+      (collection2, locale) => this.publishedPages(collection2, locale)
+    ) : void 0;
     this.auth = new Auth(this);
   }
   /**
@@ -7427,14 +7999,21 @@ var EasyCMS = class {
         ]);
       }
       const draft = { ...prepared, id: parsed, createdAt: existing.createdAt, updatedAt: now };
-      await this.saveVersion(config, collectionParent(collection2), parsed, draft, guard);
-      await this.notify(config.hooks?.afterChange, "afterChange", config.slug, {
-        ...base,
-        doc: draft,
-        previousDoc: current,
-        operation: "update"
+      const outbox2 = this.outboxRow(config, "draft", guard, draft, {
+        docId: parsed,
+        previousDoc: current
       });
-      this.emitChange(config, "draft", draft);
+      await this.saveVersion(config, collectionParent(collection2), parsed, draft, guard, outbox2);
+      if (outbox2) this.outbox?.kick();
+      else {
+        await this.notify(config.hooks?.afterChange, "afterChange", config.slug, {
+          ...base,
+          doc: draft,
+          previousDoc: current,
+          operation: "update"
+        });
+        this.emitChange(config, "draft", draft);
+      }
       await this.audited(config, "draft", draft, current, guard, mode);
       const [out2] = await this.output(config, [draft], guard, {
         ...options,
@@ -7463,7 +8042,18 @@ var EasyCMS = class {
       }
     }
     const data = { ...prepared, createdAt: existing.createdAt, updatedAt: now };
-    const doc = options.where ? await this.db.update({ collection: collection2, id: parsed, data, where: options.where }) : await this.db.update({ collection: collection2, id: parsed, data });
+    const outbox = this.outboxRow(
+      config,
+      "update",
+      guard,
+      { ...data, id: parsed },
+      {
+        docId: parsed,
+        previousDoc: current,
+        before: existing.status
+      }
+    );
+    const doc = options.where ? await this.db.update({ collection: collection2, id: parsed, data, where: options.where, outbox }) : await this.db.update({ collection: collection2, id: parsed, data, outbox });
     if (!doc) return null;
     if (moved) await moved.cleanUp();
     if (collection2 === MEDIA_FOLDERS) {
@@ -7473,13 +8063,16 @@ var EasyCMS = class {
     }
     if (!live) await this.saveVersion(config, collectionParent(collection2), parsed, doc, guard);
     if (password !== void 0) await this.auth.revokeSessions(parsed);
-    await this.notify(config.hooks?.afterChange, "afterChange", config.slug, {
-      ...base,
-      doc,
-      previousDoc: current,
-      operation: "update"
-    });
-    this.emitChange(config, "update", doc, existing.status);
+    if (outbox) this.outbox?.kick();
+    else {
+      await this.notify(config.hooks?.afterChange, "afterChange", config.slug, {
+        ...base,
+        doc,
+        previousDoc: current,
+        operation: "update"
+      });
+      this.emitChange(config, "update", doc, existing.status);
+    }
     await this.audited(config, "update", doc, current, guard, mode);
     const [out] = await this.output(config, [doc], guard, { ...options, draft: true });
     return out;
@@ -7517,7 +8110,8 @@ var EasyCMS = class {
       await this.checkMoveLimit(await this.folders.privacyAfter(parsed, { private: false }));
       await this.folders.release(existing);
     }
-    await this.db.delete({ collection: collection2, id: parsed });
+    const outbox = this.outboxRow(config, "delete", guard, existing, { docId: parsed });
+    await this.db.delete({ collection: collection2, id: parsed, outbox });
     if (collection2 === MEDIA_FOLDERS) {
       this.folders.invalidate();
       const parent = existing.parent ?? null;
@@ -7529,12 +8123,15 @@ var EasyCMS = class {
       for (const job of await this.pendingJobs(collection2, parsed))
         await this.db.delete({ collection: SCHEDULED_JOBS, id: job.id });
     }
-    await this.notify(config.hooks?.afterDelete, "afterDelete", config.slug, {
-      ...base,
-      id: parsed,
-      doc: existing
-    });
-    this.emitChange(config, "delete", existing);
+    if (outbox) this.outbox?.kick();
+    else {
+      await this.notify(config.hooks?.afterDelete, "afterDelete", config.slug, {
+        ...base,
+        id: parsed,
+        doc: existing
+      });
+      this.emitChange(config, "delete", existing);
+    }
     await this.audited(config, "delete", existing, existing, guard);
     const [out] = await this.output(config, [existing], guard, { depth: 0, draft: true });
     return out;
@@ -7691,26 +8288,38 @@ var EasyCMS = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (mode !== "unpublish" && this.separateDrafts(config) && existing.status === "published" && prepared.status === "draft") {
       const draft = { ...prepared, updatedAt: now };
-      await this.saveVersion(config, globalParent(key), 0, draft, guard);
+      const outbox2 = this.outboxRow(config, "draft", guard, draft, { previousDoc: current });
+      await this.saveVersion(config, globalParent(key), 0, draft, guard, outbox2);
+      if (outbox2) this.outbox?.kick();
+      else {
+        await this.notify(config.hooks?.afterChange, "afterChange", slug2, {
+          ...base,
+          doc: draft,
+          previousDoc: current,
+          operation: "update"
+        });
+        this.emitChange(config, "draft", draft);
+      }
+      await this.audited(config, "draft", draft, current, guard, mode);
+      return this.readGlobal(config, key, guard, { ...options, draft: true });
+    }
+    const data = { ...prepared, updatedAt: now };
+    const outbox = this.outboxRow(config, "update", guard, data, {
+      previousDoc: current,
+      before: existing.status
+    });
+    const doc = await this.db.updateGlobal({ slug: key, data, outbox });
+    await this.saveVersion(config, globalParent(key), 0, doc, guard);
+    if (outbox) this.outbox?.kick();
+    else {
       await this.notify(config.hooks?.afterChange, "afterChange", slug2, {
         ...base,
-        doc: draft,
+        doc,
         previousDoc: current,
         operation: "update"
       });
-      this.emitChange(config, "draft", draft);
-      await this.audited(config, "draft", draft, current, guard, mode);
-      return this.readGlobal(config, key, guard, { ...options, draft: true });
+      this.emitChange(config, "update", doc, existing.status);
     }
-    const doc = await this.db.updateGlobal({ slug: key, data: { ...prepared, updatedAt: now } });
-    await this.saveVersion(config, globalParent(key), 0, doc, guard);
-    await this.notify(config.hooks?.afterChange, "afterChange", slug2, {
-      ...base,
-      doc,
-      previousDoc: current,
-      operation: "update"
-    });
-    this.emitChange(config, "update", doc, existing.status);
     await this.audited(config, "update", doc, current, guard, mode);
     return this.readGlobal(config, key, guard, { ...options, draft: true });
   }
@@ -7824,9 +8433,97 @@ var EasyCMS = class {
       }
     };
   }
+  /**
+   * Waits until the outbox (`outbox: true`) ran what saves left so far, e.g. before a serverless
+   * function returns. What fails stays queued for its retry.
+   */
+  flushOutbox() {
+    return this.outbox?.flush() ?? Promise.resolve();
+  }
+  /**
+   * Searches the collections that have `search` with the config's `search` adapter: published
+   * documents, best match first, read with the access options given (pass `overrideAccess: false`
+   * and `user` to apply access rules). `total` counts matches before access rules, so a page can
+   * hold fewer documents than `limit`.
+   */
+  async search(query, options = {}) {
+    const index = this.searchIndex;
+    if (!index) throw new QueryError("Search needs a `search` adapter in the config");
+    const limit = options.limit ?? 10;
+    const page = options.page ?? 1;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+      throw new QueryError("limit must be an integer from 1 to 100");
+    if (!Number.isInteger(page) || page < 1) throw new QueryError("page must be an integer from 1");
+    const collections = options.collections ?? index.searchable;
+    for (const slug2 of collections)
+      if (!index.configOf(slug2)) throw new QueryError(`"${slug2}" is not searchable`);
+    const localization = this.config.localization;
+    const asked = options.locale && options.locale !== ALL_LOCALES ? options.locale : void 0;
+    if (asked !== void 0 && localization && !localization.locales.includes(asked))
+      throw new QueryError(`Unknown locale "${asked}"`);
+    const locale = localization ? asked ?? localization.defaultLocale ?? null : null;
+    const text3 = query.trim().slice(0, 200);
+    const empty = { hits: [], total: 0, page, limit, hasNextPage: false };
+    if (!text3 || collections.length === 0) return empty;
+    const { collections: _, limit: __, page: ___, ...read2 } = options;
+    const { hits, total } = await index.search(
+      { query: text3, collections, locale, limit, offset: (page - 1) * limit },
+      async (collection2, ids) => (await this.find(collection2, {
+        ...read2,
+        ...locale ? { locale } : {},
+        where: { id: { in: ids.map((id) => parseId(id) ?? id) } },
+        limit: ids.length,
+        draft: false
+      })).docs
+    );
+    return { hits, total, page, limit, hasNextPage: page * limit < total };
+  }
+  /**
+   * Builds the search index again from the database, for every searchable collection or one:
+   * after adding `search` to a collection, changing its fields, or to repair the index
+   * (`easy-cms search:reindex`).
+   */
+  async reindexSearch(collection2) {
+    if (!this.searchIndex) throw new QueryError("Search needs a `search` adapter in the config");
+    return this.searchIndex.reindex(collection2);
+  }
+  /** @internal Builds an in-memory search index (`ephemeral`) when the CMS starts. */
+  startSearch() {
+    this.searchIndex?.start();
+  }
+  /** Published documents of a collection in a locale, a page at a time, for the search index. */
+  async *publishedPages(collection2, locale) {
+    const options = {
+      draft: false,
+      depth: 0,
+      limit: 100,
+      sort: "id",
+      ...locale ? { locale } : {}
+    };
+    if (this.db.findAfter) {
+      let cursor = "";
+      for (; ; ) {
+        const found = await this.find(collection2, { ...options, cursor });
+        yield found.docs;
+        if (!found.nextCursor) return;
+        cursor = found.nextCursor;
+      }
+    }
+    for (let page = 1; ; page++) {
+      const found = await this.find(collection2, { ...options, page, count: false });
+      yield found.docs;
+      if (!found.hasNextPage) return;
+    }
+  }
+  /** @internal Puts a failed outbox entry back in line (Settings → Jobs). */
+  retryOutbox(id) {
+    return this.outbox?.retry(id) ?? Promise.resolve(false);
+  }
   async destroy() {
     if (this.schedulerTimer) clearInterval(this.schedulerTimer);
     await this.running;
+    await this.outbox?.flush();
+    await this.searchIndex?.flush();
     await this.webhooks.flush();
     await this.mailer.flush();
     await this.db.destroy();
@@ -7873,7 +8570,8 @@ var EasyCMS = class {
         scheduled,
         webhooks: await this.retryWebhooks(now),
         emails: await this.mailer.retry(now),
-        jobs: await this.runConfigJobs(now)
+        jobs: await this.runConfigJobs(now),
+        outbox: await this.outbox?.run(now) ?? { ran: 0, failed: 0 }
       };
       const ranAt = (/* @__PURE__ */ new Date()).toISOString();
       await this.db.updateGlobal({ slug: JOBS_RAN, data: { at: ranAt, updatedAt: ranAt } }).catch((error) => this.logger.error(`Jobs: ${error.message}`, { error }));
@@ -8605,18 +9303,20 @@ var EasyCMS = class {
     if (password !== void 0) prepared.passwordHash = await hashPassword(password);
     if (collection2 === MEDIA_FOLDERS) await this.validateFolder(prepared, void 0);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const doc = await this.db.create({
-      collection: collection2,
-      data: { ...prepared, createdAt: now, updatedAt: now }
-    });
+    const row = { ...prepared, createdAt: now, updatedAt: now };
+    const outbox = this.outboxRow(config, "create", hookGuard ?? guard, row);
+    const doc = await this.db.create({ collection: collection2, data: row, outbox });
     if (collection2 === MEDIA_FOLDERS) this.folders.invalidate();
     await this.saveVersion(config, collectionParent(collection2), doc.id, doc, guard);
-    await this.notify(config.hooks?.afterChange, "afterChange", collection2, {
-      ...base,
-      doc,
-      operation: "create"
-    });
-    this.emitChange(config, "create", doc);
+    if (outbox) this.outbox?.kick();
+    else {
+      await this.notify(config.hooks?.afterChange, "afterChange", collection2, {
+        ...base,
+        doc,
+        operation: "create"
+      });
+      this.emitChange(config, "create", doc);
+    }
     await this.audited(config, "create", doc, void 0, hookGuard ?? guard);
     const [out] = await this.output(config, [doc], hookGuard ?? guard, { ...options, draft: true });
     return out;
@@ -8674,23 +9374,25 @@ var EasyCMS = class {
     });
   }
   /**
-   * `httpCache.purge`: what readers see changed (anything, without drafts; with drafts, a
-   * published document saved, published, unpublished or deleted). Not awaited; failures are
-   * logged.
+   * The tags `httpCache.purge` gets for a change: what readers see changed (anything, without
+   * drafts; with drafts, a published document saved, published, unpublished or deleted).
    */
-  purgePublic(config, isGlobal, event, doc, before) {
-    const purge = this.config.httpCache?.purge;
-    if (!purge || config.httpCache === false || event === "draft") return;
+  purgeTags(config, event, doc, before) {
+    if (!this.config.httpCache?.purge || config.httpCache === false || event === "draft") return;
     if (config.drafts && doc.status !== "published" && before !== "published") return;
-    const tags = isGlobal ? cacheTags.global(config.slug) : cacheTags.document(config.slug, doc.id);
-    void Promise.resolve().then(() => purge(tags)).catch(
-      (error) => this.logger.error(`httpCache.purge failed: ${error.message}`, { error })
-    );
+    return this.isGlobal(config) ? cacheTags.global(config.slug) : cacheTags.document(config.slug, doc.id);
   }
-  /** Sends webhook events for a change; `before` is the stored status before it, if any. */
-  emitChange(config, event, doc, before) {
-    const isGlobal = !this.config.collections.includes(config);
-    if (!isGlobal && INTERNAL_COLLECTIONS.has(config.slug)) return;
+  /** Whether a change may change what the search index holds: a save of the document itself. */
+  searches(config, event) {
+    return event !== "draft" && !this.isGlobal(config) && !!this.searchIndex?.configOf(config.slug);
+  }
+  isGlobal(config) {
+    return !this.config.collections.includes(config);
+  }
+  /** The webhook events of a change; `before` is the stored status before it, if any. */
+  changeEvents(config, event, doc, before) {
+    const isGlobal = this.isGlobal(config);
+    if (!isGlobal && INTERNAL_COLLECTIONS.has(config.slug)) return [];
     const body = isGlobal ? { ...snapshotOf(config.fields, doc), updatedAt: doc.updatedAt } : {
       id: doc.id,
       ...snapshotOf(config.fields, doc),
@@ -8698,13 +9400,82 @@ var EasyCMS = class {
       updatedAt: doc.updatedAt
     };
     const target = isGlobal ? { global: config.slug } : { collection: config.slug, id: doc.id };
-    this.webhooks.emit(event, target, body);
-    this.purgePublic(config, isGlobal, event, doc, before);
-    if (event === "draft" || event === "delete" || !config.drafts) return;
+    const events = [{ event, target, body }];
+    if (event === "draft" || event === "delete" || !config.drafts) return events;
     const after = doc.status;
-    if (after === "published" && before !== "published") this.webhooks.emit("publish", target, body);
+    if (after === "published" && before !== "published")
+      events.push({ event: "publish", target, body });
     if (after !== "published" && before === "published")
-      this.webhooks.emit("unpublish", target, body);
+      events.push({ event: "unpublish", target, body });
+    return events;
+  }
+  /**
+   * Sends webhook events for a change and purges the HTTP cache. Not awaited; purge failures
+   * are logged.
+   */
+  emitChange(config, event, doc, before) {
+    for (const change of this.changeEvents(config, event, doc, before))
+      this.webhooks.emit(change.event, change.target, change.body);
+    if (this.searches(config, event)) this.searchIndex?.syncLater(config.slug, doc.id);
+    const purge = this.config.httpCache?.purge;
+    const tags = this.purgeTags(config, event, doc, before);
+    if (!purge || !tags) return;
+    void Promise.resolve().then(() => purge(tags)).catch(
+      (error) => this.logger.error(`httpCache.purge failed: ${error.message}`, { error })
+    );
+  }
+  /**
+   * The outbox row of a save (`outbox: true`): written in its transaction, then run by the outbox
+   * in place of its after hooks and events. `undefined` without the outbox, or with nothing to run.
+   */
+  outboxRow(config, event, guard, doc, extra = {}) {
+    if (!this.outbox) return void 0;
+    const hooks = event === "delete" ? config.hooks?.afterDelete : config.hooks?.afterChange;
+    const isGlobal = this.isGlobal(config);
+    const effects = (isGlobal || !INTERNAL_COLLECTIONS.has(config.slug)) && ((this.config.webhooks?.length ?? 0) > 0 || this.config.httpCache?.purge !== void 0);
+    if (!hooks?.length && !effects && !this.searches(config, event)) return void 0;
+    return this.outbox.row({
+      event,
+      target: config.slug,
+      global: isGlobal,
+      docId: extra.docId,
+      before: typeof extra.before === "string" ? extra.before : null,
+      doc,
+      previousDoc: extra.previousDoc,
+      user: guard.user
+    });
+  }
+  /** Runs an outbox entry: what its save would have run right after it, without the outbox. */
+  async runOutbox(entry, done, mark) {
+    const config = entry.global ? this.config.globals.find((g) => g.slug === entry.target) : this.config.collections.find((c) => c.slug === entry.target);
+    if (!config) return;
+    const { doc, event } = entry;
+    if (!done.has("hooks")) {
+      const base = this.hookArgs(config, { enforce: false, user: entry.user, context: {} });
+      const hooks = event === "delete" ? config.hooks?.afterDelete : config.hooks?.afterChange;
+      const args = event === "delete" ? { ...base, id: parseId(entry.docId ?? void 0), doc } : {
+        ...base,
+        doc,
+        ...entry.previousDoc ? { previousDoc: entry.previousDoc } : {},
+        operation: event === "create" ? "create" : "update"
+      };
+      for (const hook of hooks ?? [])
+        await hook(args);
+      if (hooks?.length) await mark("hooks");
+    }
+    if (!done.has("webhooks")) {
+      const changes = this.changeEvents(config, event, doc, entry.before);
+      for (const change of changes)
+        await this.webhooks.emitSaved(change.event, change.target, change.body);
+      if (changes.length > 0 && (this.config.webhooks?.length ?? 0) > 0) await mark("webhooks");
+    }
+    if (!done.has("search") && this.searchIndex && this.searches(config, event)) {
+      await this.searchIndex.sync(config.slug, parseId(entry.docId ?? void 0));
+      await mark("search");
+    }
+    const purge = this.config.httpCache?.purge;
+    const tags = this.purgeTags(config, event, doc, entry.before);
+    if (purge && tags) await purge(tags);
   }
   /**
    * Writes the audit log entry for a change (`audit`): publishing, unpublishing and restoring
@@ -8735,7 +9506,7 @@ var EasyCMS = class {
     );
   }
   /** Records a version after a save, when the collection or global keeps versions. */
-  async saveVersion(config, parent, id, doc, guard) {
+  async saveVersion(config, parent, id, doc, guard, outbox) {
     const max = versionLimit(config);
     if (max === void 0) return;
     await this.versions.save({
@@ -8744,7 +9515,8 @@ var EasyCMS = class {
       status: config.drafts ? doc.status ?? "draft" : null,
       snapshot: snapshotOf(config.fields, doc),
       author: guard.user?.id ?? null,
-      max
+      max,
+      outbox
     });
   }
   hookArgs(config, guard) {
@@ -9173,7 +9945,7 @@ function readCursor(cursor, query) {
 // src/rest/admin-jobs.ts
 var has = (config, slug2) => config.collections.some((c) => c.slug === slug2);
 function hasJobsPage(config) {
-  return config.jobs.length > 0 || has(config, SCHEDULED_JOBS);
+  return config.jobs.length > 0 || has(config, SCHEDULED_JOBS) || has(config, OUTBOX);
 }
 var text2 = (value) => typeof value === "string" && value !== "" ? value : null;
 async function adminJobs(cms, user) {
@@ -9206,6 +9978,7 @@ async function adminJobs(cms, user) {
     ...has(config, SCHEDULED_JOBS) ? ["scheduled"] : [],
     ...has(config, WEBHOOK_DELIVERIES) ? ["webhooks"] : [],
     ...has(config, EMAIL_DELIVERIES) ? ["emails"] : [],
+    ...has(config, OUTBOX) ? ["outbox"] : [],
     ...config.backups?.frequency ? ["backups"] : [],
     ...config.audit ? ["audit"] : []
   ];
@@ -9214,7 +9987,8 @@ async function adminJobs(cms, user) {
     lastRanAt: await cms.jobsLastRan(),
     builtIn,
     timeZone: config.timeZone ?? null,
-    canChange: isSystemAdmin(user)
+    canChange: isSystemAdmin(user),
+    outbox: has(config, OUTBOX) ? await adminOutbox(cms) : null
   };
   if (!has(config, SCHEDULED_JOBS)) return { ...head, scheduled: null };
   const { docs } = await cms.db.find({
@@ -9239,6 +10013,38 @@ async function adminJobs(cms, user) {
   });
   return { ...head, scheduled };
 }
+async function adminOutbox(cms) {
+  const count = (state) => cms.db.count({ collection: OUTBOX, where: { state: { in: state } } });
+  const { docs } = await cms.db.find({
+    collection: OUTBOX,
+    where: { attempts: { gt: 0 } },
+    sort: ["-updatedAt"],
+    limit: 100,
+    page: 1
+  });
+  return {
+    waiting: await count(["pending", "running"]),
+    failed: await count(["failed"]),
+    entries: docs.filter((row) => text2(row.error) !== null).map((row) => ({
+      id: row.id,
+      event: row.event,
+      ...row.global === true ? { global: String(row.target) } : { collection: String(row.target) },
+      doc: text2(row.docId),
+      attempts: Number(row.attempts ?? 0),
+      state: row.state === "failed" || row.state === "running" ? row.state : "pending",
+      error: text2(row.error),
+      nextAttemptAt: String(row.nextAttemptAt)
+    }))
+  };
+}
+async function retryOutbox(cms, user, id) {
+  if (!isSystemAdmin(user)) throw new ForbiddenError();
+  if (!has(cms.config, OUTBOX)) throw new NotFoundError(OUTBOX, id);
+  const row = await cms.db.findById({ collection: OUTBOX, id: parseId(id) ?? 0 });
+  if (!row) throw new NotFoundError(OUTBOX, id);
+  if (!await cms.retryOutbox(row.id))
+    throw new EasyCMSError("Only failed entries can be retried", 409);
+}
 var TIME_OF_DAY2 = /^([01]\d|2[0-3]):[0-5]\d$/;
 async function updateJob(cms, user, name, body) {
   if (!isSystemAdmin(user)) throw new ForbiddenError();
@@ -9945,7 +10751,7 @@ async function readAdminModule(cms, index) {
 }
 
 // src/version.ts
-var VERSION = true ? "1.11.0" : "0.0.0-dev";
+var VERSION = true ? "1.13.0" : "0.0.0-dev";
 
 // src/rest/handler.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -9955,7 +10761,7 @@ var PER_PAGE = 50;
 var collectionOf = (kind) => kind === "webhook" ? WEBHOOK_DELIVERIES : EMAIL_DELIVERIES;
 var exists = (cms, kind) => cms.config.collections.some((c) => c.slug === collectionOf(kind));
 var isDeliveryKind = (value) => value === "webhook" || value === "email";
-function parse2(text3) {
+function parse3(text3) {
   try {
     const value = JSON.parse(String(text3 ?? ""));
     return typeof value === "object" && value !== null ? value : {};
@@ -9974,7 +10780,7 @@ function toAdmin2(kind, row) {
     nextAttemptAt: String(row.nextAttemptAt ?? "")
   };
   if (kind === "webhook") {
-    const payload = parse2(row.body);
+    const payload = parse3(row.body);
     return {
       ...base,
       kind,
@@ -9986,7 +10792,7 @@ function toAdmin2(kind, row) {
       body: String(row.body ?? "")
     };
   }
-  const message2 = parse2(row.message);
+  const message2 = parse3(row.message);
   const to = message2.to;
   return {
     ...base,
@@ -10611,9 +11417,17 @@ async function adminSearch(cms, who, q, perCollection = 5) {
       const conditions = [];
       if (title) conditions.push({ [title]: { like: query } });
       if (/^\d+$/.test(query)) conditions.push({ id: { equals: Number(query) } });
-      if (conditions.length === 0 || !await readable(cms, c, who)) return [];
+      const indexed = cms.config.search !== void 0 && c.search !== void 0;
+      if (conditions.length === 0 && !indexed || !await readable(cms, c, who)) return [];
       try {
-        const found = await cms.find(c.slug, {
+        const ranked = indexed ? (await cms.search(query, {
+          ...who,
+          overrideAccess: false,
+          depth: 0,
+          limit: perCollection,
+          collections: [c.slug]
+        })).hits.map((hit) => hit.doc) : [];
+        const found = conditions.length === 0 ? { docs: [] } : await cms.find(c.slug, {
           ...who,
           overrideAccess: false,
           draft: true,
@@ -10622,7 +11436,9 @@ async function adminSearch(cms, who, q, perCollection = 5) {
           where: conditions.length === 1 ? conditions[0] : { or: conditions },
           sort: "-updatedAt"
         });
-        return found.docs.map((doc) => {
+        const seen = /* @__PURE__ */ new Set();
+        const docs = [...ranked, ...found.docs].filter((doc) => !seen.has(doc.id) && seen.add(doc.id)).slice(0, perCollection);
+        return docs.map((doc) => {
           const d = doc;
           const value = title ? d[title] : void 0;
           return {
@@ -10711,6 +11527,7 @@ async function adminStatus(cms) {
       database: config.db.name,
       storage: config.upload.storage?.name ?? "local",
       email: config.email ? config.email.name ?? "custom" : null,
+      search: config.search ? config.search.name ?? "custom" : null,
       plugins: config.installedPlugins.map((p) => ({ ...p })),
       fieldTypes: config.fieldTypes.map((t) => t.name)
     },
@@ -10719,7 +11536,7 @@ async function adminStatus(cms) {
 }
 
 // src/rest/filter-options.ts
-function fieldAt(fields, path) {
+function fieldAt2(fields, path) {
   let current = fields;
   let found;
   for (const part of path.split(".")) {
@@ -10738,7 +11555,7 @@ async function pickerFilter(cms, url, target, user, context = {}) {
   const dot = spec.indexOf(".");
   const slug2 = dot > 0 ? spec.slice(0, dot) : "";
   const owner = forCollection !== null ? cms.config.collections.find((c) => c.slug === slug2) : cms.config.globals.find((g) => g.slug === slug2);
-  const field = owner ? fieldAt(owner.fields, spec.slice(dot + 1)) : void 0;
+  const field = owner ? fieldAt2(owner.fields, spec.slice(dot + 1)) : void 0;
   const to = field?.type === "upload" ? "media" : field?.type === "relationship" ? field.to : null;
   if (!field || field.type !== "relationship" && field.type !== "upload" || to !== target)
     throw new QueryError(`filterFor: no relationship to "${target}" at "${spec}"`);
@@ -11503,6 +12320,13 @@ async function route(cms, ctx, method, path, options) {
       await cms.audit.record({ action: "jobs.run", target: "jobs", detail: result });
       return { body: result };
     }
+    if (third === "outbox" && segments.length === 4) {
+      if (method !== "POST") throw methodNotAllowed(ctx, "POST");
+      const id2 = segments[3];
+      await retryOutbox(cms, ctx.user, id2);
+      await cms.audit.record({ action: "jobs.outbox.retry", target: "jobs", detail: { id: id2 } });
+      return { body: await adminJobs(cms, ctx.user) };
+    }
     if (third !== void 0 && segments.length === 3) {
       if (method !== "PATCH") throw methodNotAllowed(ctx, "PATCH");
       const { action, detail } = await updateJob(
@@ -11659,6 +12483,19 @@ async function route(cms, ctx, method, path, options) {
     );
     return { status: 201, body: { ...doc, key } };
   }
+  if (first === "search" && second === void 0 && cms.config.search) {
+    if (method !== "GET") throw methodNotAllowed(ctx, "GET");
+    const q = ctx.url.searchParams;
+    const collections = q.get("collections");
+    return {
+      body: await cms.search(q.get("q") ?? "", {
+        ...access,
+        ...parseDepth(ctx.url),
+        ...pageQuery(q, 10),
+        ...collections ? { collections: collections.split(",").filter(Boolean) } : {}
+      })
+    };
+  }
   const collection2 = first;
   if (INTERNAL_COLLECTIONS.has(collection2) || !cms.config.collections.some((c) => c.slug === collection2)) {
     throw new HttpError(`Unknown collection "${collection2}"`, 404);
@@ -12378,6 +13215,7 @@ export {
   Roles,
   checkRenamedOptions,
   BUILTIN_NAV,
+  memorySearch,
   WEBHOOK_EVENTS,
   MIN_SECRET_LENGTH,
   BUILTIN_COLLECTIONS,