mindoodb-app-sdk 0.0.63 → 0.0.65

package/dist/testing/index.js

@@ -102,7 +102,7 @@ function getCategoryPath(entry) {
   }
   return path;
 }
-function serializeEntry(navigator, entry) {
+function serializeEntry(navigator2, entry) {
   const parent = entry.getParent();
   return {
     key: entry.getPositionStr(),
@@ -122,8 +122,8 @@ function serializeEntry(navigator, entry) {
     childCategoryCount: entry.getChildCategoryCount(),
     childDocumentCount: entry.getChildDocumentCount(),
     position: entry.getPositionStr(),
-    expanded: entry.isCategory() ? navigator.isExpanded(entry) : false,
-    selected: navigator.isSelected(entry.origin, entry.docId),
+    expanded: entry.isCategory() ? navigator2.isExpanded(entry) : false,
+    selected: navigator2.isSelected(entry.origin, entry.docId),
     isVisible: true
   };
 }
@@ -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);
   }
@@ -208,21 +208,21 @@ function createCoreNavigator(mindoodb, view, options) {
 function normalizePageLimit(limit) {
   return Math.max(1, Math.min(1e3, Math.trunc(limit ?? 100)));
 }
-function pageEntries(navigator, direction, options = {}) {
+function pageEntries(navigator2, direction, options = {}) {
   const entries = [];
-  const startOk = options.startPosition ? navigator.gotoPos(options.startPosition) : direction === "forward" ? navigator.gotoFirst() : navigator.gotoLast();
+  const startOk = options.startPosition ? navigator2.gotoPos(options.startPosition) : direction === "forward" ? navigator2.gotoFirst() : navigator2.gotoLast();
   if (!startOk) {
     return { entries, nextPosition: null, hasMore: false };
   }
   const moveNext = () => {
     if (direction === "forward") {
-      return options.selectedOnly ? navigator.gotoNextSelected() : navigator.gotoNext();
+      return options.selectedOnly ? navigator2.gotoNextSelected() : navigator2.gotoNext();
     }
-    return options.selectedOnly ? navigator.gotoPrevSelected() : navigator.gotoPrev();
+    return options.selectedOnly ? navigator2.gotoPrevSelected() : navigator2.gotoPrev();
   };
   if (options.selectedOnly) {
-    const current = navigator.getCurrentEntry();
-    if (!current || !navigator.isSelected(current.origin, current.docId)) {
+    const current = navigator2.getCurrentEntry();
+    if (!current || !navigator2.isSelected(current.origin, current.docId)) {
       if (!moveNext()) return { entries, nextPosition: null, hasMore: false };
     }
   }
@@ -230,26 +230,26 @@ function pageEntries(navigator, direction, options = {}) {
   let nextPosition = null;
   let hasMore = false;
   while (true) {
-    const current = navigator.getCurrentEntry();
+    const current = navigator2.getCurrentEntry();
     if (!current) break;
-    entries.push(serializeEntry(navigator, current));
+    entries.push(serializeEntry(navigator2, current));
     if (entries.length >= limit) {
       hasMore = moveNext();
-      nextPosition = hasMore ? navigator.getCurrentEntry()?.getPositionStr() ?? null : null;
+      nextPosition = hasMore ? navigator2.getCurrentEntry()?.getPositionStr() ?? null : null;
       break;
     }
     if (!moveNext()) break;
   }
   return { entries, nextPosition, hasMore };
 }
-function resolveEntry(navigator, entryKey) {
-  const entry = navigator.getPos(entryKey);
+function resolveEntry(navigator2, entryKey) {
+  const entry = navigator2.getPos(entryKey);
   if (!entry) {
     throw new Error(`Unknown view entry: ${entryKey}`);
   }
   return entry;
 }
-function wrapNavigator(definition, navigator) {
+function wrapNavigator(definition, navigator2) {
   const updateListeners = /* @__PURE__ */ new Set();
   let viewCursor = null;
   return {
@@ -267,164 +267,164 @@ function wrapNavigator(definition, navigator) {
       return () => updateListeners.delete(listener);
     },
     async getCurrentEntry() {
-      const entry = navigator.getCurrentEntry();
-      return entry ? serializeEntry(navigator, entry) : null;
+      const entry = navigator2.getCurrentEntry();
+      return entry ? serializeEntry(navigator2, entry) : null;
     },
     async gotoFirst() {
-      return navigator.gotoFirst();
+      return navigator2.gotoFirst();
     },
     async gotoLast() {
-      return navigator.gotoLast();
+      return navigator2.gotoLast();
     },
     async gotoNext() {
-      return navigator.gotoNext();
+      return navigator2.gotoNext();
     },
     async gotoPrev() {
-      return navigator.gotoPrev();
+      return navigator2.gotoPrev();
     },
     async gotoNextSibling() {
-      return navigator.gotoNextSibling();
+      return navigator2.gotoNextSibling();
     },
     async gotoPrevSibling() {
-      return navigator.gotoPrevSibling();
+      return navigator2.gotoPrevSibling();
     },
     async gotoParent() {
-      return navigator.gotoParent();
+      return navigator2.gotoParent();
     },
     async gotoFirstChild() {
-      return navigator.gotoFirstChild();
+      return navigator2.gotoFirstChild();
     },
     async gotoLastChild() {
-      return navigator.gotoLastChild();
+      return navigator2.gotoLastChild();
     },
     async gotoPos(position) {
-      return navigator.gotoPos(position);
+      return navigator2.gotoPos(position);
     },
     async getPos(position) {
-      const entry = navigator.getPos(position);
-      return entry ? serializeEntry(navigator, entry) : null;
+      const entry = navigator2.getPos(position);
+      return entry ? serializeEntry(navigator2, entry) : null;
     },
     async findCategoryEntryByParts(parts) {
-      const entry = navigator.findCategoryEntryByParts(parts);
-      return entry ? serializeEntry(navigator, entry) : null;
+      const entry = navigator2.findCategoryEntryByParts(parts);
+      return entry ? serializeEntry(navigator2, entry) : null;
     },
     async entriesForward(options) {
-      return pageEntries(navigator, "forward", options);
+      return pageEntries(navigator2, "forward", options);
     },
     async entriesBackward(options) {
-      return pageEntries(navigator, "backward", options);
+      return pageEntries(navigator2, "backward", options);
     },
     async gotoNextSelected() {
-      return navigator.gotoNextSelected();
+      return navigator2.gotoNextSelected();
     },
     async gotoPrevSelected() {
-      return navigator.gotoPrevSelected();
+      return navigator2.gotoPrevSelected();
     },
     async select(origin, docId, selectParentCategories = false) {
-      navigator.select(origin, docId, selectParentCategories);
+      navigator2.select(origin, docId, selectParentCategories);
     },
     async deselect(origin, docId) {
-      navigator.deselect(origin, docId);
+      navigator2.deselect(origin, docId);
     },
     async selectAllEntries() {
-      navigator.selectAllEntries();
+      navigator2.selectAllEntries();
     },
     async deselectAllEntries() {
-      navigator.deselectAllEntries();
+      navigator2.deselectAllEntries();
     },
     async isSelected(origin, docId) {
-      return navigator.isSelected(origin, docId);
+      return navigator2.isSelected(origin, docId);
     },
     async getSelectionState() {
       return {
-        selectAllByDefault: navigator.isSelectAllByDefault(),
-        entryKeys: Array.from(navigator.getSelectedOrDeselectedEntries())
+        selectAllByDefault: navigator2.isSelectAllByDefault(),
+        entryKeys: Array.from(navigator2.getSelectedOrDeselectedEntries())
       };
     },
     async setSelectionState(state) {
-      if (state.selectAllByDefault) navigator.selectAllEntries();
-      else navigator.deselectAllEntries();
-      navigator.setSelectedOrDeselectedEntries(new Set(state.entryKeys));
+      if (state.selectAllByDefault) navigator2.selectAllEntries();
+      else navigator2.deselectAllEntries();
+      navigator2.setSelectedOrDeselectedEntries(new Set(state.entryKeys));
     },
     async expand(origin, docId) {
-      navigator.expand(origin, docId);
+      navigator2.expand(origin, docId);
     },
     async collapse(origin, docId) {
-      navigator.collapse(origin, docId);
+      navigator2.collapse(origin, docId);
     },
     async expandAll() {
-      navigator.expandAll();
+      navigator2.expandAll();
     },
     async collapseAll() {
-      navigator.collapseAll();
+      navigator2.collapseAll();
     },
     async expandToLevel(level) {
-      navigator.expandToLevel(level);
+      navigator2.expandToLevel(level);
     },
     async isExpanded(entryKey) {
-      const entry = navigator.getPos(entryKey);
-      return entry ? navigator.isExpanded(entry) : false;
+      const entry = navigator2.getPos(entryKey);
+      return entry ? navigator2.isExpanded(entry) : false;
     },
     async getExpansionState() {
       return {
-        expandAllByDefault: navigator.isExpandAllByDefault(),
-        expandLevel: navigator.getExpandLevel(),
-        entryKeys: Array.from(navigator.getExpandedOrCollapsedEntries())
+        expandAllByDefault: navigator2.isExpandAllByDefault(),
+        expandLevel: navigator2.getExpandLevel(),
+        entryKeys: Array.from(navigator2.getExpandedOrCollapsedEntries())
       };
     },
     async setExpansionState(state) {
-      if (state.expandAllByDefault) navigator.expandAll();
-      else navigator.collapseAll();
-      navigator.expandToLevel(state.expandLevel);
-      navigator.setExpandedOrCollapsedEntries(new Set(state.entryKeys));
+      if (state.expandAllByDefault) navigator2.expandAll();
+      else navigator2.collapseAll();
+      navigator2.expandToLevel(state.expandLevel);
+      navigator2.setExpandedOrCollapsedEntries(new Set(state.entryKeys));
     },
     async childEntries(entryKey, descending) {
-      return navigator.childEntries(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+      return navigator2.childEntries(resolveEntry(navigator2, entryKey), descending).map((entry) => serializeEntry(navigator2, entry));
     },
     async childCategories(entryKey, descending) {
-      return navigator.childCategories(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+      return navigator2.childCategories(resolveEntry(navigator2, entryKey), descending).map((entry) => serializeEntry(navigator2, entry));
     },
     async childDocuments(entryKey, descending) {
-      return navigator.childDocuments(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+      return navigator2.childDocuments(resolveEntry(navigator2, entryKey), descending).map((entry) => serializeEntry(navigator2, entry));
     },
     async childCategoriesByKey(entryKey, key, exact, descending) {
-      return navigator.childCategoriesByKey(
-        resolveEntry(navigator, entryKey),
+      return navigator2.childCategoriesByKey(
+        resolveEntry(navigator2, entryKey),
         String(key ?? ""),
         Boolean(exact),
         descending
-      ).map((entry) => serializeEntry(navigator, entry));
+      ).map((entry) => serializeEntry(navigator2, entry));
     },
     async childDocumentsByKey(entryKey, key, exact, descending) {
-      return navigator.childDocumentsByKey(
-        resolveEntry(navigator, entryKey),
+      return navigator2.childDocumentsByKey(
+        resolveEntry(navigator2, entryKey),
         String(key ?? ""),
         Boolean(exact),
         descending
-      ).map((entry) => serializeEntry(navigator, entry));
+      ).map((entry) => serializeEntry(navigator2, entry));
     },
     async childCategoriesBetween(entryKey, range) {
-      return navigator.childCategoriesBetween(
-        resolveEntry(navigator, entryKey),
+      return navigator2.childCategoriesBetween(
+        resolveEntry(navigator2, entryKey),
         range.startKey,
         range.endKey,
         range.descending
-      ).map((entry) => serializeEntry(navigator, entry));
+      ).map((entry) => serializeEntry(navigator2, entry));
     },
     async childDocumentsBetween(entryKey, range) {
-      return navigator.childDocumentsBetween(
-        resolveEntry(navigator, entryKey),
+      return navigator2.childDocumentsBetween(
+        resolveEntry(navigator2, entryKey),
         range.startKey,
         range.endKey,
         range.descending
-      ).map((entry) => serializeEntry(navigator, entry));
+      ).map((entry) => serializeEntry(navigator2, entry));
     },
     async getSortedDocIds(descending) {
-      const page = pageEntries(navigator, descending ? "backward" : "forward", { limit: 1e3 });
+      const page = pageEntries(navigator2, descending ? "backward" : "forward", { limit: 1e3 });
       return collectSortedDocIds(page.entries);
     },
     async getSortedDocIdsScoped(entryKey, descending) {
-      const docs = navigator.childDocuments(resolveEntry(navigator, entryKey), descending);
+      const docs = navigator2.childDocuments(resolveEntry(navigator2, entryKey), descending);
       return docs.map((entry) => ({ origin: entry.origin, docId: entry.docId }));
     },
     async dispose() {
@@ -447,14 +447,14 @@ 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 navigator = createCoreNavigator(mindoodb, view, input.options);
-  return wrapNavigator(input.definition, navigator);
+  const navigator2 = createCoreNavigator(mindoodb, view2, input.options);
+  return wrapNavigator(input.definition, navigator2);
 }
 
 // src/testing/mockEmbeds.ts
@@ -828,6 +828,246 @@ function guardDatabase(database, currentInfo, enforce) {
   };
 }
 
+// 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}$/;
+var MOCK_AGENT_MAX_TOOLS = 64;
+var MOCK_AGENT_MAX_DESCRIPTION = 2e3;
+var MOCK_AGENT_FILE_TTL_MS = 10 * 60 * 1e3;
+var MOCK_AGENT_FILE_MAX_BYTES = 50 * 1024 * 1024;
+var DEFAULT_INVOKE_TIMEOUT_MS = 12e4;
+function invalid(message) {
+  return Object.assign(new Error(message), { name: "invalid-params" });
+}
+function notFound(message) {
+  return Object.assign(new Error(message), { name: "not-found" });
+}
+function mockAgentToolPrefix(appId, declared) {
+  if (declared && PREFIX_PATTERN.test(declared) && !declared.endsWith("_") && !/^haven(?:_|$)/.test(declared)) {
+    return declared;
+  }
+  const key = (appId.split("\\").pop() ?? "").trim().toLowerCase().replace(/^mindoodb-app-/, "").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 16).replace(/_+$/, "");
+  if (!key) return "app";
+  return /^[a-z]/.test(key) ? key : `app_${key}`.slice(0, 16);
+}
+function validateMockAgentTools(raw) {
+  if (!Array.isArray(raw)) throw invalid("tools must be an array.");
+  if (raw.length > MOCK_AGENT_MAX_TOOLS) throw invalid(`An app may offer at most ${MOCK_AGENT_MAX_TOOLS} agent tools.`);
+  const seen = /* @__PURE__ */ new Set();
+  return raw.map((entry) => {
+    const tool = entry;
+    if (!tool || typeof tool.name !== "string" || !TOOL_NAME_PATTERN.test(tool.name)) {
+      throw invalid(`Invalid agent tool name "${String(tool?.name)}".`);
+    }
+    if (seen.has(tool.name)) throw invalid(`Agent tool "${tool.name}" is declared twice.`);
+    seen.add(tool.name);
+    if (typeof tool.description !== "string" || !tool.description.trim()) {
+      throw invalid(`Agent tool "${tool.name}" needs a description.`);
+    }
+    if (tool.description.length > MOCK_AGENT_MAX_DESCRIPTION) {
+      throw invalid(`The description of agent tool "${tool.name}" is too long.`);
+    }
+    const schema = tool.inputSchema;
+    if (!schema || typeof schema !== "object" || Array.isArray(schema) || schema.type !== "object") {
+      throw invalid(`Agent tool "${tool.name}" needs an object inputSchema.`);
+    }
+    const annotations = tool.annotations ?? {};
+    for (const key of ["readOnlyHint", "consequentialHint", "untrustedContentHint"]) {
+      if (annotations[key] !== void 0 && typeof annotations[key] !== "boolean") {
+        throw invalid(`Agent tool "${tool.name}" has invalid annotations.`);
+      }
+    }
+    return {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: schema,
+      ...tool.annotations ? { annotations: { ...tool.annotations } } : {}
+    };
+  });
+}
+async function bytesOf(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  if (data instanceof Uint8Array) return data.slice();
+  if (typeof Blob !== "undefined" && data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
+  return new Uint8Array(data);
+}
+function structuralBytes(data) {
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength).slice();
+  if (Object.prototype.toString.call(data) === "[object ArrayBuffer]") return new Uint8Array(data).slice();
+  return null;
+}
+function createMockAgentHost(options) {
+  const prefix = mockAgentToolPrefix(options.appId(), options.agentToolPrefix);
+  let tools = [];
+  let context = null;
+  let enabled = options.agentToolsEnabled ?? true;
+  let consent = options.agentConsent ?? "allow";
+  const timeoutMs = options.agentInvokeTimeoutMs ?? DEFAULT_INVOKE_TIMEOUT_MS;
+  const files = /* @__PURE__ */ new Map();
+  const calls = [];
+  const pending = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const changed = () => options.onChange?.();
+  function prune(now = Date.now()) {
+    for (const [ref, file] of files) if (file.expiresAt <= now) files.delete(ref);
+  }
+  function addFile(file) {
+    prune();
+    if (file.data.length > MOCK_AGENT_FILE_MAX_BYTES) {
+      throw invalid(`Files for agents may be at most ${MOCK_AGENT_FILE_MAX_BYTES / 1024 / 1024} MB.`);
+    }
+    const now = Date.now();
+    counter += 1;
+    const entry = {
+      ...file,
+      fileRef: `file_test${counter.toString(16).padStart(4, "0")}`,
+      createdAt: now,
+      expiresAt: now + MOCK_AGENT_FILE_TTL_MS
+    };
+    files.set(entry.fileRef, entry);
+    changed();
+    return entry;
+  }
+  function registration() {
+    return { enabled, exposedNames: tools.map((tool) => `${prefix}_${tool.name}`) };
+  }
+  async function dispatch(method, params) {
+    const input = params ?? {};
+    if (method === "agent.registerTools") {
+      tools = validateMockAgentTools(input.tools);
+      changed();
+      return { result: registration() };
+    }
+    if (method === "agent.setContext") {
+      const next = input.context ?? null;
+      if (next !== null && (typeof next !== "object" || Array.isArray(next))) {
+        throw invalid("context must be an object or null.");
+      }
+      context = next;
+      changed();
+      return { result: null };
+    }
+    if (method === "agent.provideFile") {
+      if (typeof input.name !== "string" || !input.name.trim()) throw invalid("provideFile needs a file name.");
+      const data = structuralBytes(input.data);
+      if (!data) throw invalid("provideFile needs the file content as an ArrayBuffer.");
+      const mimeType = typeof input.mimeType === "string" && input.mimeType ? input.mimeType : "application/octet-stream";
+      const file = addFile({ name: input.name.trim(), mimeType, data, source: "app" });
+      return { result: { fileRef: file.fileRef, size: file.data.length } };
+    }
+    if (method === "agent.takeFile") {
+      prune();
+      const file = typeof input.fileRef === "string" ? files.get(input.fileRef) : void 0;
+      if (!file || file.source !== "host") throw notFound("Unknown or expired file reference.");
+      return { result: { name: file.name, mimeType: file.mimeType, data: file.data.slice().buffer } };
+    }
+    return void 0;
+  }
+  function finish(callId, outcome) {
+    const call2 = calls.find((entry) => entry.callId === callId);
+    if (call2) call2.outcome = outcome;
+    changed();
+    return outcome;
+  }
+  async function call(name, input = {}) {
+    counter += 1;
+    const callId = `test-call-${counter}`;
+    const startedAt = Date.now();
+    const toolName = name.startsWith(`${prefix}_`) && !tools.some((t) => t.name === name) ? name.slice(prefix.length + 1) : name;
+    calls.push({ callId, tool: toolName, input, startedAt });
+    changed();
+    const failWith = (code, message, requiredAction) => finish(callId, {
+      ok: false,
+      error: { code, message, ...requiredAction ? { requiredAction } : {} },
+      durationMs: Date.now() - startedAt
+    });
+    if (!enabled) return failWith("NOT_ALLOWED", "The user has agent tools switched off for this app.");
+    const tool = tools.find((entry) => entry.name === toolName);
+    if (!tool) return failWith("NOT_FOUND", `The app offers no tool "${name}".`);
+    if (tool.annotations?.consequentialHint) {
+      const allowed = typeof consent === "function" ? await consent({ tool: toolName, input }) : consent === "allow";
+      if (!allowed) return failWith("NOT_ALLOWED", "The user declined this call.", "ask the user before trying again");
+    }
+    return await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        pending.delete(callId);
+        resolve(failWith("FAILED", `The app did not answer "${toolName}" in time.`));
+      }, timeoutMs);
+      pending.set(callId, { resolve, startedAt, timer });
+      const posted = options.post({ protocol: "mindoodb-app-bridge", kind: "agent-invoke", callId, tool: toolName, input });
+      if (!posted) {
+        clearTimeout(timer);
+        pending.delete(callId);
+        resolve(failWith("INVALID_STATE", "The app is not connected."));
+      }
+    });
+  }
+  function handleResult(message) {
+    const entry = pending.get(message.callId);
+    if (!entry) return;
+    pending.delete(message.callId);
+    clearTimeout(entry.timer);
+    const durationMs = Date.now() - entry.startedAt;
+    entry.resolve(
+      finish(
+        message.callId,
+        message.ok ? { ok: true, result: message.result ?? null, durationMs } : {
+          ok: false,
+          error: {
+            code: message.error?.code ?? "FAILED",
+            message: message.error?.message ?? "The app reported an error.",
+            ...message.error?.requiredAction ? { requiredAction: message.error.requiredAction } : {}
+          },
+          durationMs
+        }
+      )
+    );
+  }
+  function reset(reason = "The app was closed.") {
+    for (const [callId, entry] of pending) {
+      clearTimeout(entry.timer);
+      entry.resolve(
+        finish(callId, { ok: false, error: { code: "INVALID_STATE", message: reason }, durationMs: Date.now() - entry.startedAt })
+      );
+    }
+    pending.clear();
+    tools = [];
+    context = null;
+    changed();
+  }
+  const controller = {
+    prefix,
+    tools: () => tools.map((tool) => ({ ...tool })),
+    exposedNames: () => registration().exposedNames,
+    context: () => context,
+    isEnabled: () => enabled,
+    setEnabled(next) {
+      enabled = next;
+      changed();
+    },
+    setConsent(next) {
+      consent = next;
+    },
+    call,
+    calls: () => calls,
+    async importFile(file) {
+      const data = await bytesOf(file.data);
+      const mimeType = file.mimeType || (typeof Blob !== "undefined" && file.data instanceof Blob ? file.data.type : "") || "application/octet-stream";
+      return addFile({ name: file.name, mimeType, data, source: "host" }).fileRef;
+    },
+    getFile(fileRef) {
+      prune();
+      const file = files.get(fileRef);
+      return file && file.source === "app" ? file : null;
+    },
+    files() {
+      prune();
+      return [...files.values()].sort((a, b) => b.createdAt - a.createdAt);
+    }
+  };
+  return { controller, dispatch, handleResult, reset };
+}
+
 // src/testing/memoryAttachments.ts
 function concat(chunks) {
   const bytes = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
@@ -930,6 +1170,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() } }
     };
   });
@@ -950,6 +1191,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");
@@ -1020,6 +1263,10 @@ function createBrowserTestHost(options) {
   const changed = () => queueMicrotask(() => onChange?.());
   const host = createFakeBridgeHost({
     ...hostOptions,
+    onAgentChange() {
+      hostOptions.onAgentChange?.();
+      changed();
+    },
     onRequest(request) {
       log.requests.push(request);
       const params = request.params ?? {};
@@ -1110,6 +1357,7 @@ function createBrowserTestHost(options) {
   return {
     host,
     log,
+    agent: host.agent,
     setNextScan(scan) {
       nextScan = scan;
     },
@@ -1142,6 +1390,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);
@@ -1200,6 +1453,10 @@ var STYLE = `
 .htest__meta{margin-left:auto;color:#5b6478;font-size:11px;white-space:nowrap}
 .htest__error{color:#b42318}
 .htest pre{margin:4px 0 2px;padding:6px 8px;background:#fff;border:1px solid #e4e8f1;border-radius:6px;font:11px/1.4 ui-monospace,monospace;white-space:pre-wrap;word-break:break-all;max-height:260px;overflow:auto}
+.htest textarea{width:100%;min-height:70px;font:11px/1.4 ui-monospace,monospace;border:1px solid #c9d0e0;border-radius:6px;padding:6px}
+.htest__tag{display:inline-block;padding:0 6px;border-radius:999px;background:#e4e8f1;color:#334155;font-size:10px;margin-left:4px}
+.htest__tag--warn{background:#fee4e2;color:#912018}
+.htest__shot{max-width:100%;border:1px solid #e4e8f1;border-radius:6px;margin-top:4px;background:#fff}
 @media (max-width:720px){.htest{grid-template-columns:1fr;grid-template-rows:65vh auto}.htest__panel{border-left:0;border-top:1px solid #d7dce8}}
 `;
 function previewJson(value, maxString = 400, maxItems = 30, maxDepth = 6) {
@@ -1249,7 +1506,7 @@ function mountHavenTestHost(options) {
   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 } : {},
@@ -1430,14 +1687,24 @@ function mountHavenTestHost(options) {
     lists.scans.replaceChildren(...log.scans.map(scanEntry));
     lists.requests.replaceChildren(...log.requests.slice(-50).reverse().map(requestEntry));
   }
+  let agentReady = false;
   const testHost = createBrowserTestHost({
+    // Haven's consent dialog, as a browser confirm (scripts can switch it with agent.setConsent)
+    agentConsent: ({ tool, input }) => window.confirm(`An agent wants to run "${tool}" (marked consequential).
+
+${previewJson(input, 200, 10, 3)}
+
+Allow?`),
     ...hostOptions,
     databases,
     launchContext,
     enforceCapabilities: url.enforceCapabilities ?? hostOptions.enforceCapabilities,
     directoryUsers: url.directoryUserCount !== void 0 ? generateDirectoryUsers(url.directoryUserCount) : hostOptions.directoryUsers,
     frame,
-    onChange: render,
+    onChange: () => {
+      render();
+      if (agentReady) renderAgent();
+    },
     onEmbedChange(embeds) {
       hostOptions.onEmbedChange?.(embeds);
       renderEmbeds(embeds);
@@ -1574,11 +1841,213 @@ function mountHavenTestHost(options) {
     scanInput,
     hint("What attachments.scan() returns; the file is attached to the document like in Haven.")
   );
+  const agentState = document.createElement("div");
+  agentState.className = "htest__muted";
+  const agentEnabled = document.createElement("label");
+  agentEnabled.className = "htest__check";
+  const agentEnabledBox = document.createElement("input");
+  agentEnabledBox.type = "checkbox";
+  agentEnabledBox.dataset.testid = "haven-test-agent-enabled";
+  agentEnabledBox.checked = testHost.agent.isEnabled();
+  agentEnabledBox.addEventListener("change", () => testHost.agent.setEnabled(agentEnabledBox.checked));
+  agentEnabled.append(agentEnabledBox, "Agent access on (registerTools answers enabled)");
+  const agentTools = document.createElement("ul");
+  const toolSelect = document.createElement("select");
+  toolSelect.dataset.testid = "haven-test-agent-tool";
+  toolSelect.setAttribute("aria-label", "Agent tool");
+  const toolInput = document.createElement("textarea");
+  toolInput.dataset.testid = "haven-test-agent-input";
+  toolInput.setAttribute("aria-label", "Tool input (JSON)");
+  toolInput.value = "{}";
+  const toolResult = document.createElement("div");
+  toolResult.dataset.testid = "haven-test-agent-result";
+  const callButton = button("Call tool", () => void runTool());
+  callButton.dataset.testid = "haven-test-agent-call";
+  const agentContext = document.createElement("pre");
+  agentContext.dataset.testid = "haven-test-agent-context";
+  const agentFiles = document.createElement("ul");
+  const agentCalls = document.createElement("ul");
+  const importInput = document.createElement("input");
+  importInput.type = "file";
+  importInput.multiple = true;
+  importInput.dataset.testid = "haven-test-agent-import";
+  importInput.setAttribute("aria-label", "Import files for the app");
+  importInput.addEventListener("change", () => {
+    void (async () => {
+      for (const file of importInput.files ?? []) {
+        await testHost.agent.importFile({ name: file.name, mimeType: file.type, data: file });
+      }
+      importInput.value = "";
+    })();
+  });
+  function showOutcome(target, call) {
+    const pre = document.createElement("pre");
+    const outcome = call.outcome;
+    if (!outcome) {
+      pre.textContent = "running\u2026";
+      target.replaceChildren(pre);
+      return;
+    }
+    if (outcome.ok) {
+      pre.textContent = previewJson(outcome.result, 2e3, 60, 8);
+    } else {
+      pre.className = "htest__error";
+      pre.textContent = `${outcome.error.code}: ${outcome.error.message}${outcome.error.requiredAction ? `
+\u2192 ${outcome.error.requiredAction}` : ""}`;
+    }
+    const images = [];
+    const collect = (value, depth) => {
+      if (depth > 4 || images.length >= 4) return;
+      if (typeof value === "string" && /^data:image\/(png|jpeg|gif|webp|svg\+xml);base64,/.test(value)) images.push(value);
+      else if (value && typeof value === "object") for (const child of Object.values(value)) collect(child, depth + 1);
+    };
+    if (outcome.ok) collect(outcome.result, 0);
+    target.replaceChildren(
+      pre,
+      ...images.map((src) => {
+        const img = document.createElement("img");
+        img.className = "htest__shot";
+        img.src = src;
+        img.alt = "image in the tool result";
+        return img;
+      })
+    );
+  }
+  async function runTool() {
+    let input;
+    try {
+      const parsed = JSON.parse(toolInput.value || "{}");
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("The input must be a JSON object.");
+      input = parsed;
+    } catch (error) {
+      const pre = document.createElement("pre");
+      pre.className = "htest__error";
+      pre.textContent = error instanceof Error ? error.message : String(error);
+      toolResult.replaceChildren(pre);
+      return;
+    }
+    callButton.disabled = true;
+    try {
+      await testHost.agent.call(toolSelect.value, input);
+      const last = testHost.agent.calls().at(-1);
+      if (last) showOutcome(toolResult, last);
+    } finally {
+      callButton.disabled = false;
+    }
+  }
+  function download(name, mimeType, data) {
+    const link = document.createElement("a");
+    link.textContent = name;
+    link.download = name;
+    link.href = URL.createObjectURL(new Blob([data.slice().buffer], { type: mimeType }));
+    return link;
+  }
+  const openCalls = /* @__PURE__ */ new Set();
+  function renderAgent() {
+    const agent = testHost.agent;
+    const tools = agent.tools();
+    agentState.textContent = `prefix "${agent.prefix}" \xB7 ${tools.length} tool(s) \xB7 ${agent.isEnabled() ? "access on" : "access off"}`;
+    agentEnabledBox.checked = agent.isEnabled();
+    agentTools.replaceChildren(
+      ...tools.map((tool) => {
+        const li = document.createElement("li");
+        const details = document.createElement("details");
+        const summary = document.createElement("summary");
+        const name = document.createElement("span");
+        name.textContent = `${agent.prefix}_${tool.name}`;
+        summary.append(name);
+        const hints = tool.annotations ?? {};
+        if (hints.readOnlyHint) summary.append(Object.assign(document.createElement("span"), { className: "htest__tag", textContent: "read-only" }));
+        if (hints.consequentialHint) summary.append(Object.assign(document.createElement("span"), { className: "htest__tag htest__tag--warn", textContent: "asks first" }));
+        const description = document.createElement("p");
+        description.textContent = tool.description;
+        const schema = document.createElement("pre");
+        schema.textContent = previewJson(tool.inputSchema, 400, 60, 10);
+        details.append(summary, description, schema);
+        li.append(details);
+        return li;
+      })
+    );
+    const selected = toolSelect.value;
+    toolSelect.replaceChildren(...tools.map((tool) => new Option(`${agent.prefix}_${tool.name}`, tool.name)));
+    if (tools.some((tool) => tool.name === selected)) toolSelect.value = selected;
+    callButton.disabled = tools.length === 0;
+    agentContext.textContent = previewJson(agent.context(), 400, 30, 6);
+    agentFiles.replaceChildren(
+      ...agent.files().map((file) => {
+        const li = document.createElement("li");
+        const ref = document.createElement("code");
+        ref.textContent = file.fileRef;
+        const copy = button("copy ref", () => void navigator.clipboard?.writeText(file.fileRef));
+        li.append(
+          file.source === "app" ? "from app: " : "for app: ",
+          file.source === "app" ? download(file.name, file.mimeType, file.data) : file.name,
+          ` (${file.data.length} bytes) `,
+          ref,
+          " ",
+          copy
+        );
+        return li;
+      })
+    );
+    agentCalls.replaceChildren(
+      ...agent.calls().slice(-20).reverse().map((call) => {
+        const li = document.createElement("li");
+        const details = document.createElement("details");
+        const summary = document.createElement("summary");
+        const label = document.createElement("span");
+        label.textContent = call.tool;
+        if (call.outcome && !call.outcome.ok) label.className = "htest__error";
+        const meta = document.createElement("span");
+        meta.className = "htest__meta";
+        meta.textContent = call.outcome ? `${call.outcome.durationMs} ms` : "\u2026";
+        summary.append(label, meta);
+        const body = document.createElement("div");
+        const input = document.createElement("pre");
+        input.textContent = previewJson(call.input);
+        details.append(summary, body);
+        details.addEventListener("toggle", () => {
+          if (details.open) {
+            openCalls.add(call.callId);
+            const out = document.createElement("div");
+            showOutcome(out, call);
+            body.replaceChildren(input, out);
+          } else openCalls.delete(call.callId);
+        });
+        if (openCalls.has(call.callId)) details.open = true;
+        li.append(details);
+        return li;
+      })
+    );
+  }
+  const callRow = document.createElement("div");
+  callRow.className = "htest__row";
+  callRow.append(toolSelect, callButton);
+  section(
+    "Agent tools",
+    agentState,
+    agentEnabled,
+    agentTools,
+    callRow,
+    toolInput,
+    toolResult,
+    hint("Calls a tool as an agent would; tools marked \u201Casks first\u201D go through a confirm, like Haven's consent dialog.")
+  );
+  section(
+    "Agent files",
+    importInput,
+    hint("Import puts a file in the exchange for the app (takeFile); pass its fileRef to a tool. Files the app hands over (provideFile) can be downloaded."),
+    agentFiles
+  );
+  section("Agent context", agentContext);
+  section("Agent calls (latest first)", agentCalls);
   section("Notifications", lists.notifications);
   section("Previews", lists.previews);
   section("Scans", lists.scans);
   section("Requests (latest first, click for details)", lists.requests);
   render();
+  agentReady = true;
+  renderAgent();
   syncUrl();
   window.__havenTestHost = testHost;
   return testHost;
@@ -1882,23 +2351,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)
         }
       }))
     };
@@ -1920,41 +2389,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)
       }
     }))
   };
