mindoodb-app-sdk 0.0.54 → 0.0.55

package/dist/testing/index.js

@@ -1,7 +1,8 @@
 import {
   MINDOODB_APP_VALUE_TAG,
+  pageUsers,
   releaseMindooDBAppBridgeSessions
-} from "../chunk-6NTVTL6G.js";
+} from "../chunk-S73KTYZF.js";
 
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
@@ -454,7 +455,202 @@ async function createEvaluatingViewNavigator(input, documents) {
   return wrapNavigator(input.definition, navigator);
 }
 
+// src/testing/capabilityGuard.ts
+var NONE = [];
+var READ = ["read"];
+var DOCUMENT_REQUIREMENTS = {
+  // capability probes answer false instead of failing
+  canChange: NONE,
+  canCreate: NONE,
+  canDelete: NONE,
+  canUndelete: NONE,
+  create: ["create"],
+  createMany: ["create"],
+  getDefaultCreateKeyId: ["create"],
+  listCreateKeys: ["create"],
+  update: ["update"],
+  applyAutomergeChanges: ["update"],
+  applyAutomergeChangesBatch: ["update"],
+  addRecipients: ["update"],
+  removeRecipients: ["update"],
+  setRecipients: ["update"],
+  delete: ["delete"],
+  deleteMany: ["delete"],
+  undelete: ["delete"],
+  listHistory: ["history"],
+  getAtHeads: ["history"],
+  getAtRevision: ["history"],
+  getAtTimestamp: ["history"],
+  listVerification: ["history"]
+};
+var ATTACHMENT_REQUIREMENTS = {
+  openWriteStream: ["attachments", "update"],
+  remove: ["attachments", "update"],
+  scan: ["attachments", "update"]
+};
+var DATABASE_REQUIREMENTS = {
+  info: NONE,
+  getFulltextSetup: READ,
+  getExtractionSetup: READ,
+  getSummarySetup: READ,
+  setFulltextSetup: ["update"],
+  setExtractionSetup: ["update"],
+  setSummarySetup: ["update"]
+};
+var MockForbiddenError = class extends Error {
+  name = "forbidden";
+};
+function guardApi(api, requirementOf, check) {
+  const guarded = {};
+  for (const [key, value] of Object.entries(api)) {
+    guarded[key] = typeof value === "function" ? (...args) => {
+      try {
+        check(key, requirementOf(key));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      return value.apply(api, args);
+    } : value;
+  }
+  return guarded;
+}
+function guardDatabase(database, currentInfo, enforce) {
+  const check = (area) => (method, requirement) => {
+    if (!enforce()) return;
+    const info = currentInfo();
+    for (const capability of requirement) {
+      if (!info.capabilities.includes(capability)) {
+        throw new MockForbiddenError(
+          `Database "${info.id}" was not granted the "${capability}" capability (${area}${method})`
+        );
+      }
+    }
+  };
+  const predict = (fn, capability) => async (...args) => {
+    const info = currentInfo();
+    if (enforce() && !info.capabilities.includes(capability)) {
+      return {
+        allowed: false,
+        reason: `database "${info.id}" was not granted the "${capability}" capability`,
+        tier: "tier1"
+      };
+    }
+    return await fn.apply(database.documents, args);
+  };
+  const base = guardApi(
+    database,
+    (method) => DATABASE_REQUIREMENTS[method] ?? READ,
+    check("")
+  );
+  return {
+    ...base,
+    async info() {
+      const info = currentInfo();
+      return { ...info, capabilities: [...info.capabilities] };
+    },
+    documents: {
+      ...guardApi(
+        database.documents,
+        (method) => DOCUMENT_REQUIREMENTS[method] ?? READ,
+        check("documents.")
+      ),
+      // the non-throwing predictions report the missing capability instead
+      canCreate: predict(database.documents.canCreate, "create"),
+      canChange: predict(database.documents.canChange, "update"),
+      canDelete: predict(database.documents.canDelete, "delete"),
+      canUndelete: predict(database.documents.canUndelete, "delete")
+    },
+    attachments: guardApi(
+      database.attachments,
+      (method) => ATTACHMENT_REQUIREMENTS[method] ?? ["attachments"],
+      check("attachments.")
+    ),
+    identity: guardApi(database.identity, () => ["sign"], check("identity.")),
+    timestamps: guardApi(database.timestamps, () => ["timestamps"], check("timestamps.")),
+    directory: guardApi(database.directory, () => ["directory"], check("directory."))
+  };
+}
+
+// src/testing/memoryAttachments.ts
+function concat(chunks) {
+  const bytes = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+function createMemoryAttachments() {
+  const files = /* @__PURE__ */ new Map();
+  const forDoc = (docId) => {
+    let map = files.get(docId);
+    if (!map) files.set(docId, map = /* @__PURE__ */ new Map());
+    return map;
+  };
+  return {
+    async list(docId) {
+      return [...forDoc(docId)].map(
+        ([fileName, file]) => ({
+          attachmentId: `${docId}/${fileName}`,
+          fileName,
+          mimeType: file.mimeType,
+          size: file.bytes.length
+        })
+      );
+    },
+    async remove(docId, attachmentName) {
+      forDoc(docId).delete(attachmentName);
+      return { ok: true };
+    },
+    async openReadStream(docId, attachmentName) {
+      const file = forDoc(docId).get(attachmentName);
+      if (!file) throw new Error(`Attachment not found: ${attachmentName}`);
+      let done = false;
+      return {
+        async read() {
+          if (done) return null;
+          done = true;
+          return file.bytes.slice();
+        },
+        async close() {
+        }
+      };
+    },
+    async openWriteStream(docId, attachmentName, contentType) {
+      const chunks = [];
+      return {
+        async write(chunk) {
+          chunks.push(new Uint8Array(chunk));
+        },
+        async close() {
+          forDoc(docId).set(attachmentName, {
+            bytes: concat(chunks),
+            mimeType: contentType ?? "application/octet-stream"
+          });
+        },
+        async abort() {
+          chunks.length = 0;
+        }
+      };
+    }
+  };
+}
+
 // src/testing/browserTestHost.ts
+var ALL_CAPABILITIES = [
+  "read",
+  "create",
+  "update",
+  "delete",
+  "history",
+  "attachments",
+  "views",
+  "directory",
+  "sign",
+  "timestamps",
+  "sealedchannel"
+];
 function capabilitiesForDefinitionPermissions(permissions) {
   const result = /* @__PURE__ */ new Set(["read"]);
   for (const permission of permissions ?? []) {
@@ -467,32 +663,104 @@ function capabilitiesForDefinitionPermissions(permissions) {
   }
   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 mockDatabasesFromDefinition(definition, seed = {}, options = {}) {
+  return (definition.databases ?? []).filter((database) => options.overrides?.[database.logicalDatabaseId]?.mapped !== false).map((database) => {
+    const override = options.overrides?.[database.logicalDatabaseId];
+    return {
+      info: {
+        id: database.logicalDatabaseId,
+        title: override?.title ?? database.label ?? database.logicalDatabaseId,
+        capabilities: override?.capabilities ? [...new Set(override.capabilities)] : capabilitiesForDefinitionPermissions(database.permissions)
+      },
+      documents: seed[database.logicalDatabaseId],
+      ...options.attachments === "none" ? {} : { methods: { attachments: createMemoryAttachments() } }
+    };
+  });
+}
+function readTestHostUrlSettings(search) {
+  const params = new URLSearchParams(search);
+  const settings = { overrides: {} };
+  for (const entry of params.getAll("db")) {
+    const separator = entry.indexOf(":");
+    if (separator <= 0) continue;
+    const id = entry.slice(0, separator);
+    const list = entry.slice(separator + 1);
+    settings.overrides[id] = list === "none" ? { mapped: false } : {
+      capabilities: list.split(",").map((capability) => capability.trim()).filter(
+        (capability) => ALL_CAPABILITIES.includes(capability)
+      )
+    };
+  }
+  const enforce = params.get("enforce");
+  if (enforce !== null) settings.enforceCapabilities = enforce === "1" || enforce === "true";
+  const users = Number.parseInt(params.get("users") ?? "", 10);
+  if (Number.isFinite(users) && users >= 0) settings.directoryUserCount = users;
+  const locale = params.get("locale");
+  if (locale) settings.locale = locale;
+  const theme = params.get("theme");
+  if (theme === "dark" || theme === "light") settings.theme = theme;
+  return settings;
 }
 function withLaunchId(appUrl, launchId) {
   const url = new URL(appUrl, window.location.href);
   url.searchParams.set("mindoodbAppLaunchId", launchId);
   return url.toString();
 }
+var TINY_PNG = Uint8Array.from(
+  atob(
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mN4+O7dfwAJYgPUBHcDcgAAAABJRU5ErkJggg=="
+  ),
+  (char) => char.charCodeAt(0)
+);
+async function sampleScan() {
+  const canvas = document.createElement("canvas");
+  canvas.width = 1200;
+  canvas.height = 900;
+  const g = typeof canvas.toBlob === "function" ? canvas.getContext("2d") : null;
+  if (!g) {
+    return { fileName: "sample-scan.png", mimeType: "image/png", bytes: TINY_PNG };
+  }
+  g.fillStyle = "#f4f1ea";
+  g.fillRect(0, 0, canvas.width, canvas.height);
+  g.fillStyle = "#1f2a44";
+  g.font = "bold 64px sans-serif";
+  g.fillText("Scanned page", 90, 150);
+  g.fillStyle = "#8a93a6";
+  for (let line = 0; line < 9; line += 1) {
+    g.fillRect(90, 240 + line * 60, line % 3 === 2 ? 620 : 1020, 18);
+  }
+  g.strokeStyle = "#c0392b";
+  g.lineWidth = 8;
+  g.beginPath();
+  g.arc(960, 740, 110, 0, Math.PI * 2);
+  g.stroke();
+  g.fillStyle = "#c0392b";
+  g.font = "bold 40px sans-serif";
+  g.fillText("TEST", 910, 755);
+  const blob = await new Promise((resolve) => canvas.toBlob(resolve, "image/jpeg", 0.9));
+  if (!blob) {
+    return { fileName: "sample-scan.png", mimeType: "image/png", bytes: TINY_PNG };
+  }
+  return {
+    fileName: "sample-scan.jpg",
+    mimeType: "image/jpeg",
+    bytes: new Uint8Array(await blob.arrayBuffer())
+  };
+}
 function createBrowserTestHost(options) {
-  const { frame, appUrl, onChange, ...hostOptions } = options;
-  let nextScan = null;
+  const { frame, appUrl, onChange, scanMode: initialScanMode, ...hostOptions } = options;
+  let nextScan;
+  let scanMode = initialScanMode ?? "cancel";
   let scanCounter = 0;
   const log = {
     notifications: [],
     previews: [],
     scans: [],
     focusRequests: 0,
-    requests: []
+    requests: [],
+    responses: {}
   };
+  const changed = () => queueMicrotask(() => onChange?.());
   const host = createFakeBridgeHost({
     ...hostOptions,
     onRequest(request) {
@@ -515,29 +783,56 @@ function createBrowserTestHost(options) {
         });
       }
       hostOptions.onRequest?.(request);
-      queueMicrotask(() => onChange?.());
+      changed();
+    },
+    onResponse(request, response) {
+      log.responses[request.id] = response;
+      hostOptions.onResponse?.(request, response);
+      changed();
     },
     requestHandlers: {
-      "attachments.scanAndWrite": (params) => {
+      "attachments.scanAndWrite": async (params, { host: controller }) => {
         const input = params ?? {};
-        const scan = nextScan;
-        nextScan = null;
-        log.scans.push({
-          databaseId: String(input.databaseId),
-          docId: String(input.docId),
-          result: scan ? "scanned" : "cancelled"
-        });
+        const databaseId = String(input.databaseId);
+        const docId = String(input.docId);
+        if (controller.getEnforceCapabilities()) {
+          const info = controller.listDatabases().find((entry) => entry.id === databaseId);
+          const missing = ["attachments", "update"].find(
+            (capability) => !info?.capabilities.includes(capability)
+          );
+          if (missing) {
+            const error = new Error(
+              `Database "${databaseId}" was not granted the "${missing}" capability (attachments.scan)`
+            );
+            error.name = "forbidden";
+            throw error;
+          }
+        }
+        const pending = nextScan;
+        nextScan = void 0;
+        const mode = pending === void 0 ? scanMode : pending;
+        const scan = mode === null || mode === "cancel" ? null : mode === "sample" ? await sampleScan() : mode;
         if (!scan) {
+          log.scans.push({ databaseId, docId, result: "cancelled" });
           return { ok: false };
         }
         scanCounter += 1;
+        const fileName = mode === "sample" && typeof input.defaultFileName === "string" ? input.defaultFileName : scan.fileName;
+        if (scan.bytes) {
+          const database = await controller.session.openDatabase(databaseId);
+          const writer = await database.attachments.openWriteStream(docId, fileName, scan.mimeType);
+          await writer.write(scan.bytes);
+          await writer.close();
+        }
+        const size = scan.bytes?.length ?? scan.size ?? 0;
+        log.scans.push({ databaseId, docId, result: "scanned", fileName, mimeType: scan.mimeType, size });
         return {
           ok: true,
           attachment: {
             attachmentId: `test-scan-${scanCounter}`,
-            fileName: scan.fileName,
+            fileName,
             mimeType: scan.mimeType,
-            size: scan.size
+            size
           }
         };
       },
@@ -552,12 +847,19 @@ function createBrowserTestHost(options) {
   };
   window.addEventListener("message", onMessage);
   frame.src = withLaunchId(appUrl, host.launchId);
+  const reloadApp = () => {
+    frame.src = withLaunchId(appUrl, host.launchId);
+  };
   return {
     host,
     log,
     setNextScan(scan) {
       nextScan = scan;
     },
+    setScanMode(mode) {
+      scanMode = mode;
+    },
+    getScanMode: () => scanMode,
     setTheme(theme) {
       host.emitThemeChange(theme);
       onChange?.();
@@ -566,37 +868,132 @@ function createBrowserTestHost(options) {
       host.emitHostFocusChange(focused);
       onChange?.();
     },
-    reloadApp() {
-      frame.src = withLaunchId(appUrl, host.launchId);
+    setLocale(locale) {
+      host.emitLocaleChange(locale);
+      onChange?.();
     },
+    setCapabilities(databaseId, capabilities) {
+      host.setCapabilities(databaseId, capabilities);
+      reloadApp();
+      onChange?.();
+    },
+    setEnforceCapabilities(enforce) {
+      host.setEnforceCapabilities(enforce);
+      onChange?.();
+    },
+    setDirectoryUsers(users) {
+      host.setDirectoryUsers(users);
+      onChange?.();
+    },
+    reloadApp,
     dispose() {
       window.removeEventListener("message", onMessage);
       host.dispose();
     }
   };
 }
+var TEST_HOST_LOCALES = [
+  { tag: "en-US", label: "English" },
+  { tag: "de-DE", label: "Deutsch" },
+  { tag: "fr-FR", label: "Fran\xE7ais" },
+  { tag: "es-ES", label: "Espa\xF1ol" },
+  { tag: "it-IT", label: "Italiano" },
+  { tag: "pt-BR", label: "Portugu\xEAs" },
+  { tag: "nl-NL", label: "Nederlands" },
+  { tag: "pl-PL", label: "Polski" },
+  { tag: "cs-CZ", label: "\u010Ce\u0161tina" },
+  { tag: "ru-RU", label: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  { tag: "zh-CN", label: "\u7B80\u4F53\u4E2D\u6587" },
+  { tag: "zh-TW", label: "\u7E41\u9AD4\u4E2D\u6587" },
+  { tag: "ja-JP", label: "\u65E5\u672C\u8A9E" },
+  { tag: "ko-KR", label: "\uD55C\uAD6D\uC5B4" },
+  { tag: "th-TH", label: "\u0E44\u0E17\u0E22" },
+  { tag: "vi-VN", label: "Ti\u1EBFng Vi\u1EC7t" },
+  { tag: "id-ID", label: "Bahasa Indonesia" },
+  { tag: "ms-MY", label: "Bahasa Melayu" },
+  { tag: "hi-IN", label: "\u0939\u093F\u0928\u094D\u0926\u0940" },
+  { tag: "ar-SA", label: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629" },
+  { tag: "he-IL", label: "\u05E2\u05D1\u05E8\u05D9\u05EA" }
+];
+var DIRECTORY_SIZES = [0, 5, 25, 120, 500];
 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{display:grid;grid-template-columns:minmax(0,1fr) 320px;height:100vh;margin:0;font:13px/1.45 system-ui,sans-serif;background:#eef1f7;color:#172033}
 .htest *{box-sizing:border-box}
 .htest__frame{width:100%;height:100%;border:0;background:#fff}
 .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 h3{font-size:12px;margin:10px 0 4px}
+.htest__row{display:flex;gap:6px;flex-wrap:wrap;align-items:center}
+.htest button,.htest select{font:inherit;padding:5px 9px;border-radius:7px;border:1px solid #c9d0e0;background:#fff;cursor:pointer;max-width:100%}
 .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}
+.htest__caps{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:2px 8px}
+.htest__caps label,.htest__check{display:flex;gap:5px;align-items:center}
+.htest details summary{cursor:pointer;display:flex;gap:6px;align-items:baseline}
+.htest details summary::-webkit-details-marker{display:none}
+.htest details summary::before{content:"\u25B8";color:#8a93a6}
+.htest details[open] summary::before{content:"\u25BE"}
+.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}
 @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) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (entry, depth) => {
+    if (entry instanceof Uint8Array || entry instanceof ArrayBuffer) {
+      const bytes = entry instanceof ArrayBuffer ? new Uint8Array(entry) : entry;
+      const hex = Array.from(bytes.subarray(0, 16), (byte) => byte.toString(16).padStart(2, "0")).join(" ");
+      return `<${bytes.length} bytes${bytes.length ? `: ${hex}${bytes.length > 16 ? " \u2026" : ""}` : ""}>`;
+    }
+    if (typeof entry === "string") {
+      return entry.length > maxString ? `${entry.slice(0, maxString)}\u2026 (${entry.length} chars)` : entry;
+    }
+    if (entry === null || typeof entry !== "object") return entry;
+    if (seen.has(entry)) return "<circular>";
+    if (depth >= maxDepth) return Array.isArray(entry) ? `<array(${entry.length})>` : "<object>";
+    seen.add(entry);
+    if (Array.isArray(entry)) {
+      const items = entry.slice(0, maxItems).map((child) => walk(child, depth + 1));
+      if (entry.length > maxItems) items.push(`\u2026 ${entry.length - maxItems} more`);
+      return items;
+    }
+    const result = {};
+    for (const [key, child] of Object.entries(entry)) result[key] = walk(child, depth + 1);
+    return result;
+  };
+  try {
+    return JSON.stringify(walk(value, 0), null, 2) ?? "undefined";
+  } catch {
+    return String(value);
+  }
+}
 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 {
+    container = document.body,
+    title = "Haven test host",
+    locales = TEST_HOST_LOCALES,
+    urlSettings: useUrl = true,
+    ...hostOptions
+  } = options;
+  const url = useUrl ? readTestHostUrlSettings(window.location.search) : { overrides: {} };
+  const databases = (hostOptions.databases ?? []).filter((database) => url.overrides[database.info.id]?.mapped !== false).map((database) => {
+    const capabilities = url.overrides[database.info.id]?.capabilities;
+    return capabilities ? { ...database, info: { ...database.info, capabilities } } : database;
+  });
+  const launchContext = {
+    ...hostOptions.launchContext,
+    ...url.locale ? { locale: url.locale } : {},
+    ...url.theme ? { theme: { mode: url.theme, preset: "mindoo" } } : {}
+  };
   const style = document.createElement("style");
   style.textContent = STYLE;
   document.head.append(style);
@@ -614,7 +1011,9 @@ function mountHavenTestHost(options) {
     document.body.style.margin = "0";
   }
   let focused = false;
-  let dark = false;
+  let dark = url.theme === "dark";
+  let initialDark = url.theme ? void 0 : false;
+  const openRequests = /* @__PURE__ */ new Set();
   const lists = {
     notifications: document.createElement("ul"),
     previews: document.createElement("ul"),
@@ -630,11 +1029,106 @@ function mountHavenTestHost(options) {
     node.addEventListener("click", onClick);
     return node;
   }
+  function hint(text) {
+    const node = document.createElement("p");
+    node.className = "htest__muted";
+    node.textContent = text;
+    return node;
+  }
   function section(label, ...children) {
     const heading2 = document.createElement("h2");
     heading2.textContent = label;
     panel.append(heading2, ...children);
   }
+  function syncUrl() {
+    if (!useUrl) return;
+    const params = new URLSearchParams(window.location.search);
+    for (const key of ["db", "enforce", "users", "locale", "theme"]) params.delete(key);
+    const initial = new Map((hostOptions.databases ?? []).map((database) => [database.info.id, database]));
+    for (const info of testHost.host.listDatabases()) {
+      const requested = initial.get(info.id)?.info.capabilities ?? [];
+      const same = requested.length === info.capabilities.length && requested.every((capability) => info.capabilities.includes(capability));
+      if (!same) params.append("db", `${info.id}:${info.capabilities.join(",")}`);
+    }
+    for (const [id, override] of Object.entries(url.overrides)) {
+      if (override.mapped === false) params.append("db", `${id}:none`);
+    }
+    if (testHost.host.getEnforceCapabilities()) params.set("enforce", "1");
+    const users = testHost.host.getDirectoryUsers().length;
+    if (users) params.set("users", String(users));
+    if (currentLocale) params.set("locale", currentLocale);
+    if (initialDark === void 0 || dark !== initialDark) params.set("theme", dark ? "dark" : "light");
+    const query = params.toString();
+    window.history.replaceState(
+      null,
+      "",
+      `${window.location.pathname}${query ? `?${query}` : ""}${window.location.hash}`
+    );
+  }
+  function requestEntry(request) {
+    const li = document.createElement("li");
+    const details = document.createElement("details");
+    const response = testHost.log.responses[request.id];
+    const params = request.params ?? {};
+    const summary = document.createElement("summary");
+    const method = document.createElement("span");
+    method.textContent = request.method;
+    if (response && !response.ok) method.className = "htest__error";
+    const meta = document.createElement("span");
+    meta.className = "htest__meta";
+    meta.textContent = [
+      typeof params.databaseId === "string" ? params.databaseId : null,
+      response ? `${response.durationMs.toFixed(1)} ms` : "\u2026"
+    ].filter(Boolean).join(" \xB7 ");
+    summary.append(method, meta);
+    details.append(summary);
+    const fill = () => {
+      if (details.childElementCount > 1) return;
+      const body = document.createElement("div");
+      const label = (text) => {
+        const node = document.createElement("div");
+        node.className = "htest__muted";
+        node.textContent = text;
+        return node;
+      };
+      const pre = (text, error = false) => {
+        const node = document.createElement("pre");
+        node.textContent = text;
+        if (error) node.className = "htest__error";
+        return node;
+      };
+      body.append(label("params"), pre(previewJson(request.params ?? null)));
+      if (!response) body.append(label("pending"));
+      else if (response.ok) body.append(label("result"), pre(previewJson(response.result)));
+      else body.append(label("error"), pre(`${response.error.code}: ${response.error.message}`, true));
+      details.append(body);
+    };
+    details.addEventListener("toggle", () => {
+      if (details.open) {
+        openRequests.add(request.id);
+        fill();
+      } else {
+        openRequests.delete(request.id);
+      }
+    });
+    if (openRequests.has(request.id)) {
+      details.open = true;
+      fill();
+    }
+    li.append(details);
+    return li;
+  }
+  function scanEntry(entry) {
+    const li = document.createElement("li");
+    const details = document.createElement("details");
+    const summary = document.createElement("summary");
+    summary.textContent = `${entry.result} \u2192 ${entry.docId}`;
+    const pre = document.createElement("pre");
+    pre.textContent = previewJson(entry);
+    details.append(summary, pre);
+    li.append(details);
+    return li;
+  }
   function render() {
     const { log } = testHost;
     focusState.textContent = `focused: ${focused ? "yes" : "no"} \xB7 requests: ${log.focusRequests}`;
@@ -644,10 +1138,19 @@ function mountHavenTestHost(options) {
     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)));
+    lists.scans.replaceChildren(...log.scans.map(scanEntry));
+    lists.requests.replaceChildren(...log.requests.slice(-50).reverse().map(requestEntry));
   }
-  const testHost = createBrowserTestHost({ ...hostOptions, frame, onChange: render });
+  const testHost = createBrowserTestHost({
+    ...hostOptions,
+    databases,
+    launchContext,
+    enforceCapabilities: url.enforceCapabilities ?? hostOptions.enforceCapabilities,
+    directoryUsers: url.directoryUserCount !== void 0 ? generateDirectoryUsers(url.directoryUserCount) : hostOptions.directoryUsers,
+    frame,
+    onChange: render
+  });
+  let currentLocale = url.locale;
   const badge = document.createElement("span");
   badge.className = "htest__badge";
   badge.textContent = "TEST HOST \xB7 MOCK DATA";
@@ -660,6 +1163,7 @@ function mountHavenTestHost(options) {
     button("Toggle theme", () => {
       dark = !dark;
       testHost.setTheme({ mode: dark ? "dark" : "light", preset: "mindoo" });
+      syncUrl();
     }),
     button("Toggle focus", () => {
       focused = !focused;
@@ -668,31 +1172,121 @@ function mountHavenTestHost(options) {
     button("Reload app", () => testHost.reloadApp())
   );
   section("Host", hostRow, focusState);
+  const language = document.createElement("select");
+  language.dataset.testid = "haven-test-language";
+  language.setAttribute("aria-label", "Language");
+  for (const { tag, label } of locales) language.add(new Option(`${label} (${tag})`, tag));
+  void testHost.host.session.getLaunchContext().then((context) => {
+    if (![...language.options].some((option) => option.value === context.locale)) {
+      language.add(new Option(context.locale, context.locale), 0);
+    }
+    language.value = context.locale;
+    dark = context.theme.mode === "dark";
+    if (!url.theme) initialDark = dark;
+  });
+  language.addEventListener("change", () => {
+    currentLocale = language.value;
+    testHost.setLocale(language.value);
+    syncUrl();
+  });
+  section("Language", language, hint("Haven's locale; the app switches without a reload."));
+  const enforce = document.createElement("label");
+  enforce.className = "htest__check";
+  const enforceBox = document.createElement("input");
+  enforceBox.type = "checkbox";
+  enforceBox.dataset.testid = "haven-test-enforce";
+  enforceBox.checked = testHost.host.getEnforceCapabilities();
+  enforceBox.addEventListener("change", () => {
+    testHost.setEnforceCapabilities(enforceBox.checked);
+    syncUrl();
+  });
+  enforce.append(enforceBox, "Enforce capabilities (reject calls not granted)");
+  const databaseBlocks = testHost.host.listDatabases().map((info) => {
+    const block = document.createElement("div");
+    const name = document.createElement("h3");
+    name.textContent = info.title === info.id ? info.id : `${info.title} (${info.id})`;
+    const grid = document.createElement("div");
+    grid.className = "htest__caps";
+    const boxes = /* @__PURE__ */ new Map();
+    for (const capability of ALL_CAPABILITIES) {
+      const label = document.createElement("label");
+      const box = document.createElement("input");
+      box.type = "checkbox";
+      box.checked = info.capabilities.includes(capability);
+      box.dataset.testid = `haven-test-cap-${info.id}-${capability}`;
+      box.addEventListener("change", () => {
+        const granted = ALL_CAPABILITIES.filter((entry) => boxes.get(entry)?.checked);
+        testHost.setCapabilities(info.id, granted);
+        syncUrl();
+      });
+      boxes.set(capability, box);
+      label.append(box, capability);
+      grid.append(label);
+    }
+    block.append(name, grid);
+    return block;
+  });
+  section(
+    "Databases",
+    enforce,
+    ...databaseBlocks,
+    hint("Changing a capability relaunches the app. Unmap a database with ?db=<id>:none in the URL.")
+  );
+  const directory = document.createElement("select");
+  directory.dataset.testid = "haven-test-directory";
+  directory.setAttribute("aria-label", "Directory users");
+  const userCount = testHost.host.getDirectoryUsers().length;
+  const sizes = DIRECTORY_SIZES.includes(userCount) ? DIRECTORY_SIZES : [...DIRECTORY_SIZES, userCount];
+  for (const size of sizes.sort((a, b) => a - b)) {
+    directory.add(new Option(size === userCount && !DIRECTORY_SIZES.includes(size) ? `${size} (custom)` : `${size} users`, String(size)));
+  }
+  directory.value = String(userCount);
+  directory.addEventListener("change", () => {
+    testHost.setDirectoryUsers(generateDirectoryUsers(Number(directory.value)));
+    syncUrl();
+  });
+  section("Directory", directory, hint("Usernames directory.listUsers() returns, e.g. to test paging."));
+  const scan = document.createElement("select");
+  scan.dataset.testid = "haven-test-scan-mode";
+  scan.setAttribute("aria-label", "Scanner result");
+  scan.add(new Option("Cancel the scan", "cancel"));
+  scan.add(new Option("Sample image", "sample"));
+  scan.add(new Option("Chosen file", "file"));
   const scanInput = document.createElement("input");
   scanInput.type = "file";
   scanInput.accept = "image/jpeg,image/png,application/pdf";
-  scanInput.addEventListener("change", () => {
+  const initialMode = testHost.getScanMode();
+  scan.value = typeof initialMode === "string" ? initialMode : "file";
+  scanInput.hidden = scan.value !== "file";
+  const applyScanMode = async () => {
+    scanInput.hidden = scan.value !== "file";
+    if (scan.value !== "file") {
+      testHost.setScanMode(scan.value);
+      return;
+    }
     const file = scanInput.files?.[0];
-    testHost.setNextScan(
+    testHost.setScanMode(
       file ? {
         fileName: file.name,
         mimeType: file.type === "image/png" || file.type === "application/pdf" ? file.type : "image/jpeg",
-        size: file.size
-      } : null
+        bytes: new Uint8Array(await file.arrayBuffer())
+      } : "cancel"
     );
-  });
-  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);
+  };
+  scan.addEventListener("change", () => void applyScanMode());
+  scanInput.addEventListener("change", () => void applyScanMode());
+  section(
+    "Scanner",
+    scan,
+    scanInput,
+    hint("What attachments.scan() returns; the file is attached to the document like in Haven.")
+  );
   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";
-  });
+  section("Requests (latest first, click for details)", lists.requests);
   render();
+  syncUrl();
   window.__havenTestHost = testHost;
   return testHost;
 }
@@ -1864,7 +2458,7 @@ async function mockSha256Hex(value) {
   const digest = await subtle.digest("SHA-256", new TextEncoder().encode(value));
   return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function createDatabaseHandle(definition, peers) {
+function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
   let createCounter = 0;
   let changeCounter = 0;
   const defaultViewFactory = async () => createDefaultViewNavigator();
@@ -2430,9 +3024,7 @@ function createDatabaseHandle(definition, peers) {
         status: "unknown"
       }));
     },
-    async listUsers() {
-      return [];
-    }
+    listUsers: (async (options) => options ? pageUsers(directoryUsers(), options) : [...directoryUsers()])
   };
   const defaultViews = {
     async create(_input) {
@@ -2650,15 +3242,23 @@ function createMockSessionState(options = {}) {
       capabilities: [...definition.info.capabilities]
     }));
     for (const definition of definitions) {
-      const created = createDatabaseHandle(definition, databasePeers);
-      databaseHandles.set(definition.info.id, created.handle);
+      const created = createDatabaseHandle(definition, databasePeers, () => directoryUsers);
+      const databaseId = definition.info.id;
+      databaseHandles.set(
+        databaseId,
+        guardDatabase(
+          created.handle,
+          () => databaseInfos.find((entry) => entry.id === databaseId) ?? definition.info,
+          () => enforceCapabilities
+        )
+      );
       databaseViewDocumentLists.set(definition.info.id, created.listViewDocuments);
       databaseDocumentStores.set(definition.info.id, created.documents);
       databaseLiveQueryRefreshers.set(definition.info.id, created.notifyLiveQueries);
       databaseViewApis.set(definition.info.id, {
         async create(input) {
-          const documents = input.databaseIds.flatMap((databaseId) => {
-            const list = databaseViewDocumentLists.get(databaseId);
+          const documents = input.databaseIds.flatMap((databaseId2) => {
+            const list = databaseViewDocumentLists.get(databaseId2);
             return list ? list() : [];
           });
           const evaluating = await createEvaluatingViewNavigator(input, documents);
@@ -2678,6 +3278,16 @@ function createMockSessionState(options = {}) {
       databases: databaseInfos
     });
   };
+  let enforceCapabilities = options.enforceCapabilities ?? false;
+  let directoryUsers = [...options.directoryUsers ?? []];
+  const setCapabilities = (databaseId, capabilities) => {
+    const entry = databaseInfos.find((info) => info.id === databaseId);
+    if (!entry) {
+      throw new Error(`Unknown test database: ${databaseId}`);
+    }
+    entry.capabilities = [...new Set(capabilities)];
+    launchContext = mergeLaunchContext(launchContext, { databases: databaseInfos });
+  };
   setDatabases(options.databases ?? []);
   const session = {
     async getLaunchContext() {
@@ -2885,6 +3495,15 @@ function createMockSessionState(options = {}) {
       }));
     },
     setDatabases,
+    setCapabilities,
+    setEnforceCapabilities(enforce) {
+      enforceCapabilities = enforce;
+    },
+    getEnforceCapabilities: () => enforceCapabilities,
+    setDirectoryUsers(users) {
+      directoryUsers = [...users];
+    },
+    getDirectoryUsers: () => [...directoryUsers],
     getDatabase(databaseId) {
       const database = databaseHandles.get(databaseId);
       if (!database) {
@@ -2936,6 +3555,15 @@ function createMockSessionState(options = {}) {
     }
   };
 }
+function generateDirectoryUsers(count, options = {}) {
+  const prefix = options.prefix ?? "Test User";
+  const organization = options.organization ?? "Test";
+  const width = String(Math.max(count, 1)).length;
+  return Array.from(
+    { length: count },
+    (_, index) => `CN=${prefix} ${String(index + 1).padStart(width, "0")}/O=${organization}`
+  );
+}
 function createMockMindooDBAppSession(options = {}) {
   const state = createMockSessionState(options);
   return {
@@ -2947,6 +3575,9 @@ function createMockMindooDBAppSession(options = {}) {
     proposedApps: state.proposedApps,
     listDatabases: state.listDatabaseInfos,
     setDatabases: state.setDatabases,
+    setCapabilities: state.setCapabilities,
+    setEnforceCapabilities: state.setEnforceCapabilities,
+    setDirectoryUsers: state.setDirectoryUsers,
     emitThemeChange: state.emitThemeChange,
     emitViewportChange: state.emitViewportChange,
     emitUiPreferencesChange: state.emitUiPreferencesChange,
@@ -3392,8 +4023,16 @@ function createFakeBridgeHost(options = {}) {
         return await state.getDatabase(String(params.databaseId)).directory.excerpt(
           Array.isArray(params.publicKeys) ? params.publicKeys.map(String) : []
         );
-      case "directory.listUsers":
-        return await state.getDatabase(String(params.databaseId)).directory.listUsers();
+      case "directory.listUsers": {
+        const directory = state.getDatabase(String(params.databaseId)).directory;
+        const paged = params.query !== void 0 || params.cursor !== void 0 || params.limit !== void 0;
+        if (!paged) return await directory.listUsers();
+        return await directory.listUsers({
+          query: typeof params.query === "string" ? params.query : void 0,
+          cursor: typeof params.cursor === "string" ? params.cursor : void 0,
+          limit: typeof params.limit === "number" ? params.limit : void 0
+        });
+      }
       case "attachments.list":
         return await state.getDatabase(String(params.databaseId)).attachments.list(
           String(params.docId),
@@ -3674,6 +4313,23 @@ function createFakeBridgeHost(options = {}) {
     if (message.kind === "request") {
       requests.push(message);
       options.onRequest?.(message);
+      const startedAt = performance.now();
+      const succeed = (result) => {
+        postRpcSuccess(port, message.id, result);
+        options.onResponse?.(message, {
+          ok: true,
+          result,
+          durationMs: performance.now() - startedAt
+        });
+      };
+      const fail = (error) => {
+        postRpcError(port, message.id, error);
+        options.onResponse?.(message, {
+          ok: false,
+          error,
+          durationMs: performance.now() - startedAt
+        });
+      };
       try {
         const customHandler = customRequestHandlers.get(message.method);
         if (customHandler) {
@@ -3682,20 +4338,20 @@ function createFakeBridgeHost(options = {}) {
             request: message,
             port
           });
-          postRpcSuccess(port, message.id, result);
+          succeed(result);
           return;
         }
         const builtinResult = await handleBuiltinRequest(message);
         if (builtinResult === void 0 && message.method !== "viewNavigators.dispose") {
-          postRpcError(port, message.id, {
+          fail({
             code: "method-not-found",
             message: `No fake bridge handler is configured for ${message.method}.`
           });
           return;
         }
-        postRpcSuccess(port, message.id, builtinResult);
+        succeed(builtinResult);
       } catch (error) {
-        postRpcError(port, message.id, createBridgeErrorPayload(error));
+        fail(createBridgeErrorPayload(error));
       }
       return;
     }
@@ -3737,6 +4393,12 @@ function createFakeBridgeHost(options = {}) {
     },
     install,
     acceptConnection,
+    listDatabases: state.listDatabaseInfos,
+    setCapabilities: state.setCapabilities,
+    setEnforceCapabilities: state.setEnforceCapabilities,
+    getEnforceCapabilities: state.getEnforceCapabilities,
+    setDirectoryUsers: state.setDirectoryUsers,
+    getDirectoryUsers: state.getDirectoryUsers,
     dispose() {
       restoreWindow();
       connectedPorts.forEach((port) => {
@@ -3853,13 +4515,20 @@ function createFakeBridgeHost(options = {}) {
   return controller;
 }
 export {
+  ALL_CAPABILITIES,
+  MockForbiddenError,
+  TEST_HOST_LOCALES,
   capabilitiesForDefinitionPermissions,
   createBrowserTestHost,
   createEvaluatingViewNavigator,
   createFakeBridgeHost,
+  createMemoryAttachments,
   createMockMindooDBAppBridge,
   createMockMindooDBAppSession,
+  generateDirectoryUsers,
   loadMindoodbForTesting,
   mockDatabasesFromDefinition,
-  mountHavenTestHost
+  mountHavenTestHost,
+  previewJson,
+  readTestHostUrlSettings
 };