mindoodb-app-sdk 0.0.65 → 0.0.67

package/dist/testing/index.js

@@ -4,7 +4,7 @@ import {
   mindooDBAppComponentFieldsMatch,
   pageUsers,
   releaseMindooDBAppBridgeSessions
-} from "../chunk-BE7LLFFE.js";
+} from "../chunk-376SABPG.js";
 
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
@@ -458,17 +458,40 @@ async function createEvaluatingViewNavigator(input, documents) {
 }
 
 // src/testing/mockEmbeds.ts
-function createMockEmbedHost(options, getDatabase) {
+function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
   let components = [...options.components ?? []];
   const embeds = /* @__PURE__ */ new Map();
   const handles = /* @__PURE__ */ new Map();
   const closedListeners = /* @__PURE__ */ new Set();
   const dirtyListeners = /* @__PURE__ */ new Set();
+  const toolListeners = /* @__PURE__ */ new Set();
+  const toolNames = /* @__PURE__ */ new Map();
   let nextSaveError = null;
   let embeddingDirty;
   let saveRequestHandler = null;
   let embedCounter = 0;
   let embeddingFinish = null;
+  const accessRequests = [];
+  const grantedAccess = /* @__PURE__ */ new Set();
+  const pendingAccess = /* @__PURE__ */ new Set();
+  async function requestAccess(input) {
+    accessRequests.push(structuredClone(input));
+    const pairs = (input.components ?? []).flatMap(
+      (entry) => components.some((component) => component.key === entry.componentKey) ? (entry.databaseIds ?? listDatabaseIds()).filter((databaseId) => listDatabaseIds().includes(databaseId)).map((databaseId) => ({ componentKey: entry.componentKey, databaseId })) : []
+    );
+    const pairKey = (pair) => `${pair.componentKey}/${pair.databaseId}`;
+    const ask = pairs.filter((pair) => !grantedAccess.has(pairKey(pair)) && !pendingAccess.has(pairKey(pair)));
+    if (ask.length) {
+      const allowed = new Set((await (options.embedAccess?.(structuredClone(ask)) ?? ask)).map(pairKey));
+      for (const pair of ask) {
+        (allowed.has(pairKey(pair)) ? grantedAccess : pendingAccess).add(pairKey(pair));
+      }
+    }
+    return {
+      granted: pairs.filter((pair) => grantedAccess.has(pairKey(pair))),
+      pending: pairs.filter((pair) => !grantedAccess.has(pairKey(pair)))
+    };
+  }
   function notifyChange() {
     options.onEmbedChange?.([...embeds.values()].map((entry) => ({ ...entry, rect: { ...entry.rect } })));
   }
@@ -504,11 +527,49 @@ function createMockEmbedHost(options, getDatabase) {
       docId: input.docId,
       intent,
       rect: mockRect(input),
-      visible: input.visible !== false
+      visible: input.visible !== false,
+      active: false,
+      agentTools: null
     });
-    notifyChange();
+    setActive(embedId);
     return embedId;
   }
+  function toolPrefix(component) {
+    return component.appId.replace(/^mindoodb-app-/, "").replace(/[^a-z0-9_]/g, "_") || "app";
+  }
+  function publishTools(entry) {
+    const declared = toolNames.get(entry.embedId);
+    const prefix = toolPrefix(entry.component);
+    const next = declared?.names.length ? { prefix, names: declared.names.map((name) => `${prefix}_${name}`), active: entry.active, enabled: declared.enabled } : null;
+    if (JSON.stringify(next) === JSON.stringify(entry.agentTools)) {
+      return;
+    }
+    entry.agentTools = next;
+    handles.get(entry.embedId)?.setAgentToolsState(next);
+    toolListeners.forEach((listener) => listener({ embedId: entry.embedId, agentTools: next }));
+  }
+  function setActive(embedId) {
+    const target = embeds.get(embedId);
+    if (!target) {
+      return;
+    }
+    for (const entry of embeds.values()) {
+      if (entry.component.appId === target.component.appId) {
+        entry.active = entry.embedId === embedId;
+        publishTools(entry);
+      }
+    }
+    notifyChange();
+  }
+  function setEmbedAgentTools(embedId, names, toolOptions = {}) {
+    const entry = embeds.get(embedId);
+    if (!entry) {
+      return;
+    }
+    toolNames.set(embedId, { names: [...names ?? []], enabled: toolOptions.enabled !== false });
+    publishTools(entry);
+    notifyChange();
+  }
   function closeEmbed(embedId, reason = "closed", result) {
     if (!embeds.delete(embedId)) {
       return;
@@ -520,6 +581,7 @@ function createMockEmbedHost(options, getDatabase) {
     };
     handles.get(embedId)?.settle(event);
     handles.delete(embedId);
+    toolNames.delete(embedId);
     closedListeners.forEach((listener) => listener(event));
     notifyChange();
   }
@@ -558,6 +620,39 @@ function createMockEmbedHost(options, getDatabase) {
     async save() {
       await saveEmbed(this.embedId);
     }
+    agentTools = null;
+    toolsListeners = /* @__PURE__ */ new Set();
+    async setActive() {
+      setActive(this.embedId);
+    }
+    onAgentToolsChange(listener) {
+      this.toolsListeners.add(listener);
+      return () => {
+        this.toolsListeners.delete(listener);
+      };
+    }
+    setAgentToolsState(tools) {
+      this.agentTools = tools;
+      this.toolsListeners.forEach((listener) => listener(tools));
+    }
+    waitForAgentTools(timeoutMs = 1e4) {
+      if (this.agentTools?.names.length) {
+        return Promise.resolve(this.agentTools);
+      }
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          stop();
+          resolve(null);
+        }, timeoutMs);
+        const stop = this.onAgentToolsChange((tools) => {
+          if (tools?.names.length) {
+            clearTimeout(timer);
+            stop();
+            resolve(tools);
+          }
+        });
+      });
+    }
     resolve;
     listeners = /* @__PURE__ */ new Set();
     settled = null;
