mindoodb-app-sdk 0.0.64 → 0.0.66

package/dist/testing/index.js

@@ -4,7 +4,7 @@ import {
   mindooDBAppComponentFieldsMatch,
   pageUsers,
   releaseMindooDBAppBridgeSessions
-} from "../chunk-BE7LLFFE.js";
+} from "../chunk-B3K3I2S2.js";
 
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
@@ -173,24 +173,24 @@ async function buildVirtualView(mindoodb, definition, documents, categorizationS
         break;
     }
   }
-  const view = await builder.build();
+  const view2 = await builder.build();
   const changes = /* @__PURE__ */ new Map();
   for (const document2 of documents) {
     if (!matchesFilter(mindoodb, definition, document2)) {
       continue;
     }
-    const change = changes.get(document2.origin) ?? new mindoodb.VirtualViewDataChange(document2.origin);
-    change.addEntry(document2.docId, computeColumnValues(definition, document2));
-    changes.set(document2.origin, change);
+    const change2 = changes.get(document2.origin) ?? new mindoodb.VirtualViewDataChange(document2.origin);
+    change2.addEntry(document2.docId, computeColumnValues(definition, document2));
+    changes.set(document2.origin, change2);
   }
-  for (const change of changes.values()) {
-    if (change.hasChanges()) view.applyChanges(change);
+  for (const change2 of changes.values()) {
+    if (change2.hasChanges()) view2.applyChanges(change2);
   }
-  view.getRoot();
-  return view;
+  view2.getRoot();
+  return view2;
 }