@@ -2045,9 +2514,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),
@@ -2058,9 +2530,401 @@ 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);
 }
+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 operation of patch.set ?? []) {
+    validateMockJsonPath(operation.path, "JSON set");
+    hydrateMockAutomergeValues(operation.value);
+  }
+  for (const operation of patch.unset ?? []) {
+    validateMockJsonPath(operation.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 operation of patch.listInsert ?? []) {
+    validateMockJsonPath(operation.path, "JSON listInsert");
+    assertMockNonNegativeInteger(operation.index, "JSON listInsert index");
+    if (!Array.isArray(operation.values)) {
+      throw new Error("JSON listInsert values must be an array");
+    }
+    hydrateMockAutomergeValues(operation.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") {
+      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) {
+      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");
+  }
+}
+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 operation of patch.set ?? []) {
+    setMockAutomergeValue(target, operation.path, hydrateMockAutomergeValues(operation.value));
+  }
+  for (const operation of patch.unset ?? []) {
+    unsetMockAutomergeValue(target, operation.path);
+  }
+  for (const operation of patch.listDelete ?? []) {
+    readMockAutomergeList(target, operation.path).splice(operation.index, operation.deleteCount);
+  }
+  for (const operation of patch.listInsert ?? []) {
+    ensureMockAutomergeList(target, operation.path).splice(
+      operation.index,
+      0,
+      ...hydrateMockAutomergeValues(operation.values)
+    );
+  }
+  for (const operation of patch.textSplice ?? []) {
+    ensureMockAutomergeText(target, operation.path, "JSON textSplice");
+    spliceMockAutomergeText(
+      target,
+      operation.path,
+      operation.index,
+      operation.deleteCount,
+      operation.insert ?? ""
+    );
+  }
+  for (const operation of patch.textMark ?? []) {
+    for (const [name, value] of Object.entries(operation.marks)) {
+      Automerge.mark(
+        target,
+        operation.path,
+        { start: operation.index, end: operation.index + operation.length, expand: "none" },
+        name,
+        reviveMockRichTextValue(value)
+      );
+    }
+  }
+  for (const operation of patch.textUnmark ?? []) {
+    for (const name of operation.names) {
+      Automerge.unmark(
+        target,
+        operation.path,
+        { start: operation.index, end: operation.index + operation.length, expand: "none" },
+        name
+      );
+    }
+  }
+  for (const operation of patch.counterIncrement ?? []) {
+    const parent = ensureMockAutomergeParent(target, operation.path);
+    const leaf = operation.path[operation.path.length - 1];
+    const existing = parent[leaf];
+    if (existing === void 0 || existing === null) {
+      parent[leaf] = new Automerge.Counter(operation.delta);
+    } else if (Automerge.isCounter(existing)) {
+      existing.increment(operation.delta);
+    } else {
+      throw new Error(
+        `Cannot increment non-counter value at '${operation.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 applyMockAutomergeUpdate(doc, patch) {
+  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 ?? []) {
+    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)));
+    });
+  }
+  for (const stepPatch of patch.richTextSteps ?? []) {
+    validateMockJsonPath(stepPatch.path, "Rich-text steps patch");
+    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");
+      for (const step of stepPatch.steps) {
+        spliceMockAutomergeText(target, stepPatch.path, step.index, step.deleteCount, step.insert ?? "");
+      }
+    });
+  }
+  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, field) {
   return field.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
@@ -2373,9 +3237,9 @@ function createLiveMockViewNavigator(initial, rebuild, subscribe) {
           listeners.clear();
           if (pendingNotify) clearTimeout(pendingNotify);
         }
-        const navigator = await current();
-        const member = navigator[property];
-        return typeof member === "function" ? member.apply(navigator, args) : member;
+        const navigator2 = await current();
+        const member = navigator2[property];
+        return typeof member === "function" ? member.apply(navigator2, args) : member;
       };
     }
   });
@@ -2913,9 +3777,17 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
   let createCounter = 0;
   let changeCounter = 0;
   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,
@@ -2926,7 +3798,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 = () => {
@@ -2969,6 +3848,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, MOCK_AUTOMERGE_LOCAL_ACTOR), (target) => {
+          target._encryptFor = hydrateMockAutomergeValues(nextEncryptFor);
+        })
+      );
+    }
     const updated = {
       id: docId,
       data: { ...existing.data, _encryptFor: nextEncryptFor },
@@ -2987,6 +3875,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(
@@ -3039,12 +3949,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,
@@ -3065,6 +3980,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,
@@ -3073,7 +3995,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     },
     async getHeadCursor() {
       return {
-        cursor: String(storedDocuments.size)
+        cursor: String(automergeMode ? changeSequence : storedDocuments.size)
       };
     },
     async listInaccessible(query) {
@@ -3169,7 +4091,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();
@@ -3182,7 +4104,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 {
@@ -3219,7 +4141,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 {
@@ -3248,11 +4173,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 },
+            MOCK_AUTOMERGE_LOCAL_ACTOR
+          )
+        );
+        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: [],
@@ -3283,6 +4236,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, MOCK_AUTOMERGE_LOCAL_ACTOR) : createMockAutomergeDocument(existing?.data ?? {}, MOCK_AUTOMERGE_LOCAL_ACTOR);
+        return writeAutomergeDocument(docId, existing, applyMockAutomergeUpdate(current, patch));
+      }
       const updated = {
         id: docId,
         data: applyDocumentUpdatePatch(existing?.data ?? {}, patch),
@@ -3369,7 +4326,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();
@@ -3593,7 +4550,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, MOCK_AUTOMERGE_LOCAL_ACTOR);
+      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 = {}) {
@@ -3619,6 +4595,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: () => {
@@ -3709,6 +4686,7 @@ function createMockSessionState(options = {}) {
     databaseViewApis.clear();
     databaseDocumentStores.clear();
     databaseLiveQueryRefreshers.clear();
+    databaseRemoteUpdaters.clear();
     databaseInfos = definitions.map((definition) => ({
       ...definition.info,
       capabilities: [...definition.info.capabilities]
@@ -3727,6 +4705,7 @@ 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);
       databaseViewApis.set(definition.info.id, {
         async create(input) {
           const build = () => createEvaluatingViewNavigator(
@@ -3849,10 +4828,10 @@ 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, view2);
+      return view2;
     },
     async openViewNavigator(viewId, options2) {
       const existing = sessionViews.get(viewId);
@@ -3860,7 +4839,7 @@ function createMockSessionState(options = {}) {
         return existing;
       }
       const sourceDatabaseId = launchContext.views.find(
-        (view2) => view2.id === viewId
+        (view3) => view3.id === viewId
       )?.sources[0]?.databaseId;
       if (!sourceDatabaseId) {
         throw new Error(`Unknown test view: ${viewId}`);
@@ -3871,9 +4850,9 @@ function createMockSessionState(options = {}) {
           `Unknown test database for view ${viewId}: ${sourceDatabaseId}`
         );
       }
-      const view = await api.open(viewId, options2);
-      sessionViews.set(viewId, view);
-      return view;
+      const view2 = await api.open(viewId, options2);
+      sessionViews.set(viewId, view2);
+      return view2;
     },
     menus,
     drag,
@@ -4010,6 +4989,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 ?? []];
     },
@@ -4126,6 +5112,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,
@@ -4158,6 +5145,20 @@ function createFakeBridgeHost(options = {}) {
   );
   const requests = [];
   const connectedPorts = /* @__PURE__ */ new Set();
+  const agentHost = createMockAgentHost({
+    ...options.agentToolPrefix !== void 0 ? { agentToolPrefix: options.agentToolPrefix } : {},
+    ...options.agentToolsEnabled !== void 0 ? { agentToolsEnabled: options.agentToolsEnabled } : {},
+    ...options.agentConsent !== void 0 ? { agentConsent: options.agentConsent } : {},
+    ...options.agentInvokeTimeoutMs !== void 0 ? { agentInvokeTimeoutMs: options.agentInvokeTimeoutMs } : {},
+    appId: () => state.getLaunchContext().appId,
+    post(message) {
+      const port = [...connectedPorts].pop();
+      if (!port) return false;
+      port.postMessage(message);
+      return true;
+    },
+    onChange: () => options.onAgentChange?.()
+  });
   state.embedHost.onClosed((event) => {
     connectedPorts.forEach(
       (port) => port.postMessage({ protocol: PROTOCOL, kind: "embed-event", event: { type: "closed", ...event } })
@@ -4199,6 +5200,7 @@ function createFakeBridgeHost(options = {}) {
         "Expected the bridge connection to transfer a MessagePort."
       );
     }
+    if (connectedPorts.size > 0) agentHost.reset("The app was reloaded.");
     connectedPorts.add(port);
     port.addEventListener("message", (event) => {
       void handlePortMessage(port, event.data);
@@ -4289,9 +5291,9 @@ function createFakeBridgeHost(options = {}) {
     if (existing) {
       return existing;
     }
-    const navigator = await state.openViewNavigator(viewId);
-    viewSessions.set(viewId, navigator);
-    return navigator;
+    const navigator2 = await state.openViewNavigator(viewId);
+    viewSessions.set(viewId, navigator2);
+    return navigator2;
   }
   function postRpcSuccess(port, requestId, result) {
     port.postMessage({
@@ -4340,14 +5342,14 @@ function createFakeBridgeHost(options = {}) {
         return { ok: true };
       case "session.createViewNavigator": {
         const navigatorId = `navigator-${viewCounter += 1}`;
-        const navigator = await state.createViewNavigator({
+        const navigator2 = await state.createViewNavigator({
           databaseIds: Array.isArray(params.databaseIds) ? params.databaseIds.map((entry) => String(entry)) : [],
           definition: params.definition,
           categorizationStyle: params.categorizationStyle === "category_then_document" ? "category_then_document" : "document_then_category",
           options: params.options
         });
-        viewSessions.set(navigatorId, navigator);
-        navigator.onDidUpdate((stats) => {
+        viewSessions.set(navigatorId, navigator2);
+        navigator2.onDidUpdate((stats) => {
           if (!viewSessions.has(navigatorId)) return;
           const payload = {
             protocol: PROTOCOL,
@@ -4361,11 +5363,11 @@ function createFakeBridgeHost(options = {}) {
       }
       case "session.openViewNavigator": {
         const navigatorId = `navigator-${viewCounter += 1}`;
-        const navigator = await state.openViewNavigator(
+        const navigator2 = await state.openViewNavigator(
           String(params.viewId),
           params.options
         );
-        viewSessions.set(navigatorId, navigator);
+        viewSessions.set(navigatorId, navigator2);
         return { navigatorId };
       }
       case "menus.show":
@@ -4858,8 +5860,8 @@ function createFakeBridgeHost(options = {}) {
         );
       case "viewNavigators.dispose": {
         const key = String(params.navigatorId);
-        const navigator = await resolveViewNavigator(key);
-        await navigator.dispose();
+        const navigator2 = await resolveViewNavigator(key);
+        await navigator2.dispose();
         viewSessions.delete(key);
         return void 0;
       }
@@ -4944,6 +5946,10 @@ function createFakeBridgeHost(options = {}) {
       beforeCloseWaiters.get(message.closeId)?.();
       return;
     }
+    if (message.kind === "agent-result") {
+      agentHost.handleResult(message);
+      return;
+    }
     if (message.kind === "workspace-focus-requested") {
       state.setHostFocused(true);
       const payload = {
@@ -4985,6 +5991,11 @@ function createFakeBridgeHost(options = {}) {
           succeed(result);
           return;
         }
+        const agentResult = await agentHost.dispatch(message.method, message.params);
+        if (agentResult) {
+          succeed(agentResult.result);
+          return;
+        }
         const builtinResult = await handleBuiltinRequest(message);
         if (builtinResult === NOT_HANDLED) {
           fail({
@@ -5026,6 +6037,7 @@ function createFakeBridgeHost(options = {}) {
   const controller = {
     bridge: state.bridge,
     session: state.session,
+    agent: agentHost.controller,
     get launchId() {
       return state.getLaunchContext().launchId;
     },
@@ -5043,6 +6055,7 @@ 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(),
@@ -5183,12 +6196,15 @@ export {
   createEvaluatingViewNavigator,
   createFakeBridgeHost,
   createMemoryAttachments,
+  createMockAgentHost,
   createMockMindooDBAppBridge,
   createMockMindooDBAppSession,
   generateDirectoryUsers,
   loadMindoodbForTesting,
+  mockAgentToolPrefix,
   mockDatabasesFromDefinition,
   mountHavenTestHost,
   previewJson,
-  readTestHostUrlSettings
+  readTestHostUrlSettings,
+  validateMockAgentTools
 };