mindoodb-app-sdk 0.0.49 → 0.0.53

package/dist/testing/index.js

@@ -1,6 +1,7 @@
 import {
+  MINDOODB_APP_VALUE_TAG,
   releaseMindooDBAppBridgeSessions
-} from "../chunk-TPYDERAK.js";
+} from "../chunk-6NTVTL6G.js";
 
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
@@ -28,10 +29,10 @@ function toFormulaBoolean(value) {
   }
   return Boolean(value);
 }
-function matchesFilter(mindoodb, definition, document) {
+function matchesFilter(mindoodb, definition, document2) {
   void mindoodb;
   if (!definition.filter) return true;
-  const { data: doc, origin, docId, createdAt, lastModifiedAt, witnessed, awaitingWitness } = document;
+  const { data: doc, origin, docId, createdAt, lastModifiedAt, witnessed, awaitingWitness } = document2;
   return toFormulaBoolean(
     evaluateExpression(definition.filter.expression, {
       doc,
@@ -46,8 +47,8 @@ function matchesFilter(mindoodb, definition, document) {
     })
   );
 }
-function computeColumnValues(definition, document) {
-  const { data: doc, origin, docId, createdAt, lastModifiedAt, witnessed, awaitingWitness } = document;
+function computeColumnValues(definition, document2) {
+  const { data: doc, origin, docId, createdAt, lastModifiedAt, witnessed, awaitingWitness } = document2;
   const values = {};
   for (const [key, value] of Object.entries(doc)) {
     if (!key.startsWith("_")) values[key] = value;
@@ -171,13 +172,13 @@ async function buildVirtualView(mindoodb, definition, documents, categorizationS
   }
   const view = await builder.build();
   const changes = /* @__PURE__ */ new Map();
-  for (const document of documents) {
-    if (!matchesFilter(mindoodb, definition, document)) {
+  for (const document2 of documents) {
+    if (!matchesFilter(mindoodb, definition, document2)) {
       continue;
     }
-    const change = changes.get(document.origin) ?? new mindoodb.VirtualViewDataChange(document.origin);
-    change.addEntry(document.docId, computeColumnValues(definition, document));
-    changes.set(document.origin, change);
+    const change = changes.get(document2.origin) ?? new mindoodb.VirtualViewDataChange(document2.origin);
+    change.addEntry(document2.docId, computeColumnValues(definition, document2));
+    changes.set(document2.origin, change);
   }
   for (const change of changes.values()) {
     if (change.hasChanges()) view.applyChanges(change);
@@ -453,6 +454,249 @@ async function createEvaluatingViewNavigator(input, documents) {
   return wrapNavigator(input.definition, navigator);
 }
 
+// src/testing/browserTestHost.ts
+function capabilitiesForDefinitionPermissions(permissions) {
+  const result = /* @__PURE__ */ new Set(["read"]);
+  for (const permission of permissions ?? []) {
+    if (permission === "write") {
+      result.add("create");
+      result.add("update");
+    } else if (permission === "delete" || permission === "history" || permission === "attachments" || permission === "views" || permission === "sign" || permission === "timestamps" || permission === "directory" || permission === "sealedchannel") {
+      result.add(permission);
+    }
+  }
+  return [...result];
+}
+function mockDatabasesFromDefinition(definition, seed = {}) {
+  return (definition.databases ?? []).map((database) => ({
+    info: {
+      id: database.logicalDatabaseId,
+      title: database.label ?? database.logicalDatabaseId,
+      capabilities: capabilitiesForDefinitionPermissions(database.permissions)
+    },
+    documents: seed[database.logicalDatabaseId]
+  }));
+}
+function withLaunchId(appUrl, launchId) {
+  const url = new URL(appUrl, window.location.href);
+  url.searchParams.set("mindoodbAppLaunchId", launchId);
+  return url.toString();
+}
+function createBrowserTestHost(options) {
+  const { frame, appUrl, onChange, ...hostOptions } = options;
+  let nextScan = null;
+  let scanCounter = 0;
+  const log = {
+    notifications: [],
+    previews: [],
+    scans: [],
+    focusRequests: 0,
+    requests: []
+  };
+  const host = createFakeBridgeHost({
+    ...hostOptions,
+    onRequest(request) {
+      log.requests.push(request);
+      const params = request.params ?? {};
+      if (request.method === "notifications.show") {
+        log.notifications.push({
+          id: typeof params.id === "string" ? params.id : void 0,
+          severity: typeof params.severity === "string" ? params.severity : void 0,
+          text: typeof params.text === "string" ? params.text : void 0,
+          durationMs: typeof params.durationMs === "number" ? params.durationMs : void 0
+        });
+      } else if (request.method === "session.requestHostFocus") {
+        log.focusRequests += 1;
+      } else if (request.method === "attachments.openPreview" || request.method === "attachments.preparePreviewSession") {
+        log.previews.push({
+          databaseId: String(params.databaseId),
+          docId: String(params.docId),
+          attachmentName: String(params.attachmentName)
+        });
+      }
+      hostOptions.onRequest?.(request);
+      queueMicrotask(() => onChange?.());
+    },
+    requestHandlers: {
+      "attachments.scanAndWrite": (params) => {
+        const input = params ?? {};
+        const scan = nextScan;
+        nextScan = null;
+        log.scans.push({
+          databaseId: String(input.databaseId),
+          docId: String(input.docId),
+          result: scan ? "scanned" : "cancelled"
+        });
+        if (!scan) {
+          return { ok: false };
+        }
+        scanCounter += 1;
+        return {
+          ok: true,
+          attachment: {
+            attachmentId: `test-scan-${scanCounter}`,
+            fileName: scan.fileName,
+            mimeType: scan.mimeType,
+            size: scan.size
+          }
+        };
+      },
+      ...hostOptions.requestHandlers
+    }
+  });
+  const onMessage = (event) => {
+    if (event.source !== frame.contentWindow) {
+      return;
+    }
+    host.acceptConnection(event.data, event.ports);
+  };
+  window.addEventListener("message", onMessage);
+  frame.src = withLaunchId(appUrl, host.launchId);
+  return {
+    host,
+    log,
+    setNextScan(scan) {
+      nextScan = scan;
+    },
+    setTheme(theme) {
+      host.emitThemeChange(theme);
+      onChange?.();
+    },
+    setHostFocus(focused) {
+      host.emitHostFocusChange(focused);
+      onChange?.();
+    },
+    reloadApp() {
+      frame.src = withLaunchId(appUrl, host.launchId);
+    },
+    dispose() {
+      window.removeEventListener("message", onMessage);
+      host.dispose();
+    }
+  };
+}
+var STYLE = `
+.htest{display:grid;grid-template-columns:minmax(0,1fr) 300px;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}
+.htest__panel{border-left:1px solid #d7dce8;overflow:auto;padding:14px;background:#f8f9fc}
+.htest__badge{display:inline-block;padding:2px 8px;border-radius:999px;background:#fde68a;color:#713f12;font-weight:600;font-size:11px;letter-spacing:.04em}
+.htest h1{font-size:15px;margin:8px 0 12px}
+.htest h2{font-size:12px;text-transform:uppercase;letter-spacing:.08em;color:#5b6478;margin:16px 0 6px}
+.htest__row{display:flex;gap:6px;flex-wrap:wrap}
+.htest button{font:inherit;padding:5px 9px;border-radius:7px;border:1px solid #c9d0e0;background:#fff;cursor:pointer}
+.htest ul{list-style:none;margin:0;padding:0}
+.htest li{padding:5px 0;border-bottom:1px solid #e4e8f1;word-break:break-word}
+.htest__muted{color:#5b6478}
+@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 item(text) {
+  const li = document.createElement("li");
+  li.textContent = text;
+  return li;
+}
+function mountHavenTestHost(options) {
+  const { container = document.body, title = "Haven test host", ...hostOptions } = options;
+  const style = document.createElement("style");
+  style.textContent = STYLE;
+  document.head.append(style);
+  const root = document.createElement("div");
+  root.className = "htest";
+  const frame = document.createElement("iframe");
+  frame.className = "htest__frame";
+  frame.title = title;
+  frame.dataset.testid = "haven-test-app-frame";
+  const panel = document.createElement("aside");
+  panel.className = "htest__panel";
+  root.append(frame, panel);
+  container.replaceChildren(root);
+  if (container === document.body) {
+    document.body.style.margin = "0";
+  }
+  let focused = false;
+  let dark = false;
+  const lists = {
+    notifications: document.createElement("ul"),
+    previews: document.createElement("ul"),
+    scans: document.createElement("ul"),
+    requests: document.createElement("ul")
+  };
+  const focusState = document.createElement("span");
+  focusState.className = "htest__muted";
+  function button(label, onClick) {
+    const node = document.createElement("button");
+    node.type = "button";
+    node.textContent = label;
+    node.addEventListener("click", onClick);
+    return node;
+  }
+  function section(label, ...children) {
+    const heading2 = document.createElement("h2");
+    heading2.textContent = label;
+    panel.append(heading2, ...children);
+  }
+  function render() {
+    const { log } = testHost;
+    focusState.textContent = `focused: ${focused ? "yes" : "no"} \xB7 requests: ${log.focusRequests}`;
+    lists.notifications.replaceChildren(
+      ...log.notifications.map((entry) => item(`[${entry.severity ?? "?"}] ${entry.text ?? ""}`))
+    );
+    lists.previews.replaceChildren(
+      ...log.previews.map((entry) => item(`${entry.attachmentName} (${entry.databaseId}/${entry.docId})`))
+    );
+    lists.scans.replaceChildren(...log.scans.map((entry) => item(`${entry.result} \u2192 ${entry.docId}`)));
+    lists.requests.replaceChildren(...log.requests.slice(-30).reverse().map((entry) => item(entry.method)));
+  }
+  const testHost = createBrowserTestHost({ ...hostOptions, frame, onChange: render });
+  const badge = document.createElement("span");
+  badge.className = "htest__badge";
+  badge.textContent = "TEST HOST \xB7 MOCK DATA";
+  const heading = document.createElement("h1");
+  heading.textContent = title;
+  panel.append(badge, heading);
+  const hostRow = document.createElement("div");
+  hostRow.className = "htest__row";
+  hostRow.append(
+    button("Toggle theme", () => {
+      dark = !dark;
+      testHost.setTheme({ mode: dark ? "dark" : "light", preset: "mindoo" });
+    }),
+    button("Toggle focus", () => {
+      focused = !focused;
+      testHost.setHostFocus(focused);
+    }),
+    button("Reload app", () => testHost.reloadApp())
+  );
+  section("Host", hostRow, focusState);
+  const scanInput = document.createElement("input");
+  scanInput.type = "file";
+  scanInput.accept = "image/jpeg,image/png,application/pdf";
+  scanInput.addEventListener("change", () => {
+    const file = scanInput.files?.[0];
+    testHost.setNextScan(
+      file ? {
+        fileName: file.name,
+        mimeType: file.type === "image/png" || file.type === "application/pdf" ? file.type : "image/jpeg",
+        size: file.size
+      } : null
+    );
+  });
+  const scanHint = document.createElement("p");
+  scanHint.className = "htest__muted";
+  scanHint.textContent = "The app's next scan returns this file. Without one it is cancelled.";
+  section("Next scan", scanInput, scanHint);
+  section("Notifications", lists.notifications);
+  section("Previews", lists.previews);
+  section("Scans", lists.scans);
+  section("Requests (latest first)", lists.requests);
+  void testHost.host.session.getLaunchContext().then((context) => {
+    dark = context.theme.mode === "dark";
+  });
+  render();
+  window.__havenTestHost = testHost;
+  return testHost;
+}
+
 // src/testing/index.ts
 var PROTOCOL = "mindoodb-app-bridge";
 var MOCK_SIGNING_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAmockmockmockmockmockmockmockmockmockmockmoc=\n-----END PUBLIC KEY-----\n";
@@ -473,7 +717,7 @@ function cloneBytes(chunk) {
 function applyDocumentUpdatePatch(current, patch) {
   const next = {
     ...structuredClone(current),
-    ...patch.set ? structuredClone(patch.set) : {}
+    ...patch.set ? readMockTypedValues(patch.set) : {}
   };
   for (const key of patch.unset ?? []) {
     Reflect.deleteProperty(next, key);
@@ -496,7 +740,7 @@ function applyMockJsonPatch(target, patch) {
     return;
   }
   for (const operation of patch.set ?? []) {
-    setValueAtPath(target, operation.path, structuredClone(operation.value));
+    setValueAtPath(target, operation.path, readMockTypedValues(operation.value));
   }
   for (const operation of patch.unset ?? []) {
     unsetValueAtPath(target, operation.path);
@@ -506,8 +750,13 @@ function applyMockJsonPatch(target, patch) {
     list.splice(operation.index, operation.deleteCount);
   }
   for (const operation of patch.listInsert ?? []) {
+    const parent = ensureParentAtPath(target, operation.path);
+    const leaf = operation.path[operation.path.length - 1];
+    if (parent[leaf] == null) {
+      parent[leaf] = [];
+    }
     const list = readListAtPath(target, operation.path);
-    list.splice(operation.index, 0, ...structuredClone(operation.values));
+    list.splice(operation.index, 0, ...readMockTypedValues(operation.values));
   }
   for (const operation of patch.textSplice ?? []) {
     applyMockTextPatch(target, operation.path, [{
@@ -522,6 +771,81 @@ function applyMockJsonPatch(target, patch) {
   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 operation of patch.counterIncrement ?? []) {
+    assertMockCounterAmount(operation.delta, "JSON counterIncrement delta");
+    const parent = ensureParentAtPath(target, operation.path);
+    const leaf = operation.path[operation.path.length - 1];
+    const current = parent[leaf];
+    if (current == null) {
+      parent[leaf] = operation.delta;
+    } else if (typeof current === "number") {
+      parent[leaf] = current + operation.delta;
+    } else {
+      throw new Error(
+        `Cannot increment non-counter value at ${operation.path.map(String).join(".")}`
+      );
+    }
+  }
+}
+var MOCK_CURSOR_PREFIX = "mock-cursor:";
+function readMockCursorText(data, path) {
+  let value = data;
+  for (const segment of path) {
+    value = value?.[segment];
+  }
+  if (typeof value !== "string") {
+    throw new Error(
+      `Text cursors require an Automerge text field at '${path.map(String).join(".")}'`
+    );
+  }
+  return value;
+}
+function readMockTypedValues(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return value.slice();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => readMockTypedValues(entry));
+  }
+  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 record.value;
+      case "counter":
+        assertMockCounterAmount(record.value, 'Typed value "counter"');
+        return record.value;
+      case "timestamp":
+        return 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`
+        );
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(record).map(([key, entry]) => [key, readMockTypedValues(entry)])
+  );
+}
+function toMockTimestamp(value) {
+  const date = typeof value === "number" || typeof value === "string" && value.trim() !== "" ? new Date(value) : null;
+  if (!date || Number.isNaN(date.getTime())) {
+    throw new Error(
+      'Typed value "timestamp" must be epoch milliseconds or an ISO 8601 date-time string'
+    );
+  }
+  return date.toISOString();
+}
+function assertMockCounterAmount(amount, label) {
+  if (typeof amount !== "number" || !Number.isSafeInteger(amount)) {
+    throw new Error(`${label} must be a safe integer`);
+  }
 }
 function setValueAtPath(target, path, value) {
   if (path.length === 0) {
@@ -816,27 +1140,27 @@ function createDefaultWritableAttachmentStream() {
     }
   };
 }
-function mockDecryptionKeyId(document) {
-  if (!document.decryptionKeyId || document.data._encryptFor) {
+function mockDecryptionKeyId(document2) {
+  if (!document2.decryptionKeyId || document2.data._encryptFor) {
     return {};
   }
-  return { decryptionKeyId: document.decryptionKeyId };
+  return { decryptionKeyId: document2.decryptionKeyId };
 }
-function loadMockAutomergeDocument(document) {
-  if (document.automergeBinary) {
-    return Automerge.load(document.automergeBinary);
+function loadMockAutomergeDocument(document2) {
+  if (document2.automergeBinary) {
+    return Automerge.load(document2.automergeBinary);
   }
   const initialDoc = Automerge.from({
-    ...structuredClone(document.data),
-    body: typeof document.data.body === "string" ? document.data.body : ""
+    ...structuredClone(document2.data),
+    body: typeof document2.data.body === "string" ? document2.data.body : ""
   });
-  document.automergeBinary = Automerge.save(initialDoc);
+  document2.automergeBinary = Automerge.save(initialDoc);
   return initialDoc;
 }
-function persistMockAutomergeDocument(document, automergeDoc) {
-  document.automergeBinary = Automerge.save(automergeDoc);
-  document.data = structuredClone(automergeDoc);
-  document.heads = Automerge.getHeads(automergeDoc);
+function persistMockAutomergeDocument(document2, automergeDoc) {
+  document2.automergeBinary = Automerge.save(automergeDoc);
+  document2.data = structuredClone(automergeDoc);
+  document2.heads = Automerge.getHeads(automergeDoc);
 }
 function getFieldValue2(source, field) {
   return field.split(".").reduce((current, part) => {
@@ -846,12 +1170,12 @@ function getFieldValue2(source, field) {
     return void 0;
   }, source);
 }
-function matchesDocumentFilter(document, filter) {
+function matchesDocumentFilter(document2, filter) {
   if (!filter) {
     return true;
   }
   return Object.entries(filter).every(
-    ([field, expected]) => getFieldValue2(document.data, field) === expected
+    ([field, expected]) => getFieldValue2(document2.data, field) === expected
   );
 }
 function matchesMockIdPrefix(docId, idPrefix) {
@@ -898,8 +1222,8 @@ function collectMockText(value, depth = 0) {
     return "";
   }
   const parts = [];
-  for (const item of Array.isArray(value) ? value : Object.values(value)) {
-    const text = collectMockText(item, depth + 1);
+  for (const item2 of Array.isArray(value) ? value : Object.values(value)) {
+    const text = collectMockText(item2, depth + 1);
     if (text.length > 0) {
       parts.push(text);
     }
@@ -909,14 +1233,14 @@ function collectMockText(value, depth = 0) {
 function mockTokenize(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length > 0);
 }
-function computeMockTextScore(document, clause) {
+function computeMockTextScore(document2, clause) {
   const terms = mockTokenize(clause.query);
   if (terms.length === 0) {
     return void 0;
   }
-  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue2(document.data, field))).join(" ") : collectMockText(
+  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue2(document2.data, field))).join(" ") : collectMockText(
     Object.fromEntries(
-      Object.entries(document.data).filter(([key]) => !key.startsWith("_"))
+      Object.entries(document2.data).filter(([key]) => !key.startsWith("_"))
     )
   );
   const tokens = mockTokenize(haystack);
@@ -940,22 +1264,22 @@ function runMockDocumentQuery(storedDocuments, databaseId, query, resolveDatabas
   const filter = typeof query?.filter === "string" ? parseMindooDBFormulaBooleanExpression(query.filter) : query?.filter;
   const sortBy = query?.sortBy && query.sortBy.length > 0 ? query.sortBy : query?.text ? [{ special: "textScore", direction: "descending" }] : [];
   const matches = [];
-  for (const document of storedDocuments.values()) {
-    if (document.isDeleted || document.inaccessible) {
+  for (const document2 of storedDocuments.values()) {
+    if (document2.isDeleted || document2.inaccessible) {
       continue;
     }
     let textScore;
     if (query?.text) {
-      textScore = computeMockTextScore(document, query.text);
+      textScore = computeMockTextScore(document2, query.text);
       if (textScore === void 0) {
         continue;
       }
     }
     const context = {
-      doc: document.data,
+      doc: document2.data,
       values: {},
       origin: databaseId,
-      docId: document.id,
+      docId: document2.id,
       variables: {}
     };
     if (filter && !mockExpressionToBoolean(evaluateExpression2(filter, context))) {
@@ -965,9 +1289,9 @@ function runMockDocumentQuery(storedDocuments, databaseId, query, resolveDatabas
       if (key.special === "textScore") {
         return textScore ?? 0;
       }
-      return key.expression ? evaluateExpression2(key.expression, context) : getFieldValue2(document.data, key.field ?? "");
+      return key.expression ? evaluateExpression2(key.expression, context) : getFieldValue2(document2.data, key.field ?? "");
     });
-    matches.push({ document, sortValues, textScore });
+    matches.push({ document: document2, sortValues, textScore });
   }
   if (sortBy.length > 0) {
     matches.sort((left, right) => {
@@ -988,19 +1312,19 @@ function runMockDocumentQuery(storedDocuments, databaseId, query, resolveDatabas
   const offset = Math.max(0, query?.offset ?? 0);
   const limit = Math.max(1, query?.limit ?? 200);
   const page = matches.slice(offset, offset + limit);
-  const rows = page.map(({ document, textScore }) => ({
-    docId: document.id,
-    fields: projectMockFields(document.data, query?.fields),
-    lastModified: mockLastModified(document),
+  const rows = page.map(({ document: document2, textScore }) => ({
+    docId: document2.id,
+    fields: projectMockFields(document2.data, query?.fields),
+    lastModified: mockLastModified(document2),
     ...textScore === void 0 ? {} : { textScore }
   }));
   if (query?.include) {
     hydrateMockIncludes({
       includes: query.include,
-      parents: page.map(({ document }, index) => ({
+      parents: page.map(({ document: document2 }, index) => ({
         row: rows[index],
-        docId: document.id,
-        data: document.data
+        docId: document2.id,
+        data: document2.data
       })),
       parentDatabaseId: databaseId,
       parentDocuments: storedDocuments,
@@ -1014,8 +1338,8 @@ function runMockDocumentQuery(storedDocuments, databaseId, query, resolveDatabas
 function projectMockFields(data, fields) {
   return fields ? Object.fromEntries(fields.map((field) => [field, getFieldValue2(data, field)])) : structuredClone(data);
 }
-function mockLastModified(document) {
-  return document.updatedAt ? Date.parse(document.updatedAt) || 0 : 0;
+function mockLastModified(document2) {
+  return document2.updatedAt ? Date.parse(document2.updatedAt) || 0 : 0;
 }
 var MOCK_MAX_INCLUDE_DEPTH = 3;
 var MOCK_DEFAULT_INCLUDE_LIMIT = 200;
@@ -1124,7 +1448,7 @@ function mockJoinValues(value) {
     return [];
   }
   return (Array.isArray(value) ? value : [value]).filter(
-    (item) => item !== void 0 && item !== null
+    (item2) => item2 !== void 0 && item2 !== null
   );
 }
 function validateMockInclude(slot, label, include, depth) {
@@ -1208,35 +1532,35 @@ function hydrateMockIncludes(params) {
     const sortBy = include.sortBy ?? [];
     const childrenByKey = /* @__PURE__ */ new Map();
     if (parentsByKey.size > 0) {
-      for (const document of childDocuments.values()) {
-        if (document.isDeleted || document.inaccessible) {
+      for (const document2 of childDocuments.values()) {
+        if (document2.isDeleted || document2.inaccessible) {
           continue;
         }
-        const childValue = plan.child.kind === "docId" ? document.id : getFieldValue2(document.data, plan.child.path);
+        const childValue = plan.child.kind === "docId" ? document2.id : getFieldValue2(document2.data, plan.child.path);
         const matchedKeys = mockJoinValues(childValue).filter((key) => parentsByKey.has(key));
         if (matchedKeys.length === 0) {
           continue;
         }
         const context = {
-          doc: document.data,
+          doc: document2.data,
           values: {},
           origin: childDatabaseId,
-          docId: document.id,
+          docId: document2.id,
           variables: {}
         };
         if (plan.residualFilter && !mockExpressionToBoolean(evaluateExpression2(plan.residualFilter, context))) {
           continue;
         }
         const candidate = {
-          docId: document.id,
-          data: document.data,
+          docId: document2.id,
+          data: document2.data,
           row: {
-            docId: document.id,
-            fields: projectMockFields(document.data, include.fields),
-            lastModified: mockLastModified(document)
+            docId: document2.id,
+            fields: projectMockFields(document2.data, include.fields),
+            lastModified: mockLastModified(document2)
           },
           sortValues: sortBy.map(
-            (key) => key.expression ? evaluateExpression2(key.expression, context) : getFieldValue2(document.data, key.field ?? "")
+            (key) => key.expression ? evaluateExpression2(key.expression, context) : getFieldValue2(document2.data, key.field ?? "")
           )
         };
         for (const key of matchedKeys) {
@@ -1665,30 +1989,30 @@ function createDatabaseHandle(definition, peers) {
       const offset = decodeMockListCursor(query?.cursor) + skip;
       const metadataOnly = query?.metadataOnly ?? false;
       const idPrefix = query?.idPrefix;
-      const items = Array.from(storedDocuments.values()).filter((document) => !document.inaccessible).filter(
-        (document) => status === "all" ? true : status === "deleted" ? document.isDeleted : !document.isDeleted
-      ).filter((document) => matchesMockIdPrefix(document.id, idPrefix)).filter(
-        (document) => metadataOnly ? true : matchesDocumentFilter(document, query?.filter)
+      const items = Array.from(storedDocuments.values()).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((document) => {
+      const page = items.slice(offset, offset + limit).map((document2) => {
         if (metadataOnly) {
           return {
-            id: document.id,
-            isDeleted: document.isDeleted
+            id: document2.id,
+            isDeleted: document2.isDeleted
           };
         }
         const projectedData = query?.fields ? Object.fromEntries(
           query.fields.map((field) => [
             field,
-            getFieldValue2(document.data, field)
+            getFieldValue2(document2.data, field)
           ])
-        ) : document.data;
+        ) : document2.data;
         return {
-          id: document.id,
+          id: document2.id,
           data: projectedData,
-          attachmentCount: document.attachments?.length ?? 0,
-          updatedAt: document.updatedAt,
-          isDeleted: status !== "existing" ? document.isDeleted : void 0
+          attachmentCount: document2.attachments?.length ?? 0,
+          updatedAt: document2.updatedAt,
+          isDeleted: status !== "existing" ? document2.isDeleted : void 0
         };
       });
       const nextCursor = offset + page.length < items.length ? String(offset + page.length) : null;
@@ -1704,63 +2028,102 @@ function createDatabaseHandle(definition, peers) {
     },
     async listInaccessible(query) {
       const idPrefix = query?.idPrefix;
-      const items = Array.from(storedDocuments.values()).filter((document) => document.inaccessible).filter((document) => matchesMockIdPrefix(document.id, idPrefix)).sort((left, right) => left.id.localeCompare(right.id)).map((document) => ({
-        id: document.id,
-        createdAt: document.createdAt ?? document.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        decryptionKeyId: document.decryptionKeyId ?? "sealed",
-        authorLabel: document.authorLabel
+      const items = Array.from(storedDocuments.values()).filter((document2) => document2.inaccessible).filter((document2) => matchesMockIdPrefix(document2.id, idPrefix)).sort((left, right) => left.id.localeCompare(right.id)).map((document2) => ({
+        id: document2.id,
+        createdAt: document2.createdAt ?? document2.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        decryptionKeyId: document2.decryptionKeyId ?? "sealed",
+        authorLabel: document2.authorLabel
       }));
       return { items };
     },
     async get(_docId) {
-      const document = storedDocuments.get(_docId);
-      if (!document || document.isDeleted || document.inaccessible) {
+      const document2 = storedDocuments.get(_docId);
+      if (!document2 || document2.isDeleted || document2.inaccessible) {
         return null;
       }
       return {
-        id: document.id,
-        data: structuredClone(document.data),
-        heads: document.heads ? [...document.heads] : void 0,
-        attachments: document.attachments ? structuredClone(document.attachments) : [],
-        updatedAt: document.updatedAt,
-        ...mockDecryptionKeyId(document)
+        id: document2.id,
+        data: structuredClone(document2.data),
+        heads: document2.heads ? [...document2.heads] : void 0,
+        attachments: document2.attachments ? structuredClone(document2.attachments) : [],
+        updatedAt: document2.updatedAt,
+        ...mockDecryptionKeyId(document2)
       };
     },
     async getRichText(docId, path, _options) {
-      const document = storedDocuments.get(docId);
-      if (!document || document.isDeleted) {
+      const document2 = storedDocuments.get(docId);
+      if (!document2 || document2.isDeleted) {
         throw new Error(`Document ${docId} was not found.`);
       }
       return {
         path: [...path],
-        heads: document.heads ? [...document.heads] : void 0,
-        spans: structuredClone(readRichTextSpansAtPath(document.data, path))
+        heads: document2.heads ? [...document2.heads] : void 0,
+        spans: structuredClone(readRichTextSpansAtPath(document2.data, path))
+      };
+    },
+    // Mock cursors store the index they were created at and do not follow
+    // later edits; Haven's Automerge-backed cursors do.
+    async getTextCursors(docId, path, positions, options) {
+      const document2 = storedDocuments.get(docId);
+      if (!document2 || document2.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      const text = readMockCursorText(document2.data, path);
+      return {
+        path: [...path],
+        heads: options?.heads ? [...options.heads] : [...document2.heads ?? []],
+        cursors: positions.map((position) => {
+          if (position === "start") return `${MOCK_CURSOR_PREFIX}0`;
+          if (position === "end") return `${MOCK_CURSOR_PREFIX}end`;
+          if (typeof position !== "number" || !Number.isFinite(position)) {
+            throw new Error('Text cursor positions must be numbers, "start" or "end"');
+          }
+          return `${MOCK_CURSOR_PREFIX}${Math.max(0, Math.min(Math.trunc(position), text.length))}`;
+        })
+      };
+    },
+    async resolveTextCursors(docId, path, cursors, options) {
+      const document2 = storedDocuments.get(docId);
+      if (!document2 || document2.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      const text = readMockCursorText(document2.data, path);
+      return {
+        path: [...path],
+        heads: options?.heads ? [...options.heads] : [...document2.heads ?? []],
+        positions: cursors.map((cursor) => {
+          if (typeof cursor !== "string" || !cursor.startsWith(MOCK_CURSOR_PREFIX)) {
+            throw new Error(`Unknown text cursor ${String(cursor)}`);
+          }
+          const raw = cursor.slice(MOCK_CURSOR_PREFIX.length);
+          return raw === "end" ? text.length : Math.min(Number(raw), text.length);
+        })
       };
     },
     async getAutomergeSnapshot(docId, _options) {
-      const document = storedDocuments.get(docId);
-      if (!document || document.isDeleted) {
+      const document2 = storedDocuments.get(docId);
+      if (!document2 || document2.isDeleted) {
         throw new Error(`Document ${docId} was not found.`);
       }
-      const automergeDoc = loadMockAutomergeDocument(document);
+      const automergeDoc = loadMockAutomergeDocument(document2);
       return {
         binary: Automerge.save(automergeDoc),
         heads: Automerge.getHeads(automergeDoc)
       };
     },
     async applyAutomergeChanges(docId, patch) {
-      const document = storedDocuments.get(docId);
-      if (!document || document.isDeleted) {
+      const document2 = storedDocuments.get(docId);
+      if (!document2 || document2.isDeleted) {
         throw new Error(`Document ${docId} was not found.`);
       }
-      const currentDoc = loadMockAutomergeDocument(document);
+      const currentDoc = loadMockAutomergeDocument(document2);
       const [mergedDoc] = Automerge.applyChanges(
         currentDoc,
         patch.changes.map((change) => new Uint8Array(change))
       );
-      persistMockAutomergeDocument(document, mergedDoc);
-      document.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const mergedHeads = document.heads ? [...document.heads] : [];
+      persistMockAutomergeDocument(document2, mergedDoc);
+      document2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const mergedHeads = document2.heads ? [...document2.heads] : [];
       let changesSince;
       if (patch.replicaHeads?.length) {
         const missingChanges = Automerge.getChangesSince(
@@ -1774,17 +2137,24 @@ function createDatabaseHandle(definition, peers) {
       }
       return {
         document: {
-          id: document.id,
-          data: structuredClone(document.data),
+          id: document2.id,
+          data: structuredClone(document2.data),
           heads: mergedHeads,
-          attachments: document.attachments ? structuredClone(document.attachments) : [],
-          updatedAt: document.updatedAt,
-          ...mockDecryptionKeyId(document)
+          attachments: document2.attachments ? structuredClone(document2.attachments) : [],
+          updatedAt: document2.updatedAt,
+          ...mockDecryptionKeyId(document2)
         },
         heads: mergedHeads,
         changesSince
       };
     },
+    async applyAutomergeChangesBatch(items) {
+      const results = [];
+      for (const item2 of items) {
+        results.push(await this.applyAutomergeChanges(item2.docId, item2.patch));
+      }
+      return results;
+    },
     async create(input) {
       if (input.id !== void 0 && input.idPrefix !== void 0) {
         throw new Error("documents.create: id and idPrefix are mutually exclusive");
@@ -1831,7 +2201,7 @@ function createDatabaseHandle(definition, peers) {
       const created = {
         id,
         data: {
-          ...input.set,
+          ...readMockTypedValues(input.set ?? {}),
           ...Array.isArray(input.recipients) ? { _encryptFor: mockEncryptForMap(input.recipients) } : {}
         },
         heads: [`mock-head-${++changeCounter}`],
@@ -2119,6 +2489,7 @@ function createDatabaseHandle(definition, peers) {
   const methods = definition.methods ?? {};
   let fulltextSetup = definition.fulltextSetup ?? null;
   let extractionSetup = definition.extractionSetup ?? null;
+  let summarySetup = definition.summarySetup ?? null;
   const databaseHandle = {
     async info() {
       return {
@@ -2157,15 +2528,21 @@ function createDatabaseHandle(definition, peers) {
     },
     async setExtractionSetup(config) {
       extractionSetup = config === null ? null : { ...config };
+    },
+    async getSummarySetup() {
+      return summarySetup === null ? null : structuredClone(summarySetup);
+    },
+    async setSummarySetup(config) {
+      summarySetup = config === null ? null : structuredClone(config);
     }
   };
   return {
     handle: databaseHandle,
-    listViewDocuments: () => Array.from(storedDocuments.values()).filter((document) => !document.isDeleted && !document.inaccessible).map((document) => ({
+    listViewDocuments: () => Array.from(storedDocuments.values()).filter((document2) => !document2.isDeleted && !document2.inaccessible).map((document2) => ({
       origin: definition.info.id,
-      docId: document.id,
-      data: structuredClone(document.data),
-      createdAt: document.updatedAt ?? null
+      docId: document2.id,
+      data: structuredClone(document2.data),
+      createdAt: document2.updatedAt ?? null
     })),
     documents: storedDocuments,
     notifyLiveQueries: refreshLiveQueries
@@ -2174,6 +2551,8 @@ function createDatabaseHandle(definition, peers) {
 function createMockSessionState(options = {}) {
   let launchContext = createDefaultLaunchContext(options.launchContext);
   const themeListeners = /* @__PURE__ */ new Set();
+  const hostFocusListeners = /* @__PURE__ */ new Set();
+  let hostFocused = false;
   const viewportListeners = /* @__PURE__ */ new Set();
   const uiPreferencesListeners = /* @__PURE__ */ new Set();
   const localeListeners = /* @__PURE__ */ new Set();
@@ -2465,6 +2844,23 @@ function createMockSessionState(options = {}) {
         beforeCloseListeners.delete(listener);
       };
     },
+    async requestHostFocus() {
+      hostFocused = true;
+      hostFocusListeners.forEach((listener) => listener(true));
+    },
+    async hasHostFocus() {
+      return hostFocused;
+    },
+    onHostFocusChange(listener) {
+      hostFocusListeners.add(listener);
+      return () => {
+        hostFocusListeners.delete(listener);
+      };
+    },
+    async notify(input) {
+      const id = input.id?.trim() || crypto.randomUUID();
+      return { id };
+    },
     async disconnect() {
       await options.onDisconnect?.();
     }
@@ -2527,6 +2923,10 @@ function createMockSessionState(options = {}) {
     async emitBeforeClose() {
       await Promise.all([...beforeCloseListeners].map(async (listener) => listener()));
     },
+    setHostFocused(focused) {
+      hostFocused = focused;
+      hostFocusListeners.forEach((listener) => listener(focused));
+    },
     resolveDrag(result) {
       activeDragResolve?.(result);
       activeDragResolve = null;
@@ -2552,6 +2952,9 @@ function createMockMindooDBAppSession(options = {}) {
     emitUiPreferencesChange: state.emitUiPreferencesChange,
     emitLocaleChange: state.emitLocaleChange,
     emitBeforeClose: state.emitBeforeClose,
+    emitHostFocusChange(focused) {
+      state.setHostFocused(focused);
+    },
     resolveDrag: state.resolveDrag,
     getDragProfile: state.getDragProfile
   };
@@ -2581,31 +2984,35 @@ function createFakeBridgeHost(options = {}) {
   );
   let previousWindowValue = typeof window === "undefined" ? void 0 : window;
   let installed = false;
+  function acceptConnection(message, transfer) {
+    const payload = message;
+    if (!payload || payload.protocol !== PROTOCOL || payload.type !== "mindoodb-app:connect") {
+      return false;
+    }
+    if (payload.launchId !== state.getLaunchContext().launchId) {
+      return false;
+    }
+    const port = transfer?.[0];
+    if (!port) {
+      throw new Error(
+        "Expected the bridge connection to transfer a MessagePort."
+      );
+    }
+    connectedPorts.add(port);
+    port.addEventListener("message", (event) => {
+      void handlePortMessage(port, event.data);
+    });
+    port.start();
+    const connected = {
+      protocol: PROTOCOL,
+      type: "mindoodb-app:connected"
+    };
+    port.postMessage(connected);
+    return true;
+  }
   const hostWindow = {
     postMessage(message, _targetOrigin, transfer) {
-      const payload = message;
-      if (!payload || payload.protocol !== PROTOCOL || payload.type !== "mindoodb-app:connect") {
-        return;
-      }
-      if (payload.launchId !== state.getLaunchContext().launchId) {
-        return;
-      }
-      const port = transfer?.[0];
-      if (!port) {
-        throw new Error(
-          "Expected the bridge connection to transfer a MessagePort."
-        );
-      }
-      connectedPorts.add(port);
-      port.addEventListener("message", (event) => {
-        void handlePortMessage(port, event.data);
-      });
-      port.start();
-      const connected = {
-        protocol: PROTOCOL,
-        type: "mindoodb-app:connected"
-      };
-      port.postMessage(connected);
+      acceptConnection(message, transfer);
     }
   };
   function getWindowSearch() {
@@ -2725,6 +3132,8 @@ function createFakeBridgeHost(options = {}) {
         return state.getLicensedProducts();
       case "session.listDatabases":
         return state.listDatabaseInfos();
+      case "session.listDocumentsSinceViewCursor":
+        return { items: [], nextCursor: null };
       case "session.openDatabase":
         state.getDatabase(String(params.databaseId));
         return { ok: true };
@@ -2755,6 +3164,15 @@ function createFakeBridgeHost(options = {}) {
       case "menus.hide":
         await state.session.menus.hide();
         return { ok: true };
+      case "session.requestHostFocus":
+        await state.session.requestHostFocus();
+        return null;
+      case "session.hasHostFocus":
+        return { focused: await state.session.hasHostFocus() };
+      case "notifications.show":
+        return await state.session.notify(
+          request.params
+        );
       case "session.disconnect":
         await state.session.disconnect();
         return { ok: true };
@@ -2799,6 +3217,15 @@ function createFakeBridgeHost(options = {}) {
           params.config ?? null
         );
         return { ok: true };
+      case "database.getSummarySetup":
+        return {
+          config: await state.getDatabase(String(params.databaseId)).getSummarySetup()
+        };
+      case "database.setSummarySetup":
+        await state.getDatabase(String(params.databaseId)).setSummarySetup(
+          params.config ?? null
+        );
+        return { ok: true };
       case "documents.query":
         return await state.getDatabase(String(params.databaseId)).documents.query(
           params.query
@@ -2844,6 +3271,23 @@ function createFakeBridgeHost(options = {}) {
           String(params.docId),
           params.path
         );
+      case "documents.textCursors.get":
+        return await state.getDatabase(String(params.databaseId)).documents.getTextCursors(
+          String(params.docId),
+          params.path,
+          params.positions,
+          {
+            heads: params.heads,
+            move: params.move
+          }
+        );
+      case "documents.textCursors.resolve":
+        return await state.getDatabase(String(params.databaseId)).documents.resolveTextCursors(
+          String(params.docId),
+          params.path,
+          params.cursors,
+          { heads: params.heads }
+        );
       case "documents.automerge.getSnapshot":
         return await state.getDatabase(String(params.databaseId)).documents.getAutomergeSnapshot(
           String(params.docId),
@@ -2854,6 +3298,18 @@ function createFakeBridgeHost(options = {}) {
           String(params.docId),
           params.patch
         );
+      case "documents.automerge.applyChangesBatch":
+        return await state.getDatabase(String(params.databaseId)).documents.applyAutomergeChangesBatch(
+          Array.isArray(params.items) ? params.items : []
+        );
+      case "documents.createMany":
+        return await state.getDatabase(String(params.databaseId)).documents.createMany(
+          Array.isArray(params.inputs) ? params.inputs : []
+        );
+      case "documents.deleteMany":
+        return await state.getDatabase(String(params.databaseId)).documents.deleteMany(Array.isArray(params.docIds) ? params.docIds.map(String) : []);
+      case "databases.info":
+        return await state.getDatabase(String(params.databaseId)).info();
       case "documents.create":
         return await state.getDatabase(String(params.databaseId)).documents.create(
           params.input
@@ -3205,8 +3661,19 @@ function createFakeBridgeHost(options = {}) {
       beforeCloseWaiters.get(message.closeId)?.();
       return;
     }
+    if (message.kind === "workspace-focus-requested") {
+      state.setHostFocused(true);
+      const payload = {
+        protocol: PROTOCOL,
+        kind: "host-focus-changed",
+        focused: true
+      };
+      port.postMessage(payload);
+      return;
+    }
     if (message.kind === "request") {
       requests.push(message);
+      options.onRequest?.(message);
       try {
         const customHandler = customRequestHandlers.get(message.method);
         if (customHandler) {
@@ -3221,7 +3688,7 @@ function createFakeBridgeHost(options = {}) {
         const builtinResult = await handleBuiltinRequest(message);
         if (builtinResult === void 0 && message.method !== "viewNavigators.dispose") {
           postRpcError(port, message.id, {
-            code: "unsupported-method",
+            code: "method-not-found",
             message: `No fake bridge handler is configured for ${message.method}.`
           });
           return;
@@ -3269,8 +3736,13 @@ function createFakeBridgeHost(options = {}) {
       return state.proposedApps;
     },
     install,
+    acceptConnection,
     dispose() {
       restoreWindow();
+      connectedPorts.forEach((port) => {
+        port.close();
+      });
+      connectedPorts.clear();
       viewSessions.clear();
       readStreams.clear();
       writeStreams.clear();
@@ -3315,6 +3787,15 @@ function createFakeBridgeHost(options = {}) {
       };
       connectedPorts.forEach((port) => port.postMessage(payload));
     },
+    emitHostFocusChange(focused) {
+      state.setHostFocused(focused);
+      const payload = {
+        protocol: PROTOCOL,
+        kind: "host-focus-changed",
+        focused
+      };
+      connectedPorts.forEach((port) => port.postMessage(payload));
+    },
     emitQueryResult(subscriptionId, result) {
       const payload = {
         protocol: PROTOCOL,
@@ -3372,9 +3853,13 @@ function createFakeBridgeHost(options = {}) {
   return controller;
 }
 export {
+  capabilitiesForDefinitionPermissions,
+  createBrowserTestHost,
   createEvaluatingViewNavigator,
   createFakeBridgeHost,
   createMockMindooDBAppBridge,
   createMockMindooDBAppSession,
-  loadMindoodbForTesting
+  loadMindoodbForTesting,
+  mockDatabasesFromDefinition,
+  mountHavenTestHost
 };