-function createCoreNavigator(mindoodb, view, options) {
-  const builder = mindoodb.VirtualViewFactory.createNavigator(view);
+function createCoreNavigator(mindoodb, view2, options) {
+  const builder = mindoodb.VirtualViewFactory.createNavigator(view2);
   const includeCategories = options?.includeCategories ?? true;
   const includeDocuments = options?.includeDocuments ?? true;
   if (!includeCategories && includeDocuments) builder.documentsOnly();
@@ -199,7 +199,7 @@ function createCoreNavigator(mindoodb, view, options) {
   if (Array.isArray(options?.rootCategoryPath) && options.rootCategoryPath.length > 0) {
     builder.fromCategory(options.rootCategoryPath.map((part) => String(part)).join("\\"));
   } else if (options?.rootEntryKey) {
-    const temp = mindoodb.VirtualViewFactory.createSimpleNavigator(view);
+    const temp = mindoodb.VirtualViewFactory.createSimpleNavigator(view2);
     const rootEntry = temp.getPos(options.rootEntryKey);
     if (rootEntry) builder.fromEntry(rootEntry);
   }
@@ -447,13 +447,13 @@ function collectSortedDocIds(entries) {
 async function createEvaluatingViewNavigator(input, documents) {
   const mindoodb = await loadMindoodbForTesting();
   if (!mindoodb) return null;
-  const view = await buildVirtualView(
+  const view2 = await buildVirtualView(
     mindoodb,
     input.definition,
     documents,
     input.categorizationStyle
   );
-  const navigator2 = createCoreNavigator(mindoodb, view, input.options);
+  const navigator2 = createCoreNavigator(mindoodb, view2, input.options);
   return wrapNavigator(input.definition, navigator2);
 }
 
@@ -464,6 +464,8 @@ function createMockEmbedHost(options, getDatabase) {
   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;
@@ -504,11 +506,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 +560,7 @@ function createMockEmbedHost(options, getDatabase) {
     };
     handles.get(embedId)?.settle(event);
     handles.delete(embedId);
+    toolNames.delete(embedId);
     closedListeners.forEach((listener) => listener(event));
     notifyChange();
   }
@@ -558,6 +599,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;
@@ -652,6 +726,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 () => {
@@ -684,6 +761,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 +913,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 +1000,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 +1061,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 +1205,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 +1216,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 +1263,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
@@ -1170,6 +1426,7 @@ function mockDatabasesFromDefinition(definition, seed = {}, options = {}) {
         capabilities: override?.capabilities ? [...new Set(override.capabilities)] : capabilitiesForDefinitionPermissions(database.permissions)
       },
       documents: seed[database.logicalDatabaseId],
+      ...options.automerge ? { automerge: true } : {},
       ...options.attachments === "none" ? {} : { methods: { attachments: createMemoryAttachments() } }
     };
   });
@@ -1190,6 +1447,8 @@ function readTestHostUrlSettings(search) {
   }
   const enforce = params.get("enforce");
   if (enforce !== null) settings.enforceCapabilities = enforce === "1" || enforce === "true";
+  const automerge = params.get("automerge");
+  if (automerge !== null) settings.automerge = automerge === "1" || automerge === "true";
   const users = Number.parseInt(params.get("users") ?? "", 10);
   if (Number.isFinite(users) && users >= 0) settings.directoryUserCount = users;
   const locale = params.get("locale");
@@ -1387,6 +1646,11 @@ function createBrowserTestHost(options) {
       host.setDirectoryUsers(users);
       onChange?.();
     },
+    async applyRemoteUpdate(databaseId, docId, input, updateOptions) {
+      const document2 = await host.applyRemoteUpdate(databaseId, docId, input, updateOptions);
+      onChange?.();
+      return document2;
+    },
     reloadApp,
     dispose() {
       window.removeEventListener("message", onMessage);
@@ -1418,7 +1682,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}
@@ -1486,26 +1750,63 @@ 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: {} };
   const databases = (hostOptions.databases ?? []).filter((database) => url.overrides[database.info.id]?.mapped !== false).map((database) => {
     const capabilities = url.overrides[database.info.id]?.capabilities;
     return capabilities ? { ...database, info: { ...database.info, capabilities } } : database;
-  });
+  }).map((database) => url.automerge === void 0 ? database : { ...database, automerge: url.automerge });
   const launchContext = {
     ...hostOptions.launchContext,
     ...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";
@@ -1592,8 +1893,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();
@@ -1723,6 +2024,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";
@@ -2075,8 +2377,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);
@@ -2087,50 +2389,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(".")}`
       );
     }
   }
@@ -2343,23 +2645,23 @@ function mergeLaunchContext(current, patch) {
         ...database,
         capabilities: [...database.capabilities]
       })),
-      views: current.views.map((view) => ({
-        ...view,
-        sources: view.sources.map((source) => ({ ...source })),
-        columns: view.columns.map((column) => ({
+      views: current.views.map((view2) => ({
+        ...view2,
+        sources: view2.sources.map((source) => ({ ...source })),
+        columns: view2.columns.map((column) => ({
           ...column,
           expression: column.expression.mode === "field" ? { ...column.expression } : {
             mode: "formula",
             expression: structuredClone(column.expression.expression)
           }
         })),
-        filter: view.filter.mode === "rules" ? {
+        filter: view2.filter.mode === "rules" ? {
           mode: "rules",
-          match: view.filter.match,
-          rules: view.filter.rules.map((rule) => ({ ...rule }))
+          match: view2.filter.match,
+          rules: view2.filter.rules.map((rule) => ({ ...rule }))
         } : {
           mode: "formula",
-          expression: structuredClone(view.filter.expression)
+          expression: structuredClone(view2.filter.expression)
         }
       }))
     };
@@ -2381,41 +2683,41 @@ function mergeLaunchContext(current, patch) {
       ...database,
       capabilities: [...database.capabilities]
     })),
-    views: patch.views ? patch.views.map((view) => ({
-      ...view,
-      sources: view.sources.map((source) => ({ ...source })),
-      columns: view.columns.map((column) => ({
+    views: patch.views ? patch.views.map((view2) => ({
+      ...view2,
+      sources: view2.sources.map((source) => ({ ...source })),
+      columns: view2.columns.map((column) => ({
         ...column,
         expression: column.expression.mode === "field" ? { ...column.expression } : {
           mode: "formula",
           expression: structuredClone(column.expression.expression)
         }
       })),
-      filter: view.filter.mode === "rules" ? {
+      filter: view2.filter.mode === "rules" ? {
         mode: "rules",
-        match: view.filter.match,
-        rules: view.filter.rules.map((rule) => ({ ...rule }))
+        match: view2.filter.match,
+        rules: view2.filter.rules.map((rule) => ({ ...rule }))
       } : {
         mode: "formula",
-        expression: structuredClone(view.filter.expression)
+        expression: structuredClone(view2.filter.expression)
       }
-    })) : current.views.map((view) => ({
-      ...view,
-      sources: view.sources.map((source) => ({ ...source })),
-      columns: view.columns.map((column) => ({
+    })) : current.views.map((view2) => ({
+      ...view2,
+      sources: view2.sources.map((source) => ({ ...source })),
+      columns: view2.columns.map((column) => ({
         ...column,
         expression: column.expression.mode === "field" ? { ...column.expression } : {
           mode: "formula",
           expression: structuredClone(column.expression.expression)
         }
       })),
-      filter: view.filter.mode === "rules" ? {
+      filter: view2.filter.mode === "rules" ? {
         mode: "rules",
-        match: view.filter.match,
-        rules: view.filter.rules.map((rule) => ({ ...rule }))
+        match: view2.filter.match,
+        rules: view2.filter.rules.map((rule) => ({ ...rule }))
       } : {
         mode: "formula",
-        expression: structuredClone(view.filter.expression)
+        expression: structuredClone(view2.filter.expression)
       }
     }))
   };
@@ -2506,9 +2808,12 @@ function mockDecryptionKeyId(document2) {
   }
   return { decryptionKeyId: document2.decryptionKeyId };
 }
-function loadMockAutomergeDocument(document2) {
+function loadMockAutomergeDocument(document2, actor) {
   if (document2.automergeBinary) {
-    return Automerge.load(document2.automergeBinary);
+    return Automerge.load(
+      document2.automergeBinary,
+      actor ? { actor } : void 0
+    );
   }
   const initialDoc = Automerge.from({
     ...structuredClone(document2.data),
@@ -2519,11 +2824,646 @@ function loadMockAutomergeDocument(document2) {
 }
 function persistMockAutomergeDocument(document2, automergeDoc) {
   document2.automergeBinary = Automerge.save(automergeDoc);
-  document2.data = structuredClone(automergeDoc);
+  document2.data = projectMockAutomergeValue(
+    Automerge.load(document2.automergeBinary)
+  );
   document2.heads = Automerge.getHeads(automergeDoc);
 }
-function getFieldValue2(source, field) {
-  return field.split(".").reduce((current, part) => {
+var MOCK_AUTOMERGE_SEED_ACTOR = "5eed0000000000000000000000000000";
+var MOCK_AUTOMERGE_LOCAL_ACTOR = "10ca1000000000000000000000000000";
+var MOCK_AUTOMERGE_REMOTE_ACTOR = "2e307e00000000000000000000000000";
+function projectMockAutomergeValue(value, depth = 0) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Automerge.isCounter(value)) {
+    return value.value;
+  }
+  if (Automerge.isImmutableString(value)) {
+    return String(value);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof Uint8Array) {
+    return value.slice();
+  }
+  if (depth > 100) {
+    throw new Error("Document value is nested too deeply");
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => projectMockAutomergeValue(entry, depth + 1));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      projectMockAutomergeValue(entry, depth + 1)
+    ])
+  );
+}
+function hydrateMockAutomergeValues(value, depth = 0) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (depth > 100) {
+    throw new Error("Document value is nested too deeply");
+  }
+  if (value instanceof Uint8Array || value instanceof Date || Automerge.isCounter(value) || Automerge.isImmutableString(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => entry === void 0 ? null : hydrateMockAutomergeValues(entry, depth + 1)
+    );
+  }
+  const record = value;
+  if (Object.prototype.hasOwnProperty.call(record, MINDOODB_APP_VALUE_TAG)) {
+    switch (record[MINDOODB_APP_VALUE_TAG]) {
+      case "atomic":
+        if (typeof record.value !== "string") {
+          throw new Error('Typed value "atomic" needs a string value');
+        }
+        return new Automerge.ImmutableString(record.value);
+      case "counter":
+        assertMockCounterAmount(record.value, 'Typed value "counter"');
+        return new Automerge.Counter(record.value);
+      case "timestamp":
+        return new Date(toMockTimestamp(record.value));
+      default:
+        throw new Error(
+          `Unknown typed value ${JSON.stringify(record[MINDOODB_APP_VALUE_TAG])}; the "${MINDOODB_APP_VALUE_TAG}" key is reserved`
+        );
+    }
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(record)) {
+    if (entry !== void 0) {
+      result[key] = hydrateMockAutomergeValues(entry, depth + 1);
+    }
+  }
+  return result;
+}
+function createMockAutomergeDocument(values, actor, time) {
+  const entries = Object.entries(values).filter(([, value]) => value !== void 0);
+  const initial = Automerge.init({ actor });
+  const options = time === void 0 ? {} : { time };
+  if (entries.length === 0) {
+    return Automerge.emptyChange(initial, options);
+  }
+  return Automerge.change(initial, options, (doc) => {
+    for (const [key, value] of entries) {
+      doc[key] = hydrateMockAutomergeValues(value);
+    }
+  });
+}
+function validateMockJsonPath(path, label) {
+  if (!Array.isArray(path) || path.length === 0) {
+    throw new Error(`${label} path must contain at least one segment`);
+  }
+  for (const segment of path) {
+    if (typeof segment !== "string" && typeof segment !== "number") {
+      throw new Error(`${label} path segments must be strings or numbers`);
+    }
+  }
+}
+function assertMockNonNegativeInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+}
+function validateMockJsonPatch(patch) {
+  const operationCount = (patch.set?.length ?? 0) + (patch.unset?.length ?? 0) + (patch.listDelete?.length ?? 0) + (patch.listInsert?.length ?? 0) + (patch.textSplice?.length ?? 0) + (patch.textMark?.length ?? 0) + (patch.textUnmark?.length ?? 0) + (patch.counterIncrement?.length ?? 0);
+  if (operationCount === 0) {
+    throw new Error("JSON patch must include at least one operation");
+  }
+  for (const operation2 of patch.set ?? []) {
+    validateMockJsonPath(operation2.path, "JSON set");
+    hydrateMockAutomergeValues(operation2.value);
+  }
+  for (const operation2 of patch.unset ?? []) {
+    validateMockJsonPath(operation2.path, "JSON unset");
+  }
+  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 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(operation2.values);
+  }
+  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 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 operation2 of patch.counterIncrement ?? []) {
+    validateMockJsonPath(operation2.path, "JSON counterIncrement");
+    assertMockCounterAmount(operation2.delta, "JSON counterIncrement delta");
+  }
+}
+function ensureMockAutomergeParent(target, path) {
+  let parent = target;
+  for (let index = 0; index < path.length - 1; index += 1) {
+    const segment = path[index];
+    const nextSegment = path[index + 1];
+    if (parent[segment] === void 0 || parent[segment] === null) {
+      parent[segment] = typeof nextSegment === "number" ? [] : {};
+    }
+    parent = parent[segment];
+    if (parent === null || typeof parent !== "object") {
+      throw new Error(
+        `Cannot apply JSON patch through non-object path segment '${String(segment)}'`
+      );
+    }
+  }
+  return parent;
+}
+function readMockAutomergeValue(target, path) {
+  let value = target;
+  for (const segment of path) {
+    value = value?.[segment];
+  }
+  return value;
+}
+function setMockAutomergeValue(target, path, value) {
+  const parent = ensureMockAutomergeParent(target, path);
+  parent[path[path.length - 1]] = value;
+}
+function unsetMockAutomergeValue(target, path) {
+  let parent = target;
+  for (let index = 0; index < path.length - 1; index += 1) {
+    parent = parent?.[path[index]];
+    if (parent === null || typeof parent !== "object") {
+      return;
+    }
+  }
+  delete parent[path[path.length - 1]];
+}
+function readMockAutomergeList(target, path) {
+  const value = readMockAutomergeValue(target, path);
+  if (!Array.isArray(value)) {
+    throw new Error(
+      `Cannot apply JSON list operation to non-array value at '${path.map(String).join(".")}'`
+    );
+  }
+  return value;
+}
+function ensureMockAutomergeList(target, path) {
+  const parent = ensureMockAutomergeParent(target, path);
+  const leaf = path[path.length - 1];
+  if (parent[leaf] === void 0 || parent[leaf] === null) {
+    parent[leaf] = [];
+  }
+  return readMockAutomergeList(target, path);
+}
+function clampMockIndex(index, length) {
+  if (!Number.isFinite(index)) {
+    return length;
+  }
+  return Math.max(0, Math.min(Math.trunc(index), length));
+}
+function ensureMockAutomergeText(target, path, label) {
+  const value = readMockAutomergeValue(target, path);
+  if (value === void 0 || value === null) {
+    setMockAutomergeValue(target, path, "");
+  } else if (typeof value !== "string") {
+    throw new Error(
+      `Cannot apply ${label} to non-string value at '${path.map(String).join(".")}'`
+    );
+  }
+}
+function spliceMockAutomergeText(target, path, index, deleteCount, insert) {
+  const text = readMockAutomergeValue(target, path);
+  const length = typeof text === "string" ? text.length : 0;
+  const start = clampMockIndex(index, length);
+  Automerge.splice(
+    target,
+    path,
+    start,
+    Math.max(0, Math.min(deleteCount, length - start)),
+    insert
+  );
+}
+function reviveMockRichTextValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => reviveMockRichTextValue(entry));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const record = value;
+  if (record.type === "immutableString" && typeof record.value === "string") {
+    return new Automerge.ImmutableString(record.value);
+  }
+  return Object.fromEntries(
+    Object.entries(record).map(([key, entry]) => [key, reviveMockRichTextValue(entry)])
+  );
+}
+function applyMockAutomergeJsonOperations(target, patch) {
+  for (const operation2 of patch.set ?? []) {
+    setMockAutomergeValue(target, operation2.path, hydrateMockAutomergeValues(operation2.value));
+  }
+  for (const operation2 of patch.unset ?? []) {
+    unsetMockAutomergeValue(target, operation2.path);
+  }
+  for (const operation2 of patch.listDelete ?? []) {
+    readMockAutomergeList(target, operation2.path).splice(operation2.index, operation2.deleteCount);
+  }
+  for (const operation2 of patch.listInsert ?? []) {
+    ensureMockAutomergeList(target, operation2.path).splice(
+      operation2.index,
+      0,
+      ...hydrateMockAutomergeValues(operation2.values)
+    );
+  }
+  for (const operation2 of patch.textSplice ?? []) {
+    ensureMockAutomergeText(target, operation2.path, "JSON textSplice");
+    spliceMockAutomergeText(
+      target,
+      operation2.path,
+      operation2.index,
+      operation2.deleteCount,
+      operation2.insert ?? ""
+    );
+  }
+  for (const operation2 of patch.textMark ?? []) {
+    for (const [name, value] of Object.entries(operation2.marks)) {
+      Automerge.mark(
+        target,
+        operation2.path,
+        { start: operation2.index, end: operation2.index + operation2.length, expand: "none" },
+        name,
+        reviveMockRichTextValue(value)
+      );
+    }
+  }
+  for (const operation2 of patch.textUnmark ?? []) {
+    for (const name of operation2.names) {
+      Automerge.unmark(
+        target,
+        operation2.path,
+        { start: operation2.index, end: operation2.index + operation2.length, expand: "none" },
+        name
+      );
+    }
+  }
+  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(operation2.delta);
+    } else if (Automerge.isCounter(existing)) {
+      existing.increment(operation2.delta);
+    } else {
+      throw new Error(
+        `Cannot increment non-counter value at '${operation2.path.map(String).join(".")}'; create it with MindooValue.counter() first`
+      );
+    }
+  }
+}
+function changeMockAutomergeDocument(doc, baseHeads, apply) {
+  if (baseHeads && baseHeads.length > 0) {
+    const { newDoc } = Automerge.changeAt(doc, baseHeads, apply);
+    return Automerge.load(Automerge.save(newDoc), { actor: Automerge.getActorId(doc) });
+  }
+  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) => {
+      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) {
+    const json = patch.json;
+    validateMockJsonPatch(json);
+    next = changeMockAutomergeDocument(
+      next,
+      json.baseHeads,
+      (target) => applyMockAutomergeJsonOperations(target, json)
+    );
+  }
+  for (const textPatch of patch.text ?? []) {
+    validateMockJsonPath(textPatch.path, "Text patch");
+    next = changeMockAutomergeDocument(next, textPatch.baseHeads, (target) => {
+      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 ?? []) {
+    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 ?? []) {
+    validateMockRichTextStepPatch(stepPatch);
+    next = changeMockAutomergeDocument(next, stepPatch.baseHeads, (target) => {
+      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)
+            );
+          }
+        }
+      }
+    });
+  }
+  return next;
+}
+function forkMockAutomergeDocument(doc, baseHeads, actor) {
+  if (!baseHeads || baseHeads.length === 0) {
+    return Automerge.clone(doc, { actor });
+  }
+  const heads = new Set(baseHeads);
+  let ownLatest;
+  for (const change2 of Automerge.getAllChanges(doc)) {
+    const decoded = Automerge.decodeChange(change2);
+    if (decoded.actor === actor) {
+      ownLatest = decoded.hash;
+    }
+  }
+  if (ownLatest) {
+    heads.add(ownLatest);
+  }
+  return Automerge.clone(Automerge.view(doc, [...heads]), { actor });
+}
+function getFieldValue2(source, field2) {
+  return field2.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
       return current[part];
     }
@@ -2535,7 +3475,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) {
@@ -2612,7 +3552,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("_"))
     )
@@ -2842,7 +3782,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;
@@ -3370,13 +4310,22 @@ 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 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 storedDocuments = /* @__PURE__ */ new Map();
+  const automergeMode = definition.automerge === true;
+  let changeSequence = 0;
+  const changedAt = /* @__PURE__ */ new Map();
+  const storedDocuments = new class extends Map {
+    set(id, document2) {
+      changedAt.set(id, ++changeSequence);
+      return super.set(id, document2);
+    }
+  }();
   for (const seed of definition.documents ?? []) {
-    storedDocuments.set(seed.id, {
+    const stored = {
       id: seed.id,
       data: structuredClone(seed.data),
       heads: seed.heads ? [...seed.heads] : void 0,
@@ -3387,7 +4336,14 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       decryptionKeyId: seed.decryptionKeyId,
       authorLabel: seed.authorLabel,
       createdAt: seed.createdAt
-    });
+    };
+    if (automergeMode) {
+      persistMockAutomergeDocument(
+        stored,
+        createMockAutomergeDocument(seed.data, MOCK_AUTOMERGE_SEED_ACTOR, 0)
+      );
+    }
+    storedDocuments.set(seed.id, stored);
   }
   const liveQuerySubscriptions = /* @__PURE__ */ new Set();
   const refreshLiveQueries = () => {
@@ -3430,6 +4386,15 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       throw new Error("Recipient mutators require a document created with `recipients`");
     }
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (automergeMode) {
+      return writeAutomergeDocument(
+        docId,
+        existing,
+        Automerge.change(loadMockAutomergeDocument(existing, localActor), (target) => {
+          target._encryptFor = hydrateMockAutomergeValues(nextEncryptFor);
+        })
+      );
+    }
     const updated = {
       id: docId,
       data: { ...existing.data, _encryptFor: nextEncryptFor },
@@ -3448,6 +4413,28 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     notifyLiveQueries();
     return updated;
   }
+  function writeAutomergeDocument(docId, existing, automergeDoc) {
+    const stored = {
+      ...existing ?? {},
+      id: docId,
+      data: {},
+      attachments: existing?.attachments ? structuredClone(existing.attachments) : [],
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isDeleted: false,
+      decryptionKeyId: existing?.decryptionKeyId ?? "default"
+    };
+    persistMockAutomergeDocument(stored, automergeDoc);
+    storedDocuments.set(docId, stored);
+    notifyLiveQueries();
+    return {
+      id: docId,
+      data: structuredClone(stored.data),
+      heads: [...stored.heads ?? []],
+      attachments: structuredClone(stored.attachments ?? []),
+      updatedAt: stored.updatedAt,
+      ...mockDecryptionKeyId(stored)
+    };
+  }
   const defaultDocuments = {
     async query(query) {
       return runMockDocumentQuery(
@@ -3500,12 +4487,17 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       const offset = decodeMockListCursor(query?.cursor) + skip;
       const metadataOnly = query?.metadataOnly ?? false;
       const idPrefix = query?.idPrefix;
-      const items = Array.from(storedDocuments.values()).filter((document2) => !document2.inaccessible).filter(
+      const after = automergeMode ? decodeMockListCursor(query?.cursor) : 0;
+      const items = Array.from(storedDocuments.values()).filter((document2) => !automergeMode || (changedAt.get(document2.id) ?? 0) > after).filter((document2) => !document2.inaccessible).filter(
         (document2) => status === "all" ? true : status === "deleted" ? document2.isDeleted : !document2.isDeleted
       ).filter((document2) => matchesMockIdPrefix(document2.id, idPrefix)).filter(
         (document2) => metadataOnly ? true : matchesDocumentFilter(document2, query?.filter)
-      ).sort((left, right) => left.id.localeCompare(right.id));
-      const page = items.slice(offset, offset + limit).map((document2) => {
+      ).sort(
+        (left, right) => automergeMode ? (changedAt.get(left.id) ?? 0) - (changedAt.get(right.id) ?? 0) : left.id.localeCompare(right.id)
+      );
+      const pageStart = automergeMode ? skip : offset;
+      const pageDocuments = items.slice(pageStart, pageStart + limit);
+      const page = pageDocuments.map((document2) => {
         if (metadataOnly) {
           return {
             id: document2.id,
@@ -3513,9 +4505,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 {
@@ -3526,6 +4518,13 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           isDeleted: status !== "existing" ? document2.isDeleted : void 0
         };
       });
+      if (automergeMode) {
+        const last = pageDocuments[pageDocuments.length - 1];
+        return {
+          items: page,
+          nextCursor: last ? String(changedAt.get(last.id) ?? after) : null
+        };
+      }
       const nextCursor = offset + page.length < items.length ? String(offset + page.length) : null;
       return {
         items: page,
@@ -3534,7 +4533,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     },
     async getHeadCursor() {
       return {
-        cursor: String(storedDocuments.size)
+        cursor: String(automergeMode ? changeSequence : storedDocuments.size)
       };
     },
     async listInaccessible(query) {
@@ -3569,7 +4568,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
@@ -3630,7 +4629,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       const currentDoc = loadMockAutomergeDocument(document2);
       const [mergedDoc] = Automerge.applyChanges(
         currentDoc,
-        patch.changes.map((change) => new Uint8Array(change))
+        patch.changes.map((change2) => new Uint8Array(change2))
       );
       persistMockAutomergeDocument(document2, mergedDoc);
       document2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -3643,7 +4642,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
         );
         changesSince = {
           sinceHeads: [...patch.replicaHeads],
-          changes: missingChanges.map((change) => cloneBytes(new Uint8Array(change)))
+          changes: missingChanges.map((change2) => cloneBytes(new Uint8Array(change2)))
         };
       }
       return {
@@ -3680,7 +4679,10 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           if (existing.isDeleted) {
             existing.isDeleted = false;
             existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            existing.heads = [`mock-head-${++changeCounter}`];
+            if (!automergeMode) {
+              existing.heads = [`mock-head-${++changeCounter}`];
+            }
+            storedDocuments.set(callerId, existing);
             notifyLiveQueries();
           }
           return {
@@ -3698,10 +4700,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)) {
@@ -3709,11 +4711,39 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           "recipients: [] with includeSelf: false would produce a document nobody can read"
         );
       }
+      const encryptFor = Array.isArray(input.recipients) ? { _encryptFor: mockEncryptForMap(input.recipients) } : {};
+      if (automergeMode) {
+        const stored2 = {
+          id,
+          data: {},
+          attachments: [],
+          updatedAt: createdAt,
+          isDeleted: false,
+          decryptionKeyId: input.decryptionKeyId ?? "default"
+        };
+        persistMockAutomergeDocument(
+          stored2,
+          createMockAutomergeDocument(
+            { ...input.set ?? {}, ...encryptFor },
+            localActor
+          )
+        );
+        storedDocuments.set(id, stored2);
+        notifyLiveQueries();
+        return {
+          id,
+          data: structuredClone(stored2.data),
+          heads: [...stored2.heads ?? []],
+          attachments: [],
+          updatedAt: createdAt,
+          ...mockDecryptionKeyId(stored2)
+        };
+      }
       const created = {
         id,
         data: {
           ...readMockTypedValues(input.set ?? {}),
-          ...Array.isArray(input.recipients) ? { _encryptFor: mockEncryptForMap(input.recipients) } : {}
+          ...encryptFor
         },
         heads: [`mock-head-${++changeCounter}`],
         attachments: [],
@@ -3744,6 +4774,10 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     async update(docId, patch) {
       const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       const existing = storedDocuments.get(docId);
+      if (automergeMode) {
+        const current = existing?.automergeBinary ? loadMockAutomergeDocument(existing, localActor) : createMockAutomergeDocument(existing?.data ?? {}, localActor);
+        return writeAutomergeDocument(docId, existing, applyMockAutomergeUpdate(current, patch));
+      }
       const updated = {
         id: docId,
         data: applyDocumentUpdatePatch(existing?.data ?? {}, patch),
@@ -3830,7 +4864,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
         storedDocuments.set(_docId, {
           ...existing,
           isDeleted: false,
-          heads: [`mock-head-${++changeCounter}`],
+          heads: automergeMode ? existing.heads : [`mock-head-${++changeCounter}`],
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         notifyLiveQueries();
@@ -4054,7 +5088,26 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       createdAt: document2.updatedAt ?? null
     })),
     documents: storedDocuments,
-    notifyLiveQueries: refreshLiveQueries
+    notifyLiveQueries: refreshLiveQueries,
+    async applyRemoteUpdate(docId, input, options) {
+      const existing = storedDocuments.get(docId);
+      if (!existing || existing.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      if (!automergeMode || !existing.automergeBinary) {
+        return await defaultDocuments.update(docId, input);
+      }
+      const current = loadMockAutomergeDocument(existing, localActor);
+      const remote = applyMockAutomergeUpdate(
+        forkMockAutomergeDocument(
+          current,
+          input.json?.baseHeads,
+          options?.actor ?? MOCK_AUTOMERGE_REMOTE_ACTOR
+        ),
+        input.json ? { ...input, json: { ...input.json, baseHeads: void 0 } } : input
+      );
+      return writeAutomergeDocument(docId, existing, Automerge.merge(current, remote));
+    }
   };
 }
 function createMockSessionState(options = {}) {
@@ -4080,6 +5133,7 @@ function createMockSessionState(options = {}) {
   const databaseViewDocumentLists = /* @__PURE__ */ new Map();
   const databaseDocumentStores = /* @__PURE__ */ new Map();
   const databaseLiveQueryRefreshers = /* @__PURE__ */ new Map();
+  const databaseRemoteUpdaters = /* @__PURE__ */ new Map();
   const databasePeers = {
     getDocuments: (databaseId) => databaseDocumentStores.get(databaseId),
     refreshAllLiveQueries: () => {
@@ -4170,12 +5224,18 @@ function createMockSessionState(options = {}) {
     databaseViewApis.clear();
     databaseDocumentStores.clear();
     databaseLiveQueryRefreshers.clear();
+    databaseRemoteUpdaters.clear();
     databaseInfos = definitions.map((definition) => ({
       ...definition.info,
       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,
@@ -4188,35 +5248,49 @@ function createMockSessionState(options = {}) {
       databaseViewDocumentLists.set(definition.info.id, created.listViewDocuments);
       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 ?? {}
       });
@@ -4310,15 +5384,20 @@ function createMockSessionState(options = {}) {
           `Unknown test database for view creation: ${firstDatabaseId}`
         );
       }
-      const view = await api.create(input);
+      const view2 = await api.create(input);
       const viewId = input.definition.id || crypto.randomUUID();
-      sessionViews.set(viewId, view);
-      return view;
+      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(
         (view2) => view2.id === viewId
@@ -4332,9 +5411,7 @@ function createMockSessionState(options = {}) {
           `Unknown test database for view ${viewId}: ${sourceDatabaseId}`
         );
       }
-      const view = await api.open(viewId, options2);
-      sessionViews.set(viewId, view);
-      return view;
+      return await api.open(viewId, options2);
     },
     menus,
     drag,
@@ -4463,6 +5540,8 @@ function createMockSessionState(options = {}) {
       directoryUsers = [...users];
     },
     getDirectoryUsers: () => [...directoryUsers],
+    replicaStores: () => databaseDocumentStores,
+    notifyReplicaChange: (databaseId) => databaseLiveQueryRefreshers.get(databaseId)?.(),
     embedHost,
     getDatabase(databaseId) {
       const database = databaseHandles.get(databaseId);
@@ -4471,6 +5550,13 @@ function createMockSessionState(options = {}) {
       }
       return database;
     },
+    async applyRemoteUpdate(databaseId, docId, input, updateOptions) {
+      const applyRemoteUpdate = databaseRemoteUpdaters.get(databaseId);
+      if (!applyRemoteUpdate) {
+        throw new Error(`Unknown test database: ${databaseId}`);
+      }
+      return await applyRemoteUpdate(docId, input, updateOptions);
+    },
     getLicensedProducts() {
       return [...launchContext.licensedProducts ?? []];
     },
@@ -4573,9 +5659,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,
@@ -4587,6 +5756,7 @@ function createMockMindooDBAppSession(options = {}) {
     setCapabilities: state.setCapabilities,
     setEnforceCapabilities: state.setEnforceCapabilities,
     setDirectoryUsers: state.setDirectoryUsers,
+    applyRemoteUpdate: state.applyRemoteUpdate,
     emitThemeChange: state.emitThemeChange,
     emitViewportChange: state.emitViewportChange,
     emitUiPreferencesChange: state.emitUiPreferencesChange,
@@ -4603,10 +5773,13 @@ function createMockMindooDBAppSession(options = {}) {
     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);
@@ -4625,6 +5798,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;
@@ -4643,6 +5817,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();
@@ -4895,9 +6074,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));
@@ -5529,10 +6717,12 @@ function createFakeBridgeHost(options = {}) {
     getEnforceCapabilities: state.getEnforceCapabilities,
     setDirectoryUsers: state.setDirectoryUsers,
     getDirectoryUsers: state.getDirectoryUsers,
+    applyRemoteUpdate: state.applyRemoteUpdate,
     listEmbeds: () => state.embedHost.listEmbeds(),
     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() {
@@ -5658,10 +6848,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,
@@ -5676,8 +6868,12 @@ export {
   loadMindoodbForTesting,
   mockAgentToolPrefix,
   mockDatabasesFromDefinition,
+  mockReplicaDifferences,
+  modeSwitch,
   mountHavenTestHost,
+  mountTwoUserTestHost,
   previewJson,
   readTestHostUrlSettings,
+  syncMockReplicas,
   validateMockAgentTools
 };