@@ -637,7 +732,8 @@ function createMockEmbedHost(options, getDatabase) {
         const handle = new MockEmbed(embedId, input.componentKey, input.databaseId, input.docId);
         handles.set(embedId, handle);
         return handle;
-      }
+      },
+      requestAccess
     },
     embedding: {
       async complete(result) {
@@ -652,6 +748,9 @@ function createMockEmbedHost(options, getDatabase) {
       async setDirty(dirty) {
         embeddingDirty = dirty === true;
       },
+      async lookup(field2, lookupOptions) {
+        return structuredClone(await (options.embeddingLookup?.(field2, { ...lookupOptions }) ?? []));
+      },
       onSaveRequest(handler) {
         saveRequestHandler = handler;
         return () => {
@@ -671,6 +770,12 @@ function createMockEmbedHost(options, getDatabase) {
     setComponents(next) {
       components = [...next];
     },
+    getAccessRequests() {
+      return structuredClone(accessRequests);
+    },
+    getGrantedAccess() {
+      return [...grantedAccess];
+    },
     getEmbeddingFinish() {
       return embeddingFinish;
     },
@@ -684,6 +789,14 @@ function createMockEmbedHost(options, getDatabase) {
       };
     },
     setEmbedDirty,
+    setActive,
+    setEmbedAgentTools,
+    onAgentTools(listener) {
+      toolListeners.add(listener);
+      return () => {
+        toolListeners.delete(listener);
+      };
+    },
     onDirty(listener) {
       dirtyListeners.add(listener);
       return () => {
@@ -828,6 +941,44 @@ function guardDatabase(database, currentInfo, enforce) {
   };
 }
 
+// src/testing/configuredViews.ts
+var field = (path) => ({ kind: "field", path });
+var literal = (value) => ({ kind: "literal", value });
+var operation = (op, args) => ({ kind: "operation", op, args });
+function ruleExpression(rule) {
+  const target = field(rule.field);
+  switch (rule.operator) {
+    case "notContains":
+      return operation("not", [operation("contains", [target, literal(rule.value ?? "")])]);
+    case "exists":
+    case "notExists":
+      return operation(rule.operator, [target]);
+    default:
+      return operation(rule.operator, [target, literal(rule.value ?? "")]);
+  }
+}
+function configuredViewDefinition(view2) {
+  const filter = view2.filter.mode === "formula" ? { mode: "expression", expression: structuredClone(view2.filter.expression) } : view2.filter.rules.length ? {
+    mode: "expression",
+    expression: view2.filter.rules.length === 1 ? ruleExpression(view2.filter.rules[0]) : operation(view2.filter.match === "all" ? "and" : "or", view2.filter.rules.map(ruleExpression))
+  } : void 0;
+  return {
+    id: view2.id,
+    title: view2.description?.trim() || view2.id,
+    ...filter ? { filter } : {},
+    defaultExpand: "collapsed",
+    columns: view2.columns.map((column) => ({
+      name: column.name,
+      title: column.title,
+      role: column.role === "sort" ? "display" : column.role,
+      expression: column.expression.mode === "field" ? field(column.expression.field) : structuredClone(column.expression.expression),
+      sorting: column.sorting,
+      hidden: column.hidden,
+      totalMode: column.totalMode
+    }))
+  };
+}
+
 // src/testing/mockAgentTools.ts
 var TOOL_NAME_PATTERN = /^[a-z][a-z0-9_]{0,47}$/;
 var PREFIX_PATTERN = /^[a-z][a-z0-9_]{0,15}$/;
@@ -877,11 +1028,15 @@ function validateMockAgentTools(raw) {
         throw invalid(`Agent tool "${tool.name}" has invalid annotations.`);
       }
     }
+    if (tool.scope !== void 0 && tool.scope !== "app" && tool.scope !== "document") {
+      throw invalid(`Agent tool "${tool.name}" has an invalid scope; use "app" or "document".`);
+    }
     return {
       name: tool.name,
       description: tool.description,
       inputSchema: schema,
-      ...tool.annotations ? { annotations: { ...tool.annotations } } : {}
+      ...tool.annotations ? { annotations: { ...tool.annotations } } : {},
+      ...tool.scope ? { scope: tool.scope } : {}
     };
   });
 }
@@ -934,7 +1089,7 @@ function createMockAgentHost(options) {
   async function dispatch(method, params) {
     const input = params ?? {};
     if (method === "agent.registerTools") {
-      tools = validateMockAgentTools(input.tools);
+      tools = validateMockAgentTools(input.tools).filter((tool) => !options.embedded?.() || tool.scope === "document");
       changed();
       return { result: registration() };
     }
@@ -1078,6 +1233,10 @@ function concat(chunks) {
   }
   return bytes;
 }
+var MEMORY_ATTACHMENTS = /* @__PURE__ */ Symbol.for("mindoodb-app-sdk.memoryAttachments");
+function isMemoryAttachments(value) {
+  return !!value && typeof value === "object" && MEMORY_ATTACHMENTS in value;
+}
 function createMemoryAttachments() {
   const files = /* @__PURE__ */ new Map();
   const forDoc = (docId) => {
@@ -1085,7 +1244,7 @@ function createMemoryAttachments() {
     if (!map) files.set(docId, map = /* @__PURE__ */ new Map());
     return map;
   };
-  return {
+  const api = {
     async list(docId) {
       return [...forDoc(docId)].map(
         ([fileName, file]) => ({
@@ -1132,6 +1291,131 @@ function createMemoryAttachments() {
       };
     }
   };
+  return Object.assign(api, { [MEMORY_ATTACHMENTS]: true });
+}
+
+// src/testing/twoUserTestHost.ts
+var DEFAULT_TEST_HOST_USERS = [
+  { name: "Anna", username: "CN=Anna Test/O=Test" },
+  { name: "Ben", username: "CN=Ben Test/O=Test" }
+];
+var STYLE = `
+.htu{display:grid;grid-template-rows:auto 1fr;height:100vh;margin:0;font:13px/1.45 system-ui,sans-serif;background:#eef1f7;color:#172033}
+.htu *{box-sizing:border-box}
+.htu__bar{display:flex;gap:10px;align-items:center;flex-wrap:wrap;padding:8px 12px;border-bottom:1px solid #d7dce8;background:#f8f9fc}
+.htu__badge{padding:2px 8px;border-radius:999px;background:#fde68a;color:#713f12;font-weight:600;font-size:11px;letter-spacing:.04em}
+.htu button{font:inherit;padding:5px 12px;border-radius:7px;border:1px solid #c9d0e0;background:#fff;cursor:pointer}
+.htu__status{font-weight:600}
+.htu .htest__mode{display:flex;gap:8px;align-items:center;padding:0 8px;border-left:1px solid #d7dce8;border-right:1px solid #d7dce8}
+.htu__panes{display:grid;grid-template-columns:1fr 1fr;gap:1px;background:#d7dce8;min-height:0}
+.htu__pane{display:grid;grid-template-rows:auto 1fr;min-height:0;background:#fff}
+.htu__pane h2{margin:0;padding:4px 10px;font-size:12px;letter-spacing:.06em;text-transform:uppercase;color:#5b6478;background:#f8f9fc;border-bottom:1px solid #e4e8f1}
+.htu iframe{width:100%;height:100%;border:0}
+@media (max-width:900px){.htu__panes{grid-template-columns:1fr;grid-template-rows:1fr 1fr}}
+`;
+function replicaOf(databases) {
+  return databases.map((database) => ({
+    ...database,
+    automerge: true,
+    info: structuredClone(database.info),
+    documents: database.documents ? structuredClone(database.documents) : void 0,
+    ...database.methods ? {
+      methods: {
+        ...database.methods,
+        ...isMemoryAttachments(database.methods.attachments) ? { attachments: createMemoryAttachments() } : {}
+      }
+    } : {}
+  }));
+}
+function mountTwoUserTestHost(options, createHost) {
+  const { container = document.body, title = "Haven test host", users = DEFAULT_TEST_HOST_USERS, ...hostOptions } = options;
+  const style = document.createElement("style");
+  style.textContent = STYLE;
+  document.head.append(style);
+  if (container === document.body) document.body.style.margin = "0";
+  const root = document.createElement("div");
+  root.className = "htu";
+  const bar = document.createElement("div");
+  bar.className = "htu__bar";
+  const badge = document.createElement("span");
+  badge.className = "htu__badge";
+  badge.textContent = `TEST HOST \xB7 TWO USERS \xB7 ${title}`;
+  const syncButton = document.createElement("button");
+  syncButton.type = "button";
+  syncButton.textContent = "Sync";
+  syncButton.dataset.testid = "haven-two-users-sync";
+  const auto = document.createElement("label");
+  const autoBox = document.createElement("input");
+  autoBox.type = "checkbox";
+  autoBox.checked = true;
+  autoBox.dataset.testid = "haven-two-users-autosync";
+  auto.append(autoBox, " Auto-sync every 2 s");
+  const status = document.createElement("span");
+  status.className = "htu__status";
+  status.dataset.testid = "haven-two-users-status";
+  bar.append(badge, modeSwitch("two"), syncButton, auto, status);
+  const panes = document.createElement("div");
+  panes.className = "htu__panes";
+  root.append(bar, panes);
+  container.replaceChildren(root);
+  const databasesA = (hostOptions.databases ?? []).map((database) => ({ ...database, automerge: true }));
+  const hosts = users.map((user, index) => {
+    const pane = document.createElement("section");
+    pane.className = "htu__pane";
+    const heading = document.createElement("h2");
+    heading.textContent = `${user.name} \u2014 replica ${index + 1}`;
+    const frame = document.createElement("iframe");
+    frame.title = `${title} as ${user.name}`;
+    frame.dataset.testid = `haven-two-users-frame-${index + 1}`;
+    pane.append(heading, frame);
+    panes.append(pane);
+    const launchContext = {
+      ...hostOptions.launchContext,
+      user: { id: `test-user-${index + 1}`, username: user.username }
+    };
+    return createHost({
+      ...hostOptions,
+      frame,
+      launchContext,
+      databases: index === 0 ? databasesA : replicaOf(databasesA),
+      // distinct Automerge actors: the two replicas write concurrently
+      automergeActor: index === 0 ? "a11ce000000000000000000000000001" : "b0b00000000000000000000000000002"
+    });
+  });
+  let lastSync = null;
+  const describe = () => {
+    const open = mockReplicaDifferences(hosts[0].host, hosts[1].host);
+    status.textContent = `${open ? `\u26A0 ${open} document(s) not synced` : "\u2713 in sync"} \xB7 last sync ${lastSync ?? "never"}`;
+    status.style.color = open ? "#b45309" : "#15803d";
+  };
+  let syncing = null;
+  const sync = () => {
+    syncing ??= syncMockReplicas(hosts[0].host, hosts[1].host).finally(() => {
+      syncing = null;
+      lastSync = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      describe();
+    });
+    return syncing;
+  };
+  syncButton.addEventListener("click", () => void sync());
+  let timer;
+  const setAutoSync = (on) => {
+    autoBox.checked = on;
+    if (timer) clearInterval(timer);
+    timer = on ? setInterval(() => void sync(), 2e3) : void 0;
+  };
+  autoBox.addEventListener("change", () => setAutoSync(autoBox.checked));
+  setAutoSync(true);
+  setInterval(describe, 500);
+  describe();
+  const handle = {
+    hosts,
+    sync,
+    setAutoSync,
+    differences: () => mockReplicaDifferences(hosts[0].host, hosts[1].host)
+  };
+  window.__havenTwoUsers = handle;
+  return handle;
 }
 
 // src/testing/browserTestHost.ts
@@ -1426,7 +1710,7 @@ var TEST_HOST_LOCALES = [
   { tag: "he-IL", label: "\u05E2\u05D1\u05E8\u05D9\u05EA" }
 ];
 var DIRECTORY_SIZES = [0, 5, 25, 120, 500];
-var STYLE = `
+var STYLE2 = `
 .htest{display:grid;grid-template-columns:minmax(0,1fr) 320px;height:100vh;margin:0;font:13px/1.45 system-ui,sans-serif;background:#eef1f7;color:#172033}
 .htest *{box-sizing:border-box}
 .htest__frame{width:100%;height:100%;border:0;background:#fff}
@@ -1494,12 +1778,40 @@ function item(text) {
   li.textContent = text;
   return li;
 }
+function modeSwitch(current) {
+  const row = document.createElement("div");
+  row.className = "htest__row htest__mode";
+  row.dataset.testid = "haven-test-mode";
+  for (const [mode, label] of [
+    ["single", "Single user"],
+    ["two", "Two users"]
+  ]) {
+    const url = new URL(window.location.href);
+    if (mode === "two") url.searchParams.set("twoUsers", "1");
+    else url.searchParams.delete("twoUsers");
+    if (mode === current) {
+      const active = document.createElement("strong");
+      active.textContent = label;
+      active.setAttribute("aria-current", "page");
+      row.append(active);
+    } else {
+      const link = document.createElement("a");
+      link.href = url.toString();
+      link.textContent = label;
+      link.dataset.testid = `haven-test-mode-${mode}`;
+      row.append(link);
+    }
+  }
+  return row;
+}
 function mountHavenTestHost(options) {
   const {
     container = document.body,
     title = "Haven test host",
     locales = TEST_HOST_LOCALES,
     urlSettings: useUrl = true,
+    twoUsers = false,
+    users,
     ...hostOptions
   } = options;
   const url = useUrl ? readTestHostUrlSettings(window.location.search) : { overrides: {} };
@@ -1512,8 +1824,17 @@ function mountHavenTestHost(options) {
     ...url.locale ? { locale: url.locale } : {},
     ...url.theme ? { theme: { mode: url.theme, preset: "mindoo" } } : {}
   };
+  const twoUsersFromUrl = useUrl && new URLSearchParams(window.location.search).get("twoUsers") === "1";
+  if (twoUsers || twoUsersFromUrl) {
+    const handle = mountTwoUserTestHost(
+      { ...hostOptions, databases, launchContext, container, title, ...users ? { users } : {} },
+      createBrowserTestHost
+    );
+    window.__havenTestHost = handle.hosts[0];
+    return handle.hosts[0];
+  }
   const style = document.createElement("style");
-  style.textContent = STYLE;
+  style.textContent = STYLE2;
   document.head.append(style);
   const root = document.createElement("div");
   root.className = "htest";
@@ -1600,8 +1921,8 @@ function mountHavenTestHost(options) {
       if (override.mapped === false) params.append("db", `${id}:none`);
     }
     if (testHost.host.getEnforceCapabilities()) params.set("enforce", "1");
-    const users = testHost.host.getDirectoryUsers().length;
-    if (users) params.set("users", String(users));
+    const users2 = testHost.host.getDirectoryUsers().length;
+    if (users2) params.set("users", String(users2));
     if (currentLocale) params.set("locale", currentLocale);
     if (initialDark === void 0 || dark !== initialDark) params.set("theme", dark ? "dark" : "light");
     const query = params.toString();
@@ -1731,6 +2052,7 @@ Allow?`),
     }),
     button("Reload app", () => testHost.reloadApp())
   );
+  section("Mode", modeSwitch("single"));
   section("Host", hostRow, focusState);
   const language = document.createElement("select");
   language.dataset.testid = "haven-test-language";
@@ -2083,8 +2405,8 @@ function applyDocumentUpdatePatch(current, patch) {
     applyMockTextPatch(next, textPatch.path, textPatch.edits);
   }
   for (const richTextPatch of patch.richText ?? []) {
-    const spans = richTextPatch.spansSequence?.at(-1) ?? richTextPatch.spans ?? [];
-    setValueAtPath(next, richTextPatch.path, structuredClone(spans));
+    const spans2 = richTextPatch.spansSequence?.at(-1) ?? richTextPatch.spans ?? [];
+    setValueAtPath(next, richTextPatch.path, structuredClone(spans2));
   }
   for (const richTextStepPatch of patch.richTextSteps ?? []) {
     applyMockRichTextSteps(next, richTextStepPatch.path, richTextStepPatch.steps);
@@ -2095,50 +2417,50 @@ function applyMockJsonPatch(target, patch) {
   if (!patch) {
     return;
   }
-  for (const operation of patch.set ?? []) {
-    setValueAtPath(target, operation.path, readMockTypedValues(operation.value));
+  for (const operation2 of patch.set ?? []) {
+    setValueAtPath(target, operation2.path, readMockTypedValues(operation2.value));
   }
-  for (const operation of patch.unset ?? []) {
-    unsetValueAtPath(target, operation.path);
+  for (const operation2 of patch.unset ?? []) {
+    unsetValueAtPath(target, operation2.path);
   }
-  for (const operation of patch.listDelete ?? []) {
-    const list = readListAtPath(target, operation.path);
-    list.splice(operation.index, operation.deleteCount);
+  for (const operation2 of patch.listDelete ?? []) {
+    const list = readListAtPath(target, operation2.path);
+    list.splice(operation2.index, operation2.deleteCount);
   }
-  for (const operation of patch.listInsert ?? []) {
-    const parent = ensureParentAtPath(target, operation.path);
-    const leaf = operation.path[operation.path.length - 1];
+  for (const operation2 of patch.listInsert ?? []) {
+    const parent = ensureParentAtPath(target, operation2.path);
+    const leaf = operation2.path[operation2.path.length - 1];
     if (parent[leaf] == null) {
       parent[leaf] = [];
     }
-    const list = readListAtPath(target, operation.path);
-    list.splice(operation.index, 0, ...readMockTypedValues(operation.values));
+    const list = readListAtPath(target, operation2.path);
+    list.splice(operation2.index, 0, ...readMockTypedValues(operation2.values));
   }
-  for (const operation of patch.textSplice ?? []) {
-    applyMockTextPatch(target, operation.path, [{
-      index: operation.index,
-      deleteCount: operation.deleteCount,
-      ...operation.insert !== void 0 ? { insert: operation.insert } : {}
+  for (const operation2 of patch.textSplice ?? []) {
+    applyMockTextPatch(target, operation2.path, [{
+      index: operation2.index,
+      deleteCount: operation2.deleteCount,
+      ...operation2.insert !== void 0 ? { insert: operation2.insert } : {}
     }]);
   }
-  for (const operation of patch.textMark ?? []) {
-    applyMockTextMarks(target, operation.path, operation.index, operation.length, operation.marks, false);
+  for (const operation2 of patch.textMark ?? []) {
+    applyMockTextMarks(target, operation2.path, operation2.index, operation2.length, operation2.marks, false);
   }
-  for (const operation of patch.textUnmark ?? []) {
-    applyMockTextMarks(target, operation.path, operation.index, operation.length, Object.fromEntries(operation.names.map((name) => [name, null])), true);
+  for (const operation2 of patch.textUnmark ?? []) {
+    applyMockTextMarks(target, operation2.path, operation2.index, operation2.length, Object.fromEntries(operation2.names.map((name) => [name, null])), true);
   }
-  for (const operation of patch.counterIncrement ?? []) {
-    assertMockCounterAmount(operation.delta, "JSON counterIncrement delta");
-    const parent = ensureParentAtPath(target, operation.path);
-    const leaf = operation.path[operation.path.length - 1];
+  for (const operation2 of patch.counterIncrement ?? []) {
+    assertMockCounterAmount(operation2.delta, "JSON counterIncrement delta");
+    const parent = ensureParentAtPath(target, operation2.path);
+    const leaf = operation2.path[operation2.path.length - 1];
     const current = parent[leaf];
     if (current == null) {
-      parent[leaf] = operation.delta;
+      parent[leaf] = operation2.delta;
     } else if (typeof current === "number") {
-      parent[leaf] = current + operation.delta;
+      parent[leaf] = current + operation2.delta;
     } else {
       throw new Error(
-        `Cannot increment non-counter value at ${operation.path.map(String).join(".")}`
+        `Cannot increment non-counter value at ${operation2.path.map(String).join(".")}`
       );
     }
   }
@@ -2642,44 +2964,44 @@ function validateMockJsonPatch(patch) {
   if (operationCount === 0) {
     throw new Error("JSON patch must include at least one operation");
   }
-  for (const operation of patch.set ?? []) {
-    validateMockJsonPath(operation.path, "JSON set");
-    hydrateMockAutomergeValues(operation.value);
+  for (const operation2 of patch.set ?? []) {
+    validateMockJsonPath(operation2.path, "JSON set");
+    hydrateMockAutomergeValues(operation2.value);
   }
-  for (const operation of patch.unset ?? []) {
-    validateMockJsonPath(operation.path, "JSON unset");
+  for (const operation2 of patch.unset ?? []) {
+    validateMockJsonPath(operation2.path, "JSON unset");
   }
-  for (const operation of patch.listDelete ?? []) {
-    validateMockJsonPath(operation.path, "JSON listDelete");
-    assertMockNonNegativeInteger(operation.index, "JSON listDelete index");
-    assertMockNonNegativeInteger(operation.deleteCount, "JSON listDelete deleteCount");
+  for (const operation2 of patch.listDelete ?? []) {
+    validateMockJsonPath(operation2.path, "JSON listDelete");
+    assertMockNonNegativeInteger(operation2.index, "JSON listDelete index");
+    assertMockNonNegativeInteger(operation2.deleteCount, "JSON listDelete deleteCount");
   }
-  for (const operation of patch.listInsert ?? []) {
-    validateMockJsonPath(operation.path, "JSON listInsert");
-    assertMockNonNegativeInteger(operation.index, "JSON listInsert index");
-    if (!Array.isArray(operation.values)) {
+  for (const operation2 of patch.listInsert ?? []) {
+    validateMockJsonPath(operation2.path, "JSON listInsert");
+    assertMockNonNegativeInteger(operation2.index, "JSON listInsert index");
+    if (!Array.isArray(operation2.values)) {
       throw new Error("JSON listInsert values must be an array");
     }
-    hydrateMockAutomergeValues(operation.values);
+    hydrateMockAutomergeValues(operation2.values);
   }
-  for (const operation of patch.textSplice ?? []) {
-    validateMockJsonPath(operation.path, "JSON textSplice");
-    assertMockNonNegativeInteger(operation.index, "JSON textSplice index");
-    assertMockNonNegativeInteger(operation.deleteCount, "JSON textSplice deleteCount");
-    if (operation.insert !== void 0 && typeof operation.insert !== "string") {
+  for (const operation2 of patch.textSplice ?? []) {
+    validateMockJsonPath(operation2.path, "JSON textSplice");
+    assertMockNonNegativeInteger(operation2.index, "JSON textSplice index");
+    assertMockNonNegativeInteger(operation2.deleteCount, "JSON textSplice deleteCount");
+    if (operation2.insert !== void 0 && typeof operation2.insert !== "string") {
       throw new Error("JSON textSplice insert must be a string");
     }
   }
-  for (const operation of [...patch.textMark ?? [], ...patch.textUnmark ?? []]) {
-    validateMockJsonPath(operation.path, "JSON text mark");
-    assertMockNonNegativeInteger(operation.index, "JSON text mark index");
-    if (!Number.isInteger(operation.length) || operation.length <= 0) {
+  for (const operation2 of [...patch.textMark ?? [], ...patch.textUnmark ?? []]) {
+    validateMockJsonPath(operation2.path, "JSON text mark");
+    assertMockNonNegativeInteger(operation2.index, "JSON text mark index");
+    if (!Number.isInteger(operation2.length) || operation2.length <= 0) {
       throw new Error("JSON text mark length must be a positive integer");
     }
   }
-  for (const operation of patch.counterIncrement ?? []) {
-    validateMockJsonPath(operation.path, "JSON counterIncrement");
-    assertMockCounterAmount(operation.delta, "JSON counterIncrement delta");
+  for (const operation2 of patch.counterIncrement ?? []) {
+    validateMockJsonPath(operation2.path, "JSON counterIncrement");
+    assertMockCounterAmount(operation2.delta, "JSON counterIncrement delta");
   }
 }
 function ensureMockAutomergeParent(target, path) {
@@ -2781,64 +3103,64 @@ function reviveMockRichTextValue(value) {
   );
 }
 function applyMockAutomergeJsonOperations(target, patch) {
-  for (const operation of patch.set ?? []) {
-    setMockAutomergeValue(target, operation.path, hydrateMockAutomergeValues(operation.value));
+  for (const operation2 of patch.set ?? []) {
+    setMockAutomergeValue(target, operation2.path, hydrateMockAutomergeValues(operation2.value));
   }
-  for (const operation of patch.unset ?? []) {
-    unsetMockAutomergeValue(target, operation.path);
+  for (const operation2 of patch.unset ?? []) {
+    unsetMockAutomergeValue(target, operation2.path);
   }
-  for (const operation of patch.listDelete ?? []) {
-    readMockAutomergeList(target, operation.path).splice(operation.index, operation.deleteCount);
+  for (const operation2 of patch.listDelete ?? []) {
+    readMockAutomergeList(target, operation2.path).splice(operation2.index, operation2.deleteCount);
   }
-  for (const operation of patch.listInsert ?? []) {
-    ensureMockAutomergeList(target, operation.path).splice(
-      operation.index,
+  for (const operation2 of patch.listInsert ?? []) {
+    ensureMockAutomergeList(target, operation2.path).splice(
+      operation2.index,
       0,
-      ...hydrateMockAutomergeValues(operation.values)
+      ...hydrateMockAutomergeValues(operation2.values)
     );
   }
-  for (const operation of patch.textSplice ?? []) {
-    ensureMockAutomergeText(target, operation.path, "JSON textSplice");
+  for (const operation2 of patch.textSplice ?? []) {
+    ensureMockAutomergeText(target, operation2.path, "JSON textSplice");
     spliceMockAutomergeText(
       target,
-      operation.path,
-      operation.index,
-      operation.deleteCount,
-      operation.insert ?? ""
+      operation2.path,
+      operation2.index,
+      operation2.deleteCount,
+      operation2.insert ?? ""
     );
   }
-  for (const operation of patch.textMark ?? []) {
-    for (const [name, value] of Object.entries(operation.marks)) {
+  for (const operation2 of patch.textMark ?? []) {
+    for (const [name, value] of Object.entries(operation2.marks)) {
       Automerge.mark(
         target,
-        operation.path,
-        { start: operation.index, end: operation.index + operation.length, expand: "none" },
+        operation2.path,
+        { start: operation2.index, end: operation2.index + operation2.length, expand: "none" },
         name,
         reviveMockRichTextValue(value)
       );
     }
   }
-  for (const operation of patch.textUnmark ?? []) {
-    for (const name of operation.names) {
+  for (const operation2 of patch.textUnmark ?? []) {
+    for (const name of operation2.names) {
       Automerge.unmark(
         target,
-        operation.path,
-        { start: operation.index, end: operation.index + operation.length, expand: "none" },
+        operation2.path,
+        { start: operation2.index, end: operation2.index + operation2.length, expand: "none" },
         name
       );
     }
   }
-  for (const operation of patch.counterIncrement ?? []) {
-    const parent = ensureMockAutomergeParent(target, operation.path);
-    const leaf = operation.path[operation.path.length - 1];
+  for (const operation2 of patch.counterIncrement ?? []) {
+    const parent = ensureMockAutomergeParent(target, operation2.path);
+    const leaf = operation2.path[operation2.path.length - 1];
     const existing = parent[leaf];
     if (existing === void 0 || existing === null) {
-      parent[leaf] = new Automerge.Counter(operation.delta);
+      parent[leaf] = new Automerge.Counter(operation2.delta);
     } else if (Automerge.isCounter(existing)) {
-      existing.increment(operation.delta);
+      existing.increment(operation2.delta);
     } else {
       throw new Error(
-        `Cannot increment non-counter value at '${operation.path.map(String).join(".")}'; create it with MindooValue.counter() first`
+        `Cannot increment non-counter value at '${operation2.path.map(String).join(".")}'; create it with MindooValue.counter() first`
       );
     }
   }
@@ -2850,7 +3172,232 @@ function changeMockAutomergeDocument(doc, baseHeads, apply) {
   }
   return Automerge.change(doc, apply);
 }
+function reviveMockRichTextSpans(spans2) {
+  return spans2.map(
+    (span) => span.type === "text" ? {
+      type: "text",
+      value: span.value,
+      marks: span.marks ? reviveMockRichTextValue(span.marks) : void 0
+    } : { type: "block", value: reviveMockRichTextValue(span.value) }
+  );
+}
+function dehydrateMockRichTextValue(value) {
+  if (Automerge.isImmutableString(value)) {
+    return { type: "immutableString", value: String(value) };
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => dehydrateMockRichTextValue(entry));
+  }
+  if (!value || typeof value !== "object" || value instanceof Date || value instanceof Uint8Array) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, dehydrateMockRichTextValue(entry)])
+  );
+}
+function validateMockRichTextSpans(spans2) {
+  if (!Array.isArray(spans2)) {
+    throw new Error("Rich-text patch spans must be an array");
+  }
+  for (const span of spans2) {
+    if (!span || typeof span !== "object") {
+      throw new Error("Rich-text span must be an object");
+    }
+    if (span.type === "text") {
+      if (typeof span.value !== "string") {
+        throw new Error("Rich-text text span value must be a string");
+      }
+      continue;
+    }
+    if (span.type === "block") {
+      if (!span.value || typeof span.value !== "object" || Array.isArray(span.value)) {
+        throw new Error("Rich-text block span value must be an object");
+      }
+      continue;
+    }
+    throw new Error("Rich-text span type must be 'text' or 'block'");
+  }
+}
+function validateMockRichTextPatch(patch) {
+  validateMockJsonPath(patch.path, "Rich-text patch");
+  const hasSpans = patch.spans !== void 0;
+  const hasSequence = patch.spansSequence !== void 0;
+  if (hasSpans === hasSequence) {
+    throw new Error("Rich-text patch must include exactly one of spans or spansSequence");
+  }
+  if (hasSpans) {
+    validateMockRichTextSpans(patch.spans);
+    return;
+  }
+  if (!Array.isArray(patch.spansSequence) || patch.spansSequence.length === 0) {
+    throw new Error("Rich-text patch spansSequence must be a non-empty array");
+  }
+  for (const spans2 of patch.spansSequence) {
+    validateMockRichTextSpans(spans2);
+  }
+}
+function validateMockRichTextStepPatch(patch) {
+  validateMockJsonPath(patch.path, "Rich-text steps patch");
+  if (!Array.isArray(patch.steps) || patch.steps.length === 0) {
+    throw new Error("Rich-text steps patch steps must be a non-empty array");
+  }
+  for (const step of patch.steps) {
+    if (!step || typeof step !== "object") {
+      throw new Error("Rich-text step must be an object");
+    }
+    if (step.type !== "splice") {
+      throw new Error("Rich-text step type must be 'splice'");
+    }
+    if (!Number.isInteger(step.index) || step.index < 0) {
+      throw new Error("Rich-text splice step index must be a non-negative integer");
+    }
+    if (!Number.isInteger(step.deleteCount) || step.deleteCount < 0) {
+      throw new Error("Rich-text splice step deleteCount must be a non-negative integer");
+    }
+    if (step.insert !== void 0 && typeof step.insert !== "string") {
+      throw new Error("Rich-text splice step insert must be a string");
+    }
+    for (const range of step.marks ?? []) {
+      if (!Number.isInteger(range.index) || range.index < 0) {
+        throw new Error("Rich-text mark range index must be a non-negative integer");
+      }
+      if (!Number.isInteger(range.length) || range.length <= 0) {
+        throw new Error("Rich-text mark range length must be a positive integer");
+      }
+      if (!range.marks || typeof range.marks !== "object" || Array.isArray(range.marks)) {
+        throw new Error("Rich-text mark range marks must be an object");
+      }
+    }
+  }
+}
+function ensureMockRichTextPath(target, path) {
+  let node = target;
+  for (let index = 0; index < path.length - 1; index += 1) {
+    const segment = path[index];
+    if (node[segment] === void 0 || node[segment] === null) {
+      node[segment] = typeof path[index + 1] === "number" ? [] : {};
+    }
+    node = node[segment];
+    if (node === null || typeof node !== "object") {
+      throw new Error(`Cannot apply rich-text patch through non-object path segment '${String(segment)}'`);
+    }
+  }
+  const leaf = path[path.length - 1];
+  const current = node[leaf];
+  if (current === void 0 || current === null) {
+    node[leaf] = "";
+    return;
+  }
+  if (typeof current !== "string") {
+    throw new Error(`Cannot apply rich-text patch to non-string value at '${path.map(String).join(".")}'`);
+  }
+}
+function changeMockAutomergeDocumentOnFork(doc, baseHeads, apply) {
+  const current = Automerge.getHeads(doc);
+  if (!baseHeads || baseHeads.length === 0 || current.length === baseHeads.length && current.every((head) => baseHeads.includes(head))) {
+    return Automerge.change(doc, apply);
+  }
+  const base = Automerge.view(doc, baseHeads);
+  const actor = Automerge.getActorId(doc);
+  const ownChangeSince = Automerge.getChanges(base, doc).some(
+    (change2) => Automerge.decodeChange(change2).actor === actor
+  );
+  const fork = Automerge.clone(base, ownChangeSince ? void 0 : { actor });
+  return Automerge.merge(doc, Automerge.change(fork, apply));
+}
+function isMockUpdateSpansBoundsError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Cannot updateSpans|out of bounds/i.test(message);
+}
+function readMockAutomergeRichText(document2, path) {
+  validateMockJsonPath(path, "Rich-text snapshot");
+  const doc = loadMockAutomergeDocument(document2);
+  return Automerge.spans(doc, path).map((span) => {
+    const record = span;
+    return record.type === "text" ? {
+      type: "text",
+      value: typeof record.value === "string" ? record.value : "",
+      marks: record.marks ? dehydrateMockRichTextValue(record.marks) : void 0
+    } : {
+      type: "block",
+      value: dehydrateMockRichTextValue(record.value)
+    };
+  });
+}
+function commonMockBaseHeads(patch) {
+  const all = [
+    patch.json?.baseHeads,
+    ...(patch.text ?? []).map((p) => p.baseHeads),
+    ...(patch.richText ?? []).map((p) => p.baseHeads),
+    ...(patch.richTextSteps ?? []).map((p) => p.baseHeads)
+  ].filter((heads) => Array.isArray(heads) && heads.length > 0);
+  if (all.length === 0) return void 0;
+  const first = [...all[0]].sort().join(",");
+  return all.every((heads) => [...heads].sort().join(",") === first) ? all[0] : null;
+}
+function applyMockRichTextSpansInChange(target, richTextPatch) {
+  const sequence = richTextPatch.spansSequence ?? (richTextPatch.spans ? [richTextPatch.spans] : []);
+  const config = richTextPatch.updateSpansConfig;
+  ensureMockRichTextPath(target, richTextPatch.path);
+  const path = richTextPatch.path;
+  for (const spans2 of sequence) {
+    const revived = reviveMockRichTextSpans(spans2);
+    try {
+      Automerge.updateSpans(target, path, revived, config);
+    } catch (error) {
+      if (!isMockUpdateSpansBoundsError(error)) {
+        throw error;
+      }
+      setMockAutomergeValue(target, richTextPatch.path, "");
+      Automerge.updateSpans(target, path, revived, config);
+    }
+  }
+}
+function applyMockRichTextStepsInChange(target, stepPatch) {
+  ensureMockRichTextPath(target, stepPatch.path);
+  const path = stepPatch.path;
+  for (const step of stepPatch.steps) {
+    Automerge.splice(target, path, step.index, step.deleteCount, step.insert ?? "");
+    for (const range of step.marks ?? []) {
+      for (const [name, value] of Object.entries(range.marks)) {
+        Automerge.mark(
+          target,
+          path,
+          { start: range.index, end: range.index + range.length, expand: "none" },
+          name,
+          reviveMockRichTextValue(value)
+        );
+      }
+    }
+  }
+}
 function applyMockAutomergeUpdate(doc, patch) {
+  const common = commonMockBaseHeads(patch);
+  if (common !== null) {
+    if (patch.json) validateMockJsonPatch(patch.json);
+    for (const textPatch of patch.text ?? []) validateMockJsonPath(textPatch.path, "Text patch");
+    for (const richTextPatch of patch.richText ?? []) validateMockRichTextPatch(richTextPatch);
+    for (const stepPatch of patch.richTextSteps ?? []) validateMockRichTextStepPatch(stepPatch);
+    return changeMockAutomergeDocumentOnFork(doc, common, (target) => {
+      for (const [key, value] of Object.entries(patch.set ?? {})) {
+        if (value !== void 0) {
+          target[key] = hydrateMockAutomergeValues(value);
+        }
+      }
+      for (const key of patch.unset ?? []) {
+        delete target[key];
+      }
+      if (patch.json) applyMockAutomergeJsonOperations(target, patch.json);
+      for (const textPatch of patch.text ?? []) {
+        ensureMockAutomergeText(target, textPatch.path, "text patch");
+        for (const edit of textPatch.edits) {
+          spliceMockAutomergeText(target, textPatch.path, edit.index, edit.deleteCount, edit.insert ?? "");
+        }
+      }
+      for (const richTextPatch of patch.richText ?? []) applyMockRichTextSpansInChange(target, richTextPatch);
+      for (const stepPatch of patch.richTextSteps ?? []) applyMockRichTextStepsInChange(target, stepPatch);
+    });
+  }
   let next = doc;
   if (patch.set || (patch.unset?.length ?? 0) > 0) {
     next = Automerge.change(next, (target) => {
@@ -2883,26 +3430,44 @@ function applyMockAutomergeUpdate(doc, patch) {
     });
   }
   for (const richTextPatch of patch.richText ?? []) {
-    validateMockJsonPath(richTextPatch.path, "Rich-text patch");
-    const spans = richTextPatch.spansSequence?.at(-1) ?? richTextPatch.spans ?? [];
-    next = Automerge.change(next, (target) => {
-      setMockAutomergeValue(target, richTextPatch.path, hydrateMockAutomergeValues(structuredClone(spans)));
+    validateMockRichTextPatch(richTextPatch);
+    const sequence = richTextPatch.spansSequence ?? (richTextPatch.spans ? [richTextPatch.spans] : []);
+    const config = richTextPatch.updateSpansConfig;
+    next = changeMockAutomergeDocumentOnFork(next, richTextPatch.baseHeads, (target) => {
+      ensureMockRichTextPath(target, richTextPatch.path);
+      const path = richTextPatch.path;
+      for (const spans2 of sequence) {
+        const revived = reviveMockRichTextSpans(spans2);
+        try {
+          Automerge.updateSpans(target, path, revived, config);
+        } catch (error) {
+          if (!isMockUpdateSpansBoundsError(error)) {
+            throw error;
+          }
+          setMockAutomergeValue(target, richTextPatch.path, "");
+          Automerge.updateSpans(target, path, revived, config);
+        }
+      }
     });
   }
   for (const stepPatch of patch.richTextSteps ?? []) {
-    validateMockJsonPath(stepPatch.path, "Rich-text steps patch");
+    validateMockRichTextStepPatch(stepPatch);
     next = changeMockAutomergeDocument(next, stepPatch.baseHeads, (target) => {
-      const current = readMockAutomergeValue(target, stepPatch.path);
-      if (current !== void 0 && current !== null && typeof current !== "string") {
-        setMockAutomergeValue(
-          target,
-          stepPatch.path,
-          materializeMockRichTextValue(projectMockAutomergeValue(current))
-        );
-      }
-      ensureMockAutomergeText(target, stepPatch.path, "rich-text steps");
+      ensureMockRichTextPath(target, stepPatch.path);
+      const path = stepPatch.path;
       for (const step of stepPatch.steps) {
-        spliceMockAutomergeText(target, stepPatch.path, step.index, step.deleteCount, step.insert ?? "");
+        Automerge.splice(target, path, step.index, step.deleteCount, step.insert ?? "");
+        for (const range of step.marks ?? []) {
+          for (const [name, value] of Object.entries(range.marks)) {
+            Automerge.mark(
+              target,
+              path,
+              { start: range.index, end: range.index + range.length, expand: "none" },
+              name,
+              reviveMockRichTextValue(value)
+            );
+          }
+        }
       }
     });
   }
@@ -2925,8 +3490,8 @@ function forkMockAutomergeDocument(doc, baseHeads, actor) {
   }
   return Automerge.clone(Automerge.view(doc, [...heads]), { actor });
 }
-function getFieldValue2(source, field) {
-  return field.split(".").reduce((current, part) => {
+function getFieldValue2(source, field2) {
+  return field2.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
       return current[part];
     }
@@ -2938,7 +3503,7 @@ function matchesDocumentFilter(document2, filter) {
     return true;
   }
   return Object.entries(filter).every(
-    ([field, expected]) => getFieldValue2(document2.data, field) === expected
+    ([field2, expected]) => getFieldValue2(document2.data, field2) === expected
   );
 }
 function withValidatedCreateIds(documents) {
@@ -3015,7 +3580,7 @@ function computeMockTextScore(document2, clause) {
   if (terms.length === 0) {
     return void 0;
   }
-  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue2(document2.data, field))).join(" ") : collectMockText(
+  const haystack = clause.fields ? clause.fields.map((field2) => collectMockText(getFieldValue2(document2.data, field2))).join(" ") : collectMockText(
     Object.fromEntries(
       Object.entries(document2.data).filter(([key]) => !key.startsWith("_"))
     )
@@ -3245,7 +3810,7 @@ function createLiveMockViewNavigator(initial, rebuild, subscribe) {
   });
 }
 function projectMockFields(data, fields) {
-  return fields ? Object.fromEntries(fields.map((field) => [field, getFieldValue2(data, field)])) : structuredClone(data);
+  return fields ? Object.fromEntries(fields.map((field2) => [field2, getFieldValue2(data, field2)])) : structuredClone(data);
 }
 function mockLastModified(document2) {
   return document2.updatedAt ? Date.parse(document2.updatedAt) || 0 : 0;
@@ -3773,19 +4338,56 @@ async function mockSha256Hex(value) {
   const digest = await subtle.digest("SHA-256", new TextEncoder().encode(value));
   return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
+function mockRevisionId(docId, index) {
+  return `${docId}@${index}`;
+}
+function mockRevisionIndex(docId, revisionId) {
+  const prefix = `${docId}@`;
+  return revisionId.startsWith(prefix) ? Number(revisionId.slice(prefix.length)) : -1;
+}
+function createDatabaseHandle(definition, peers, directoryUsers = () => [], localActor = MOCK_AUTOMERGE_LOCAL_ACTOR) {
   let createCounter = 0;
   let changeCounter = 0;
+  const replicaTag = localActor === MOCK_AUTOMERGE_LOCAL_ACTOR ? "" : `-${localActor.slice(0, 6)}`;
   const defaultViewFactory = async () => createDefaultViewNavigator();
   const automergeMode = definition.automerge === true;
   let changeSequence = 0;
   const changedAt = /* @__PURE__ */ new Map();
+  const revisions = /* @__PURE__ */ new Map();
   const storedDocuments = new class extends Map {
     set(id, document2) {
       changedAt.set(id, ++changeSequence);
+      const timeline = revisions.get(id) ?? [];
+      const updatedAt = document2.updatedAt ? Date.parse(document2.updatedAt) : NaN;
+      const previous = timeline[timeline.length - 1]?.timestamp ?? 0;
+      timeline.push({
+        // Strictly increasing, so a timestamp names one revision.
+        timestamp: Math.max(Number.isFinite(updatedAt) ? updatedAt : Date.now(), previous + 1),
+        data: structuredClone(document2.data),
+        heads: document2.heads ? [...document2.heads] : void 0,
+        isDeleted: document2.isDeleted,
+        authorLabel: document2.authorLabel,
+        attachments: structuredClone(document2.attachments ?? [])
+      });
+      revisions.set(id, timeline);
       return super.set(id, document2);
     }
   }();
+  function historicalDocument(docId, index, timestamp, revisionId) {
+    const revision = index >= 0 ? revisions.get(docId)?.[index] : void 0;
+    if (!revision) {
+      return { id: docId, timestamp, state: "missing", data: null, attachments: [], ...revisionId ? { revisionId } : {} };
+    }
+    return {
+      id: docId,
+      revisionId: revisionId ?? mockRevisionId(docId, index),
+      timestamp: revision.timestamp,
+      heads: revision.heads ? [...revision.heads] : [],
+      state: revision.isDeleted ? "deleted" : "exists",
+      data: revision.isDeleted ? null : structuredClone(revision.data),
+      attachments: structuredClone(revision.attachments)
+    };
+  }
   for (const seed of definition.documents ?? []) {
     const stored = {
       id: seed.id,
@@ -3852,7 +4454,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       return writeAutomergeDocument(
         docId,
         existing,
-        Automerge.change(loadMockAutomergeDocument(existing, MOCK_AUTOMERGE_LOCAL_ACTOR), (target) => {
+        Automerge.change(loadMockAutomergeDocument(existing, localActor), (target) => {
           target._encryptFor = hydrateMockAutomergeValues(nextEncryptFor);
         })
       );
@@ -3967,9 +4569,9 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           };
         }
         const projectedData = query?.fields ? Object.fromEntries(
-          query.fields.map((field) => [
-            field,
-            getFieldValue2(document2.data, field)
+          query.fields.map((field2) => [
+            field2,
+            getFieldValue2(document2.data, field2)
           ])
         ) : document2.data;
         return {
@@ -4030,7 +4632,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       return {
         path: [...path],
         heads: document2.heads ? [...document2.heads] : void 0,
-        spans: structuredClone(readRichTextSpansAtPath(document2.data, path))
+        spans: automergeMode ? readMockAutomergeRichText(document2, path) : structuredClone(readRichTextSpansAtPath(document2.data, path))
       };
     },
     // Mock cursors store the index they were created at and do not follow
@@ -4162,10 +4764,10 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
         id = callerId;
       } else if (typeof input.idPrefix === "string" && input.idPrefix.length > 0) {
         createCounter += 1;
-        id = `${input.idPrefix}_${String(createCounter).padStart(22, "0")}`;
+        id = `${input.idPrefix}_${String(createCounter).padStart(22, "0")}${replicaTag}`;
       } else {
         createCounter += 1;
-        id = `doc-${createCounter}`;
+        id = `doc-${createCounter}${replicaTag}`;
       }
       const createdAt = (/* @__PURE__ */ new Date()).toISOString();
       if (Array.isArray(input.recipients) && input.recipientOptions?.includeSelf === false && input.recipients.every((name) => name.trim().length === 0)) {
@@ -4187,7 +4789,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           stored2,
           createMockAutomergeDocument(
             { ...input.set ?? {}, ...encryptFor },
-            MOCK_AUTOMERGE_LOCAL_ACTOR
+            localActor
           )
         );
         storedDocuments.set(id, stored2);
@@ -4237,7 +4839,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       const existing = storedDocuments.get(docId);
       if (automergeMode) {
-        const current = existing?.automergeBinary ? loadMockAutomergeDocument(existing, MOCK_AUTOMERGE_LOCAL_ACTOR) : createMockAutomergeDocument(existing?.data ?? {}, MOCK_AUTOMERGE_LOCAL_ACTOR);
+        const current = existing?.automergeBinary ? loadMockAutomergeDocument(existing, localActor) : createMockAutomergeDocument(existing?.data ?? {}, localActor);
         return writeAutomergeDocument(docId, existing, applyMockAutomergeUpdate(current, patch));
       }
       const updated = {
@@ -4351,28 +4953,30 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     async listCreateKeys() {
       return [{ keyId: "default", isDefault: true }];
     },
-    async listHistory(_docId) {
-      return [];
+    async listHistory(docId) {
+      const timeline = revisions.get(docId) ?? [];
+      return timeline.map((revision, index) => ({
+        revisionId: mockRevisionId(docId, index),
+        timestamp: revision.timestamp,
+        ...revision.heads ? { heads: [...revision.heads] } : {},
+        publicKey: revision.authorLabel ?? "mock-user",
+        ...revision.authorLabel ? { identityLabel: revision.authorLabel } : {},
+        isDeleted: revision.isDeleted,
+        isCurrent: index === timeline.length - 1,
+        ...index > 0 ? { dependencyIds: [mockRevisionId(docId, index - 1)] } : {}
+      })).reverse();
     },
     async getAtTimestamp(docId, timestamp) {
-      return {
-        id: docId,
-        timestamp,
-        state: "missing",
-        data: null,
-        attachments: []
-      };
+      const timeline = revisions.get(docId) ?? [];
+      let index = -1;
+      timeline.forEach((revision, position) => {
+        if (revision.timestamp <= timestamp) index = position;
+      });
+      return historicalDocument(docId, index, timestamp);
     },
-    async getAtRevision(docId, revisionId) {
-      return {
-        id: docId,
-        revisionId,
-        timestamp: Date.now(),
-        heads: [],
-        state: "missing",
-        data: null,
-        attachments: []
-      };
+    async getAtRevision(docId, revisionId, revisionOptions) {
+      const index = mockRevisionIndex(docId, revisionId);
+      return historicalDocument(docId, revisionOptions?.phase === "before" ? index - 1 : index, Date.now(), revisionId);
     },
     async getAtHeads(docId, _headIds) {
       return {
@@ -4559,7 +5163,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       if (!automergeMode || !existing.automergeBinary) {
         return await defaultDocuments.update(docId, input);
       }
-      const current = loadMockAutomergeDocument(existing, MOCK_AUTOMERGE_LOCAL_ACTOR);
+      const current = loadMockAutomergeDocument(existing, localActor);
       const remote = applyMockAutomergeUpdate(
         forkMockAutomergeDocument(
           current,
@@ -4574,13 +5178,17 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
 }
 function createMockSessionState(options = {}) {
   let launchContext = createDefaultLaunchContext(options.launchContext);
-  const embedHost = createMockEmbedHost(options, (databaseId) => {
-    const database = databaseHandles.get(databaseId);
-    if (!database) {
-      throw new Error(`Unknown test database: ${databaseId}`);
-    }
-    return database;
-  });
+  const embedHost = createMockEmbedHost(
+    options,
+    (databaseId) => {
+      const database = databaseHandles.get(databaseId);
+      if (!database) {
+        throw new Error(`Unknown test database: ${databaseId}`);
+      }
+      return database;
+    },
+    () => [...databaseHandles.keys()]
+  );
   const themeListeners = /* @__PURE__ */ new Set();
   let incomingHandler = null;
   const pendingIncoming = [];
@@ -4692,7 +5300,12 @@ function createMockSessionState(options = {}) {
       capabilities: [...definition.info.capabilities]
     }));
     for (const definition of definitions) {
-      const created = createDatabaseHandle(definition, databasePeers, () => directoryUsers);
+      const created = createDatabaseHandle(
+        definition,
+        databasePeers,
+        () => directoryUsers,
+        options.automergeActor ?? MOCK_AUTOMERGE_LOCAL_ACTOR
+      );
       const databaseId = definition.info.id;
       databaseHandles.set(
         databaseId,
@@ -4706,35 +5319,48 @@ function createMockSessionState(options = {}) {
       databaseDocumentStores.set(definition.info.id, created.documents);
       databaseLiveQueryRefreshers.set(definition.info.id, created.notifyLiveQueries);
       databaseRemoteUpdaters.set(definition.info.id, created.applyRemoteUpdate);
+      const createView = async (input) => {
+        const build = () => createEvaluatingViewNavigator(
+          input,
+          input.databaseIds.flatMap((databaseId2) => {
+            const list = databaseViewDocumentLists.get(databaseId2);
+            return list ? list() : [];
+          })
+        );
+        const subscribe = (onChange) => {
+          const listener = { databaseIds: [...input.databaseIds], onChange };
+          viewChangeListeners.add(listener);
+          return () => viewChangeListeners.delete(listener);
+        };
+        const evaluating = await build();
+        if (evaluating) {
+          return createLiveMockViewNavigator(evaluating, build, subscribe);
+        }
+        console.warn(
+          "[mindoodb-app-sdk/testing] mindoodb peer not available; using empty view navigator. Install mindoodb as a devDependency for evaluating VirtualViews."
+        );
+        return createLiveMockViewNavigator(
+          await createDefaultViewNavigator(),
+          async () => null,
+          subscribe
+        );
+      };
       databaseViewApis.set(definition.info.id, {
-        async create(input) {
-          const build = () => createEvaluatingViewNavigator(
-            input,
-            input.databaseIds.flatMap((databaseId2) => {
-              const list = databaseViewDocumentLists.get(databaseId2);
-              return list ? list() : [];
-            })
-          );
-          const subscribe = (onChange) => {
-            const listener = { databaseIds: [...input.databaseIds], onChange };
-            viewChangeListeners.add(listener);
-            return () => viewChangeListeners.delete(listener);
-          };
-          const evaluating = await build();
-          if (evaluating) {
-            return createLiveMockViewNavigator(evaluating, build, subscribe);
+        create: createView,
+        // A view configured in the launch context, evaluated over the mock
+        // documents of its sources: a fresh navigator per open, with the
+        // open options applied, as Haven builds one.
+        async open(viewId, openOptions) {
+          const configured = launchContext.views.find((view2) => view2.id === viewId);
+          if (!configured) {
+            return await createDefaultViewNavigator();
           }
-          console.warn(
-            "[mindoodb-app-sdk/testing] mindoodb peer not available; using empty view navigator. Install mindoodb as a devDependency for evaluating VirtualViews."
-          );
-          return createLiveMockViewNavigator(
-            await createDefaultViewNavigator(),
-            async () => null,
-            subscribe
-          );
-        },
-        async open(_viewId) {
-          return await createDefaultViewNavigator();
+          return await createView({
+            databaseIds: configured.sources.map((source) => source.databaseId),
+            definition: configuredViewDefinition(configured),
+            categorizationStyle: configured.categorizationStyle,
+            ...openOptions ? { options: openOptions } : {}
+          });
         },
         ...definition.methods?.views ?? {}
       });
@@ -4830,16 +5456,21 @@ function createMockSessionState(options = {}) {
       }
       const view2 = await api.create(input);
       const viewId = input.definition.id || crypto.randomUUID();
-      sessionViews.set(viewId, view2);
+      sessionViews.set(viewId, input);
       return view2;
     },
+    // Every open is a navigator of its own with its own options, as in
+    // Haven: disposing one leaves the others and later opens working.
     async openViewNavigator(viewId, options2) {
-      const existing = sessionViews.get(viewId);
-      if (existing) {
-        return existing;
+      const created = sessionViews.get(viewId);
+      if (created) {
+        const api2 = databaseViewApis.get(created.databaseIds[0]);
+        if (api2) {
+          return await api2.create({ ...created, ...options2 ? { options: options2 } : {} });
+        }
       }
       const sourceDatabaseId = launchContext.views.find(
-        (view3) => view3.id === viewId
+        (view2) => view2.id === viewId
       )?.sources[0]?.databaseId;
       if (!sourceDatabaseId) {
         throw new Error(`Unknown test view: ${viewId}`);
@@ -4850,9 +5481,7 @@ function createMockSessionState(options = {}) {
           `Unknown test database for view ${viewId}: ${sourceDatabaseId}`
         );
       }
-      const view2 = await api.open(viewId, options2);
-      sessionViews.set(viewId, view2);
-      return view2;
+      return await api.open(viewId, options2);
     },
     menus,
     drag,
@@ -4981,6 +5610,8 @@ function createMockSessionState(options = {}) {
       directoryUsers = [...users];
     },
     getDirectoryUsers: () => [...directoryUsers],
+    replicaStores: () => databaseDocumentStores,
+    notifyReplicaChange: (databaseId) => databaseLiveQueryRefreshers.get(databaseId)?.(),
     embedHost,
     getDatabase(databaseId) {
       const database = databaseHandles.get(databaseId);
@@ -5098,9 +5729,92 @@ function buildMockIncomingContent(input, deliveryId) {
     })
   };
 }
+var replicaStates = /* @__PURE__ */ new WeakMap();
+function sameMockHeads(a, b) {
+  const x = a?.heads ?? [];
+  const y = b?.heads ?? [];
+  return x.length === y.length && x.every((head) => y.includes(head));
+}
+function mockReplicaDifferences(a, b) {
+  const left = replicaStates.get(a)?.replicaStores();
+  const right = replicaStates.get(b)?.replicaStores();
+  if (!left || !right) throw new Error("syncMockReplicas: not a mock controller");
+  let count = 0;
+  for (const [databaseId, docsA] of left) {
+    const docsB = right.get(databaseId);
+    if (!docsB) continue;
+    for (const id of /* @__PURE__ */ new Set([...docsA.keys(), ...docsB.keys()])) {
+      const x = docsA.get(id);
+      const y = docsB.get(id);
+      if (!x || !y || x.isDeleted !== y.isDeleted || !sameMockHeads(x, y)) count += 1;
+    }
+  }
+  return count;
+}
+async function syncMockReplicas(a, b) {
+  const stateA = replicaStates.get(a);
+  const stateB = replicaStates.get(b);
+  if (!stateA || !stateB) throw new Error("syncMockReplicas: not a mock controller");
+  let changed = 0;
+  for (const [databaseId, docsA] of stateA.replicaStores()) {
+    const docsB = stateB.replicaStores().get(databaseId);
+    if (!docsB) continue;
+    const touchedA = /* @__PURE__ */ new Set();
+    const touchedB = /* @__PURE__ */ new Set();
+    for (const id of /* @__PURE__ */ new Set([...docsA.keys(), ...docsB.keys()])) {
+      const x = docsA.get(id);
+      const y = docsB.get(id);
+      if (x && y && x.isDeleted === y.isDeleted && sameMockHeads(x, y)) continue;
+      changed += 1;
+      let merged;
+      if (x?.automergeBinary && y?.automergeBinary) {
+        const doc = Automerge.merge(Automerge.load(x.automergeBinary), Automerge.load(y.automergeBinary));
+        merged = { ...x, ...y, attachments: structuredClone(x.attachments ?? y.attachments ?? []) };
+        persistMockAutomergeDocument(merged, doc);
+      } else if (x && y) {
+        merged = structuredClone((x.updatedAt ?? "") >= (y.updatedAt ?? "") ? x : y);
+      } else {
+        merged = structuredClone(x ?? y);
+      }
+      merged.isDeleted = Boolean(x?.isDeleted || y?.isDeleted);
+      merged.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (!x || !sameMockHeads(x, merged) || x.isDeleted !== merged.isDeleted) {
+        docsA.set(id, structuredClone(merged));
+        touchedA.add(id);
+      }
+      if (!y || !sameMockHeads(y, merged) || y.isDeleted !== merged.isDeleted) {
+        docsB.set(id, structuredClone(merged));
+        touchedB.add(id);
+      }
+    }
+    const dbA = stateA.getDatabase(databaseId);
+    const dbB = stateB.getDatabase(databaseId);
+    for (const id of /* @__PURE__ */ new Set([...docsA.keys()])) {
+      if (docsA.get(id)?.isDeleted) continue;
+      for (const [from2, to, touched] of [
+        [dbA, dbB, touchedB],
+        [dbB, dbA, touchedA]
+      ]) {
+        const have = new Set((await to.attachments.list(id).catch(() => [])).map((f) => f.fileName));
+        for (const file of await from2.attachments.list(id).catch(() => [])) {
+          if (have.has(file.fileName)) continue;
+          const reader = await from2.attachments.openReadStream(id, file.fileName);
+          const writer = await to.attachments.openWriteStream(id, file.fileName, file.mimeType);
+          for (let chunk = await reader.read(); chunk !== null; chunk = await reader.read()) await writer.write(chunk);
+          await reader.close();
+          await writer.close();
+          touched.add(id);
+        }
+      }
+    }
+    if (touchedA.size) stateA.notifyReplicaChange(databaseId);
+    if (touchedB.size) stateB.notifyReplicaChange(databaseId);
+  }
+  return changed;
+}
 function createMockMindooDBAppSession(options = {}) {
   const state = createMockSessionState(options);
-  return {
+  const controller = {
     bridge: state.bridge,
     session: state.session,
     getLaunchContext: state.getLaunchContext,
@@ -5125,14 +5839,18 @@ function createMockMindooDBAppSession(options = {}) {
     getDragProfile: state.getDragProfile,
     emitIncomingContent: state.emitIncomingContent,
     listEmbeds: () => state.embedHost.listEmbeds(),
+    getEmbedAccessRequests: () => state.embedHost.getAccessRequests(),
     closeEmbed: (embedId, reason, result) => state.embedHost.closeEmbed(embedId, reason, result),
     setComponents: (components) => state.embedHost.setComponents(components),
     getEmbeddingFinish: () => state.embedHost.getEmbeddingFinish(),
     setEmbedDirty: (embedId, dirty) => state.embedHost.setEmbedDirty(embedId, dirty),
+    setEmbedAgentTools: (embedId, names, toolOptions) => state.embedHost.setEmbedAgentTools(embedId, names, toolOptions),
     failNextEmbedSave: (message) => state.embedHost.failNextSave(message),
     getEmbeddingDirty: () => state.embedHost.getEmbeddingDirty(),
     requestEmbeddingSave: () => state.embedHost.requestEmbeddingSave()
   };
+  replicaStates.set(controller, state);
+  return controller;
 }
 function createMockMindooDBAppBridge(options = {}) {
   return createMockMindooDBAppSession(options);
@@ -5151,6 +5869,7 @@ function createFakeBridgeHost(options = {}) {
     ...options.agentConsent !== void 0 ? { agentConsent: options.agentConsent } : {},
     ...options.agentInvokeTimeoutMs !== void 0 ? { agentInvokeTimeoutMs: options.agentInvokeTimeoutMs } : {},
     appId: () => state.getLaunchContext().appId,
+    embedded: () => Boolean(state.getLaunchContext().embed),
     post(message) {
       const port = [...connectedPorts].pop();
       if (!port) return false;
@@ -5169,6 +5888,11 @@ function createFakeBridgeHost(options = {}) {
       (port) => port.postMessage({ protocol: PROTOCOL, kind: "embed-event", event: { type: "dirty", ...event } })
     );
   });
+  state.embedHost.onAgentTools((event) => {
+    connectedPorts.forEach(
+      (port) => port.postMessage({ protocol: PROTOCOL, kind: "embed-event", event: { type: "agentTools", ...event } })
+    );
+  });
   const embeddingRequests = /* @__PURE__ */ new Map();
   let embeddingRequestCounter = 0;
   const beforeCloseWaiters = /* @__PURE__ */ new Map();
@@ -5409,6 +6133,10 @@ function createFakeBridgeHost(options = {}) {
         const embedId = await state.embedHost.openEmbed(input);
         return input.placement === "frame" && options.embedFrameUrl ? { embedId, frame: { url: options.embedFrameUrl } } : { embedId };
       }
+      case "embeds.requestAccess":
+        return await state.embedHost.embeds.requestAccess(
+          params.input ?? { components: [] }
+        );
       case "embeds.setRect":
         state.embedHost.setRect(String(params.embedId), params.rect);
         return { ok: true };
@@ -5421,9 +6149,18 @@ function createFakeBridgeHost(options = {}) {
       case "embeds.save":
         await state.embedHost.saveEmbed(String(params.embedId));
         return { ok: true };
+      case "embeds.setActive":
+        state.embedHost.setActive(String(params.embedId));
+        return { ok: true };
       case "embedding.setDirty":
         state.embedHost.setEmbeddingDirty(params.dirty === true);
         return { ok: true };
+      case "embedding.lookup":
+        return await state.embedHost.embedding.lookup(String(params.field), {
+          ...typeof params.query === "string" ? { query: params.query } : {},
+          ...Array.isArray(params.docIds) ? { docIds: params.docIds.map(String) } : {},
+          ...typeof params.limit === "number" ? { limit: params.limit } : {}
+        });
       case "embedding.respond": {
         const pending = embeddingRequests.get(String(params.requestId));
         embeddingRequests.delete(String(params.requestId));
@@ -6057,9 +6794,11 @@ function createFakeBridgeHost(options = {}) {
     getDirectoryUsers: state.getDirectoryUsers,
     applyRemoteUpdate: state.applyRemoteUpdate,
     listEmbeds: () => state.embedHost.listEmbeds(),
+    getEmbedAccessRequests: () => state.embedHost.getAccessRequests(),
     closeEmbed: (embedId, reason, result) => state.embedHost.closeEmbed(embedId, reason, result),
     getEmbeddingFinish: () => state.embedHost.getEmbeddingFinish(),
     setEmbedDirty: (embedId, dirty) => state.embedHost.setEmbedDirty(embedId, dirty),
+    setEmbedAgentTools: (embedId, names, toolOptions) => state.embedHost.setEmbedAgentTools(embedId, names, toolOptions),
     failNextEmbedSave: (message) => state.embedHost.failNextSave(message),
     getEmbeddingDirty: () => state.embedHost.getEmbeddingDirty(),
     requestEmbeddingSave() {
@@ -6185,10 +6924,12 @@ function createFakeBridgeHost(options = {}) {
       customRequestHandlers.delete(method);
     }
   };
+  replicaStates.set(controller, state);
   return controller;
 }
 export {
   ALL_CAPABILITIES,
+  DEFAULT_TEST_HOST_USERS,
   MockForbiddenError,
   TEST_HOST_LOCALES,
   capabilitiesForDefinitionPermissions,
@@ -6203,8 +6944,12 @@ export {
   loadMindoodbForTesting,
   mockAgentToolPrefix,
   mockDatabasesFromDefinition,
+  mockReplicaDifferences,
+  modeSwitch,
   mountHavenTestHost,
+  mountTwoUserTestHost,
   previewJson,
   readTestHostUrlSettings,
+  syncMockReplicas,
   validateMockAgentTools
 };