mindoodb-app-sdk 0.0.53 → 0.0.55

package/dist/index.js

@@ -8,6 +8,7 @@ import {
   MINDOODB_APP_MAX_DRAG_TYPES,
   MINDOODB_APP_VALUE_TAG,
   MINIMAL_DRAG_PREVIEW_PNG,
+  MindooDBAppAgentToolError,
   MindooDBAppDragInputError,
   MindooDBAppValue,
   applyHostedDocumentOverscrollContain,
@@ -23,7 +24,7 @@ import {
   releaseMindooDBAppBridgeSessions,
   sanitizeHostShortcutBindings,
   snapshotElementToPng
-} from "./chunk-6NTVTL6G.js";
+} from "./chunk-S73KTYZF.js";
 import {
   MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME,
   MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME,
@@ -286,6 +287,13 @@ function readListing(value, errors) {
     errors
   );
   if (description) listing.description = description;
+  const descriptionMarkdown = readLocalizedText(
+    value.descriptionMarkdown,
+    "App definition listing.descriptionMarkdown",
+    MINDOODB_APP_LISTING_DESCRIPTION_MAX,
+    errors
+  );
+  if (descriptionMarkdown) listing.descriptionMarkdown = descriptionMarkdown;
   const icon = readListingAssetPath(value.icon, "App definition listing.icon", errors);
   if (icon) listing.icon = icon;
   if (value.screenshots !== void 0 && value.screenshots !== null) {
@@ -575,6 +583,212 @@ function isHostedBundleRuntime(search) {
   return readMindooDBAppHostingMode(search) === "hosted";
 }
 
+// src/listingMarkdown.ts
+var MAX_INLINE_DEPTH = 4;
+var HEADING = /^#{1,6}\s+(.*?)\s*#*\s*$/;
+var BULLET = /^[-*+]\s+(.*)$/;
+var ORDERED = /^\d{1,9}[.)]\s+(.*)$/;
+var ESCAPABLE = new Set("\\`*_[]()#+-.!<>".split(""));
+var BARE_URL_TRAILING_PUNCTUATION = /[.,;:!?)\]'"]+$/;
+function sanitizeListingHref(raw) {
+  const cleaned = raw.replace(/[\t\n\r]/g, "").trim();
+  if (!cleaned) {
+    return null;
+  }
+  try {
+    const url = new URL(cleaned);
+    if (url.protocol === "https:") {
+      return url.toString();
+    }
+    if (url.protocol === "mailto:" && url.pathname) {
+      return url.toString();
+    }
+  } catch {
+  }
+  return null;
+}
+function isWordCharacter(char) {
+  return char !== void 0 && /[\p{L}\p{N}]/u.test(char);
+}
+function pushText(nodes, text) {
+  if (!text) {
+    return;
+  }
+  const last = nodes[nodes.length - 1];
+  if (last?.type === "text") {
+    last.text += text;
+  } else {
+    nodes.push({ type: "text", text });
+  }
+}
+function findClosingDelimiter(text, from, delimiter) {
+  let index = text.indexOf(delimiter, from);
+  while (index !== -1) {
+    const before = text[index - 1];
+    const after = text[index + delimiter.length];
+    const closesAfterContent = index > from && before !== " " && before !== "\\";
+    const underscoreBoundary = delimiter[0] !== "_" || !isWordCharacter(after);
+    if (closesAfterContent && underscoreBoundary) {
+      return index;
+    }
+    index = text.indexOf(delimiter, index + 1);
+  }
+  return -1;
+}
+function findLinkTargetEnd(text, from) {
+  let open = 0;
+  for (let index = from; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "(") {
+      open += 1;
+    } else if (char === ")") {
+      if (open === 0) return index;
+      open -= 1;
+    } else if (char === " ") {
+      return -1;
+    }
+  }
+  return -1;
+}
+function parseInline(text, depth = 0) {
+  const nodes = [];
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\" && ESCAPABLE.has(text[index + 1] ?? "")) {
+      pushText(nodes, text[index + 1]);
+      index += 2;
+      continue;
+    }
+    if (char === "`") {
+      const end = text.indexOf("`", index + 1);
+      if (end > index + 1) {
+        nodes.push({ type: "code", text: text.slice(index + 1, end) });
+        index = end + 1;
+        continue;
+      }
+    }
+    if (depth < MAX_INLINE_DEPTH && (char === "*" || char === "_")) {
+      const strong = text[index + 1] === char;
+      const delimiter = strong ? char + char : char;
+      const next = text[index + delimiter.length];
+      const opens = next !== void 0 && next !== " " && (char !== "_" || !isWordCharacter(text[index - 1]));
+      if (opens) {
+        const end = findClosingDelimiter(text, index + delimiter.length, delimiter);
+        if (end !== -1) {
+          const children = parseInline(text.slice(index + delimiter.length, end), depth + 1);
+          nodes.push(strong ? { type: "strong", children } : { type: "em", children });
+          index = end + delimiter.length;
+          continue;
+        }
+      }
+    }
+    if (char === "[" && depth < MAX_INLINE_DEPTH) {
+      const labelEnd = text.indexOf("](", index + 1);
+      const urlEnd = labelEnd === -1 ? -1 : findLinkTargetEnd(text, labelEnd + 2);
+      if (labelEnd > index + 1 && urlEnd !== -1) {
+        const label = parseInline(text.slice(index + 1, labelEnd), depth + 1);
+        const href = sanitizeListingHref(text.slice(labelEnd + 2, urlEnd));
+        if (href) {
+          nodes.push({ type: "link", href, children: label });
+        } else {
+          nodes.push(...label);
+        }
+        index = urlEnd + 1;
+        continue;
+      }
+    }
+    if (char === "h" && text.startsWith("https://", index) && !isWordCharacter(text[index - 1])) {
+      let end = index;
+      while (end < text.length && !/\s/.test(text[end])) end += 1;
+      const candidate = text.slice(index, end).replace(BARE_URL_TRAILING_PUNCTUATION, "");
+      const href = sanitizeListingHref(candidate);
+      if (href) {
+        nodes.push({ type: "link", href, children: [{ type: "text", text: candidate }] });
+        index += candidate.length;
+        continue;
+      }
+    }
+    pushText(nodes, char);
+    index += 1;
+  }
+  return nodes;
+}
+function parseListingMarkdown(markdown) {
+  const blocks = [];
+  let paragraph = [];
+  let list = null;
+  const flushParagraph = () => {
+    if (paragraph.length) {
+      blocks.push({ type: "paragraph", children: parseInline(paragraph.join(" ")) });
+      paragraph = [];
+    }
+  };
+  const flushList = () => {
+    if (list) {
+      blocks.push({ type: "list", ordered: list.ordered, items: list.items.map((item) => parseInline(item)) });
+      list = null;
+    }
+  };
+  for (const rawLine of markdown.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      flushParagraph();
+      flushList();
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    const bullet = BULLET.exec(line);
+    const ordered = bullet ? null : ORDERED.exec(line);
+    if (heading) {
+      flushParagraph();
+      flushList();
+      blocks.push({ type: "heading", children: parseInline(heading[1]) });
+    } else if (bullet || ordered) {
+      flushParagraph();
+      const isOrdered = Boolean(ordered);
+      if (list && list.ordered !== isOrdered) {
+        flushList();
+      }
+      list ??= { ordered: isOrdered, items: [] };
+      list.items.push((bullet ?? ordered)[1]);
+    } else if (list) {
+      list.items[list.items.length - 1] += ` ${line}`;
+    } else {
+      paragraph.push(line);
+    }
+  }
+  flushParagraph();
+  flushList();
+  return blocks;
+}
+function inlineToPlainText(nodes) {
+  return nodes.map((node) => {
+    if (node.type === "text" || node.type === "code") {
+      return node.text;
+    }
+    const label = inlineToPlainText(node.children);
+    if (node.type !== "link") {
+      return label;
+    }
+    const target = node.href.replace(/^mailto:/, "").replace(/^https:\/\//, "").replace(/\/$/, "");
+    return label.includes(target) ? label : `${label} (${node.href.replace(/^mailto:/, "")})`;
+  }).join("");
+}
+function listingMarkdownToPlainText(markdown) {
+  const paragraphs = [];
+  for (const block of parseListingMarkdown(markdown)) {
+    if (block.type === "list") {
+      block.items.forEach((item, index) => {
+        paragraphs.push(`${block.ordered ? `${index + 1}.` : "\u2022"} ${inlineToPlainText(item)}`);
+      });
+    } else {
+      paragraphs.push(inlineToPlainText(block.children));
+    }
+  }
+  return paragraphs.filter((paragraph) => paragraph.trim()).join("\n\n");
+}
+
 // src/landing.ts
 var DEFAULT_HAVEN_URL = "https://haven.mindoodb.com";
 var APP_ICON_FALLBACKS = ["appicon.png", "appicon.webp", "appicon.svg"];
@@ -638,6 +852,43 @@ function el(tag, className, text) {
   if (text !== void 0) node.textContent = text;
   return node;
 }
+function externalLink(href) {
+  const link = el("a");
+  link.href = href;
+  link.rel = "noopener noreferrer";
+  link.target = "_blank";
+  return link;
+}
+function appendInline(parent, nodes) {
+  for (const node of nodes) {
+    if (node.type === "text") {
+      parent.append(node.text);
+    } else if (node.type === "code") {
+      parent.append(el("code", void 0, node.text));
+    } else {
+      const child = node.type === "link" ? externalLink(node.href) : el(node.type);
+      appendInline(child, node.children);
+      parent.append(child);
+    }
+  }
+}
+function renderMarkdownDescription(block, markdown) {
+  for (const entry of parseListingMarkdown(markdown)) {
+    if (entry.type === "list") {
+      const list = el(entry.ordered ? "ol" : "ul");
+      for (const item of entry.items) {
+        const li = el("li");
+        appendInline(li, item);
+        list.append(li);
+      }
+      block.append(list);
+    } else {
+      const node = el(entry.type === "heading" ? "h2" : "p");
+      appendInline(node, entry.children);
+      block.append(node);
+    }
+  }
+}
 var STYLE_ID = "mdb-landing-style";
 var STYLE = `
 .mdb-landing{--bg:#f4f6fb;--card:#fff;--text:#172033;--muted:#5b6478;--line:#e2e6ef;--accent:#1f3a8a;--accent-text:#fff;
@@ -657,7 +908,12 @@ var STYLE = `
 .mdb-landing__button:focus-visible{outline:3px solid var(--accent);outline-offset:3px}
 .mdb-landing__hint{margin:0;max-width:420px;color:var(--muted);font-size:14px}
 .mdb-landing__description{margin:32px 0 0}
-.mdb-landing__description p{margin:0 0 12px}
+.mdb-landing__description p,.mdb-landing__description ul,.mdb-landing__description ol{margin:0 0 12px}
+.mdb-landing__description ul,.mdb-landing__description ol{padding-left:22px}
+.mdb-landing__description li+li{margin-top:4px}
+.mdb-landing__description h2{margin:20px 0 8px;font-size:17px}
+.mdb-landing__description code{font:.92em ui-monospace,SFMono-Regular,Menlo,monospace;padding:1px 5px;border-radius:5px;background:var(--line)}
+.mdb-landing__description a,.mdb-landing__meta a{color:var(--accent)}
 .mdb-landing__shots-title{margin:32px 0 12px;font-size:15px;color:var(--muted);font-weight:600}
 .mdb-landing__shots{display:grid;grid-auto-flow:column;grid-auto-columns:min(78%,420px);gap:16px;overflow-x:auto;padding-bottom:8px;scroll-snap-type:x mandatory}
 .mdb-landing__shot{margin:0;scroll-snap-align:start}
@@ -706,11 +962,14 @@ async function renderHavenAppLandingPage(options = {}) {
   }
   const titles = el("div");
   titles.append(el("p", "mdb-landing__eyebrow", strings.eyebrow), el("h1", "mdb-landing__title", label));
-  const meta = [format(strings.from, { origin })];
+  const meta = el("p", "mdb-landing__meta");
   if (listing?.publisher) {
-    meta.unshift(format(strings.by, { publisher: listing.publisher.name }));
+    const [before, after = ""] = strings.by.split("{publisher}");
+    const name = listing.publisher.url ? Object.assign(externalLink(listing.publisher.url), { textContent: listing.publisher.name }) : listing.publisher.name;
+    meta.append(before ?? "", name, after, " \xB7 ");
   }
-  titles.append(el("p", "mdb-landing__meta", meta.join(" \xB7 ")));
+  meta.append(format(strings.from, { origin }));
+  titles.append(meta);
   head.append(titles);
   card.append(head);
   const summary = resolveMindooDBAppLocalizedText(listing?.summary, locale) || definition?.description || strings.fallbackSummary;
@@ -722,11 +981,16 @@ async function renderHavenAppLandingPage(options = {}) {
   button.dataset.testid = "haven-app-landing-install";
   cta.append(button, el("p", "mdb-landing__hint", format(strings.ctaHint, { label })));
   card.append(cta);
+  const descriptionMarkdown = resolveMindooDBAppLocalizedText(listing?.descriptionMarkdown, locale);
   const description = resolveMindooDBAppLocalizedText(listing?.description, locale);
-  if (description) {
+  if (descriptionMarkdown || description) {
     const block = el("section", "mdb-landing__description");
-    for (const paragraph of description.split(/\n\s*\n/)) {
-      if (paragraph.trim()) block.append(el("p", void 0, paragraph.trim()));
+    if (descriptionMarkdown) {
+      renderMarkdownDescription(block, descriptionMarkdown);
+    } else {
+      for (const paragraph of description.split(/\n\s*\n/)) {
+        if (paragraph.trim()) block.append(el("p", void 0, paragraph.trim()));
+      }
     }
     card.append(block);
   }
@@ -1438,6 +1702,7 @@ export {
   MINDOODB_APP_VALUE_TAG,
   MINDOODB_APP_WELL_KNOWN_DRAG_TYPES,
   MINIMAL_DRAG_PREVIEW_PNG,
+  MindooDBAppAgentToolError,
   MindooDBAppDragInputError,
   MindooDBAppValue,
   MindooDBRichTextHandle,
@@ -1461,11 +1726,13 @@ export {
   isLaunchedByHaven,
   isMindooDBAppBundleHash,
   isMindooDBAppDragType,
+  listingMarkdownToPlainText,
   matchHostShortcut,
   normalizeDragAccepts,
   normalizeDragPointerInput,
   normalizeDragStartInput,
   normalizeMindooDBAppBundlePath,
+  parseListingMarkdown,
   queryDocuments,
   readMindooDBAppHostingMode,
   readMindooDBAppLaunchId,
@@ -1476,6 +1743,7 @@ export {
   resolveMindooDBAppListingAssetUrl,
   resolveMindooDBAppLocalizedText,
   sanitizeHostShortcutBindings,
+  sanitizeListingHref,
   snapshotElementToPng,
   validateMindooDBAppBundleManifest,
   validateMindooDBAppDefinition,

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { ay as MindooDBAppCreateViewNavigatorInput, cC as MindooDBAppViewNavigator, $ as MindooDBAppBridgeRpcRequest, b7 as MindooDBAppHostTheme, ag as MindooDBAppCapability, i as MindooDBAppDefinition, e as MindooDBAppBridge, cc as MindooDBAppSession, bE as MindooDBAppProposeAppInput, cK as MindooDBAppViewport, cw as MindooDBAppUiPreferences, bK as MindooDBAppQueryResult, cJ as MindooDBAppViewUpdateStats, X as MindooDBAppBridgePortMessage, bl as MindooDBAppLaunchContext, az as MindooDBAppDatabaseInfo, aI as MindooDBAppDocumentApi, cE as MindooDBAppViewNavigatorOpenOptions, A as MindooDBAppAttachmentApi, b8 as MindooDBAppIdentityApi, cs as MindooDBAppTimestampApi, aG as MindooDBAppDirectoryApi, k as MindooDBAppDocument, b4 as MindooDBAppFulltextSetup, b3 as MindooDBAppExtractionSetup, ck as MindooDBAppSummarySetup, bF as MindooDBAppProposeAppResult, c as MindooDBAppDragStartResult, aZ as MindooDBAppDragProfile } from '../types-CsKw_niD.js';
+import { aG as MindooDBAppCreateViewNavigatorInput, cM as MindooDBAppViewNavigator, a7 as MindooDBAppBridgeRpcRequest, bf as MindooDBAppHostTheme, ao as MindooDBAppCapability, j as MindooDBAppDefinition, G as MindooDBAppAttachmentApi, e as MindooDBAppBridge, cm as MindooDBAppSession, bO as MindooDBAppProposeAppInput, cU as MindooDBAppViewport, cG as MindooDBAppUiPreferences, bU as MindooDBAppQueryResult, cT as MindooDBAppViewUpdateStats, a3 as MindooDBAppBridgePortMessage, aH as MindooDBAppDatabaseInfo, $ as MindooDBAppBridgeErrorPayload, bt as MindooDBAppLaunchContext, aQ as MindooDBAppDocumentApi, cO as MindooDBAppViewNavigatorOpenOptions, bg as MindooDBAppIdentityApi, cC as MindooDBAppTimestampApi, aO as MindooDBAppDirectoryApi, l as MindooDBAppDocument, bc as MindooDBAppFulltextSetup, bb as MindooDBAppExtractionSetup, cu as MindooDBAppSummarySetup, bP as MindooDBAppProposeAppResult, c as MindooDBAppDragStartResult, b5 as MindooDBAppDragProfile } from '../types-Dl70Tlfj.js';
 import * as mindoodb from 'mindoodb';
 import 'mindoodb-view-language';
 
@@ -31,12 +31,22 @@ declare function createEvaluatingViewNavigator(input: MindooDBAppCreateViewNavig
  * tenant and an install in a real Haven. It is never meant to be deployed where end
  * users can reach it.
  */
-/** A scan the test host hands out on the app's next `attachments.scan()` call. */
+/**
+ * A scan the test host hands out on the app's `attachments.scan()` call. With `bytes`
+ * the file is written to the document's attachments, as Haven's scanner does; without,
+ * only the attachment info is returned.
+ */
 interface BrowserTestHostScan {
     fileName: string;
     mimeType: "image/jpeg" | "image/png" | "application/pdf";
-    size: number;
+    size?: number;
+    bytes?: Uint8Array;
 }
+/**
+ * What a scan returns when no {@link BrowserTestHost.setNextScan} is pending: cancel,
+ * a generated sample page, or a fixed file.
+ */
+type BrowserTestHostScanMode = "cancel" | "sample" | BrowserTestHostScan;
 /** What the test host recorded, in the order the app asked. */
 interface BrowserTestHostLog {
     notifications: Array<{
@@ -54,15 +64,22 @@ interface BrowserTestHostLog {
         databaseId: string;
         docId: string;
         result: "scanned" | "cancelled";
+        fileName?: string;
+        mimeType?: string;
+        size?: number;
     }>;
     focusRequests: number;
     requests: MindooDBAppBridgeRpcRequest[];
+    /** The answer to each request, by request id (result or error, duration). */
+    responses: Record<string, FakeBridgeRpcResponse>;
 }
 interface CreateBrowserTestHostOptions extends CreateFakeBridgeHostOptions {
     /** The iframe the app runs in. Its `src` is set by the host. */
     frame: HTMLIFrameElement;
     /** URL of the app page, relative to the test page or absolute. */
     appUrl: string;
+    /** What scans return while no `setNextScan()` is pending. Default `"cancel"`. */
+    scanMode?: BrowserTestHostScanMode;
     /** Called after every request, e.g. to re-render a control panel. */
     onChange?: () => void;
 }
@@ -70,30 +87,98 @@ interface BrowserTestHost {
     host: FakeBridgeHostController;
     log: BrowserTestHostLog;
     /**
-     * Decides the outcome of the app's next `attachments.scan()`: a file description to
-     * "scan", or `null` to act as if the user cancelled. Without a call, scans cancel.
+     * Decides the outcome of the app's next `attachments.scan()`: a file to "scan", or
+     * `null` to act as if the user cancelled. Later scans follow {@link setScanMode}.
      */
     setNextScan(scan: BrowserTestHostScan | null): void;
+    /** What scans return while no `setNextScan()` is pending. */
+    setScanMode(mode: BrowserTestHostScanMode): void;
+    getScanMode(): BrowserTestHostScanMode;
     setTheme(theme: MindooDBAppHostTheme): void;
     setHostFocus(focused: boolean): void;
+    /** Haven's language changed: the app gets `onLocaleChange`, no reload. */
+    setLocale(locale: string): void;
+    /**
+     * Grants a mapped database these capabilities and reloads the app, like Haven
+     * relaunching it after a permission change.
+     */
+    setCapabilities(databaseId: string, capabilities: MindooDBAppCapability[]): void;
+    /** Turns the capability checks on or off (`enforceCapabilities`). */
+    setEnforceCapabilities(enforce: boolean): void;
+    /** Replaces the usernames of the tenant directory (`directory.listUsers()`). */
+    setDirectoryUsers(users: readonly string[]): void;
     /** Reloads the app frame. The mock data survives; the app's in-memory state does not. */
     reloadApp(): void;
     dispose(): void;
 }
+/** Every capability Haven can grant, in the order the panel lists them. */
+declare const ALL_CAPABILITIES: readonly MindooDBAppCapability[];
 /**
  * The capabilities Haven grants for the permissions a definition requests. `read` is
  * implied by the mapping, `write` is create plus update.
  */
 declare function capabilitiesForDefinitionPermissions(permissions: readonly string[] | undefined): MindooDBAppCapability[];
-/** Mock databases for every database a `haven-app.json` declares, granted as requested. */
-declare function mockDatabasesFromDefinition(definition: Pick<MindooDBAppDefinition, "databases">, seed?: Record<string, MockMindooDBAppDatabaseDefinition["documents"]>): MockMindooDBAppDatabaseDefinition[];
+/** Changes to one database of a definition, for testing other mappings than requested. */
+interface MockDatabaseOverride {
+    title?: string;
+    /** Grant exactly these instead of what the definition requests. */
+    capabilities?: MindooDBAppCapability[];
+    /** `false`: the user did not map this database to the app. */
+    mapped?: boolean;
+}
+interface MockDatabasesFromDefinitionOptions {
+    /** By logical database id. */
+    overrides?: Record<string, MockDatabaseOverride>;
+    /**
+     * `"memory"` (default): attachments the app writes can be listed and read back.
+     * `"none"`: the mock's stateless default.
+     */
+    attachments?: "memory" | "none";
+}
+/**
+ * Mock databases for every database a `haven-app.json` declares, granted as requested
+ * unless `options.overrides` says otherwise.
+ */
+declare function mockDatabasesFromDefinition(definition: Pick<MindooDBAppDefinition, "databases">, seed?: Record<string, MockMindooDBAppDatabaseDefinition["documents"]>, options?: MockDatabasesFromDefinitionOptions): MockMindooDBAppDatabaseDefinition[];
+/**
+ * Test-host settings from the page URL, so a scenario can be linked or scripted:
+ *
+ * - `db=<id>:<capability>,<capability>` grants exactly these; `db=<id>:none` unmaps it
+ * - `enforce=1` turns the capability checks on
+ * - `users=<count>` fills the directory with generated users
+ * - `locale=<tag>`, `theme=dark|light`
+ */
+interface TestHostUrlSettings {
+    overrides: Record<string, MockDatabaseOverride>;
+    enforceCapabilities?: boolean;
+    directoryUserCount?: number;
+    locale?: string;
+    theme?: "dark" | "light";
+}
+declare function readTestHostUrlSettings(search: string): TestHostUrlSettings;
 declare function createBrowserTestHost(options: CreateBrowserTestHostOptions): BrowserTestHost;
 interface MountHavenTestHostOptions extends Omit<CreateBrowserTestHostOptions, "frame" | "onChange"> {
     /** Element to render into. Defaults to `document.body`, which is cleared. */
     container?: HTMLElement;
     /** Heading of the control panel, e.g. the app label. */
     title?: string;
+    /** Locales offered in the panel's language switcher. */
+    locales?: ReadonlyArray<{
+        tag: string;
+        label: string;
+    }>;
+    /**
+     * Read `db=`, `enforce=`, `users=`, `locale=` and `theme=` from the page URL (see
+     * {@link readTestHostUrlSettings}) and keep the URL in sync with the panel. Default
+     * true. URL settings win over the options passed here.
+     */
+    urlSettings?: boolean;
 }
+/** The locales Haven's UI offers; the default of the panel's language switcher. */
+declare const TEST_HOST_LOCALES: ReadonlyArray<{
+    tag: string;
+    label: string;
+}>;
 declare global {
     interface Window {
         /** Set by {@link mountHavenTestHost} so Playwright can script the host. */
@@ -101,12 +186,36 @@ declare global {
     }
 }
 /**
- * Renders the full test page: the app frame plus a control panel for theme, host focus
- * and the next scan, and a live log of notifications, previews, scans and requests.
+ * JSON for the request log: binary as size plus a hex preview, long strings and arrays
+ * cut, deep objects summarized.
+ */
+declare function previewJson(value: unknown, maxString?: number, maxItems?: number, maxDepth?: number): string;
+/**
+ * Renders the full test page: the app frame plus a control panel — theme, host focus,
+ * language, capabilities per database, directory users, the scanner — and a live log
+ * of notifications, previews, scans and requests (click an entry for details).
  * The returned host is also available as `window.__havenTestHost`.
  */
 declare function mountHavenTestHost(options: MountHavenTestHostOptions): BrowserTestHost;
 
+/**
+ * In-memory attachments for mock databases: what an app writes can be listed and read
+ * back, like in Haven. The default mock attachment API stores nothing; the browser test
+ * host (`mockDatabasesFromDefinition`) uses this store instead.
+ */
+
+declare function createMemoryAttachments(): Partial<MindooDBAppAttachmentApi>;
+
+/**
+ * Capability checks for the mock databases, the way Haven enforces them: a call the
+ * database was not granted is rejected with a `forbidden` error. Opt in with
+ * `enforceCapabilities: true`; without it the mock only lists the capabilities.
+ */
+
+declare class MockForbiddenError extends Error {
+    name: string;
+}
+
 type MaybePromise<T> = T | Promise<T>;
 type MockViewApi = {
     create(input: MindooDBAppCreateViewNavigatorInput): MaybePromise<MindooDBAppViewNavigator>;
@@ -198,7 +307,27 @@ interface CreateMockMindooDBAppSessionOptions {
     proposeApp?: (input: MindooDBAppProposeAppInput) => MindooDBAppProposeAppResult;
     /** Initial contents of `session.storage`. */
     storage?: Record<string, string>;
+    /**
+     * Reject calls a database was not granted, like Haven does (a `forbidden` error;
+     * `documents.canCreate()` and friends answer `allowed: false`). Off by default so
+     * existing tests keep passing; turn it on to test how an app handles missing rights.
+     */
+    enforceCapabilities?: boolean;
+    /**
+     * Usernames `directory.listUsers()` returns on every database (Haven's directory is
+     * tenant-wide), e.g. `generateDirectoryUsers(120)`. A database's own
+     * `methods.directory` still wins.
+     */
+    directoryUsers?: readonly string[];
 }
+/**
+ * Test usernames in Haven's canonical form: `CN=Test User 001/O=Test`, …
+ * Enough of them (e.g. 120) exercise the paging of `directory.listUsers({ … })`.
+ */
+declare function generateDirectoryUsers(count: number, options?: {
+    prefix?: string;
+    organization?: string;
+}): string[];
 interface MockMindooDBAppSessionController {
     bridge: MindooDBAppBridge;
     session: MindooDBAppSession;
@@ -209,6 +338,16 @@ interface MockMindooDBAppSessionController {
     proposedApps: MindooDBAppProposeAppInput[];
     listDatabases(): MindooDBAppDatabaseInfo[];
     setDatabases(definitions: MockMindooDBAppDatabaseDefinition[]): void;
+    /**
+     * Replaces the capabilities of one mapped database. Takes effect on the next call
+     * (with `enforceCapabilities`) and in the launch context; apps that read the
+     * capabilities once at start see the change after a reload.
+     */
+    setCapabilities(databaseId: string, capabilities: MindooDBAppCapability[]): void;
+    /** Turns the capability checks on or off (see `enforceCapabilities`). */
+    setEnforceCapabilities(enforce: boolean): void;
+    /** Replaces the directory's usernames (see `directoryUsers`). */
+    setDirectoryUsers(users: readonly string[]): void;
     emitThemeChange(theme: MindooDBAppHostTheme): void;
     emitViewportChange(viewport: MindooDBAppViewport): void;
     emitUiPreferencesChange(uiPreferences: MindooDBAppUiPreferences): void;
@@ -232,11 +371,23 @@ type FakeBridgePortMessageHandler = (message: Exclude<MindooDBAppBridgePortMessa
     host: FakeBridgeHostController;
     port: MessagePort;
 }) => MaybePromise<boolean | void>;
+/** How the fake host answered one RPC request (see `onResponse`). */
+type FakeBridgeRpcResponse = {
+    ok: true;
+    result: unknown;
+    durationMs: number;
+} | {
+    ok: false;
+    error: MindooDBAppBridgeErrorPayload;
+    durationMs: number;
+};
 interface CreateFakeBridgeHostOptions extends CreateMockMindooDBAppSessionOptions {
     windowMode?: "parent" | "opener";
     requestHandlers?: Record<string, FakeBridgeRequestHandler>;
     /** Called for every RPC request the app sends, before it is answered. */
     onRequest?: (request: MindooDBAppBridgeRpcRequest) => void;
+    /** Called with the answer to every RPC request, right after it was sent. */
+    onResponse?: (request: MindooDBAppBridgeRpcRequest, response: FakeBridgeRpcResponse) => void;
     onPortMessage?: FakeBridgePortMessageHandler;
 }
 interface FakeBridgeHostController {
@@ -272,7 +423,16 @@ interface FakeBridgeHostController {
     postPortMessage(message: MindooDBAppBridgePortMessage, transfer?: Transferable[]): void;
     setRequestHandler(method: string, handler: FakeBridgeRequestHandler): void;
     clearRequestHandler(method: string): void;
+    listDatabases(): MindooDBAppDatabaseInfo[];
+    /** See {@link MockMindooDBAppSessionController.setCapabilities}. */
+    setCapabilities(databaseId: string, capabilities: MindooDBAppCapability[]): void;
+    /** See {@link CreateMockMindooDBAppSessionOptions.enforceCapabilities}. */
+    setEnforceCapabilities(enforce: boolean): void;
+    getEnforceCapabilities(): boolean;
+    /** See {@link CreateMockMindooDBAppSessionOptions.directoryUsers}. */
+    setDirectoryUsers(users: readonly string[]): void;
+    getDirectoryUsers(): string[];
 }
 declare function createFakeBridgeHost(options?: CreateFakeBridgeHostOptions): FakeBridgeHostController;
 
-export { type BrowserTestHost, type BrowserTestHostLog, type BrowserTestHostScan, type CreateBrowserTestHostOptions, type CreateFakeBridgeHostOptions, type CreateMockMindooDBAppSessionOptions, type EvaluatingViewDocument, type FakeBridgeHostController, type FakeBridgePortMessageHandler, type FakeBridgeRequestHandler, type MockMindooDBAppDatabaseDefinition, type MockMindooDBAppSessionController, type MockSealedChannelOptions, type MockSeedDocument, type MountHavenTestHostOptions, capabilitiesForDefinitionPermissions, createBrowserTestHost, createEvaluatingViewNavigator, createFakeBridgeHost, createMockMindooDBAppBridge, createMockMindooDBAppSession, loadMindoodbForTesting, mockDatabasesFromDefinition, mountHavenTestHost };
+export { ALL_CAPABILITIES, type BrowserTestHost, type BrowserTestHostLog, type BrowserTestHostScan, type BrowserTestHostScanMode, type CreateBrowserTestHostOptions, type CreateFakeBridgeHostOptions, type CreateMockMindooDBAppSessionOptions, type EvaluatingViewDocument, type FakeBridgeHostController, type FakeBridgePortMessageHandler, type FakeBridgeRequestHandler, type FakeBridgeRpcResponse, type MockDatabaseOverride, type MockDatabasesFromDefinitionOptions, MockForbiddenError, type MockMindooDBAppDatabaseDefinition, type MockMindooDBAppSessionController, type MockSealedChannelOptions, type MockSeedDocument, type MountHavenTestHostOptions, TEST_HOST_LOCALES, type TestHostUrlSettings, capabilitiesForDefinitionPermissions, createBrowserTestHost, createEvaluatingViewNavigator, createFakeBridgeHost, createMemoryAttachments, createMockMindooDBAppBridge, createMockMindooDBAppSession, generateDirectoryUsers, loadMindoodbForTesting, mockDatabasesFromDefinition, mountHavenTestHost, previewJson, readTestHostUrlSettings };