mindoodb-app-sdk 0.0.63 → 0.0.65

package/TESTING.md

@@ -108,6 +108,24 @@ Each database entry can provide:
 - `methods.attachments`
 - `fulltextSetup` — the initial config returned by `db.getFulltextSetup()`; `db.setFulltextSetup()` overwrites it for the lifetime of the handle. Use this to test your app's full-text bootstrap logic. Note the mock evaluates `text` query clauses regardless of this config.
 - `summarySetup` — the initial config returned by `db.getSummarySetup()`; `db.setSummarySetup()` overwrites it for the lifetime of the handle. The mock's `query()` reads seeded documents directly and ignores this config; use it to test your app's summary bootstrap logic.
+- `automerge: true` — back every document with a real Automerge document, as Haven does (off by default: plain JSON with `mock-head-N` heads). `create`/`update` then return real Automerge heads, `update` applies `set`/`unset`, `json` (with `Automerge.changeAt(json.baseHeads)` when given) and `text` patches as Automerge changes with Haven's rules (missing parents and lists are created, `unset` is idempotent, `counterIncrement` needs a counter, an empty `json` patch is rejected), and `get`/`list`/`query` return the plain projection (atomic strings as strings, counters as numbers, timestamps as ISO strings). `richText` snapshots replace the value at their path and `richTextSteps` are spliced into the text without marks. Seeds are built with a fixed actor, so two mocks from the same seed have identical heads. `mockDatabasesFromDefinition(definition, seed, { automerge: true })` and the test host URL setting `automerge=1` turn it on, too.
+
+#### Concurrent edits from another device
+
+`applyRemoteUpdate(databaseId, docId, input, { actor? })` on the controller (`createMockMindooDBAppSession`, `createFakeBridgeHost`, the browser test host and `window.__havenTestHost`) writes `input` as another device and syncs it in; live queries update as after any write. With `automerge: true` the device holds the history up to `input.json.baseHeads` (plus its own earlier changes) and writes as its own Automerge actor, so its edit truly merges with an app save at the same heads:
+
+```ts
+const doc = await database.documents.get("sheet-1");          // heads H
+await mock.applyRemoteUpdate("main", "sheet-1", {             // device B, at H
+  json: { baseHeads: doc!.heads, listInsert: [{ path: ["rows"], index: 1, values: ["remote"] }] },
+});
+const saved = await database.documents.update("sheet-1", {   // the app, also at H
+  json: { baseHeads: doc!.heads, listInsert: [{ path: ["rows"], index: 1, values: ["local"] }] },
+});
+// saved.data.rows keeps both entries; saved.heads has two heads
+```
+
+The relative order of concurrent inserts at the same index follows Automerge's op ids, as in Haven. Without `automerge`, `applyRemoteUpdate` is a plain update.
 
 ### Evaluating VirtualViews
 
@@ -344,6 +362,7 @@ The page shows the app next to a control panel:
 - **Databases**: one checkbox per capability for every mapped database, plus **Enforce capabilities**. Changing a capability relaunches the app, as Haven does after a permission change. With enforcement on, the mock rejects every call the database was not granted with a `forbidden` error (and `documents.canCreate()` and friends answer `allowed: false`), so you can check the app's hints for missing rights.
 - **Directory**: fills the tenant directory with 0 to 500 generated users (`CN=Test User 001/O=Test`, …) for recipient pickers and paging.
 - **Scanner**: what `attachments.scan()` returns — cancel, a generated sample page, or a file you choose. The file is written to the document's attachments like Haven's scanner does, so the app can read it back.
+- **Agent tools**: the tools the app declared with `session.agent.registerTools()` (with the prefix agents see, `read-only` and `asks first` tags, description and input schema), a form to call one with a JSON input as an agent would, and the result as the agent gets it (images in the result are shown). Tools marked `consequentialHint` go through a confirm, like Haven's consent dialog. A checkbox switches agent access off. **Agent files** imports files for the app (each gets a `fileRef` for `takeFile`) and lists the files the app handed over with `provideFile` for download. **Agent context** shows what the app last passed to `setContext`.
 - A live log of notifications, attachment previews, scans and every RPC request. Click a request for its parameters, its result or error, and how long it took; binary values show as size plus a hex preview.
 
 `mockDatabasesFromDefinition` gives every database an in-memory attachment store (`attachments: "none"` restores the stateless default) and takes overrides for testing other mappings than the definition requests:
@@ -363,7 +382,7 @@ mountHavenTestHost({
 });
 ```
 
-The panel keeps its settings in the page URL, so a scenario can be linked or opened by Playwright directly: `/__haven-test/?db=main:read,attachments&db=archive:none&enforce=1&users=120&locale=de-DE&theme=dark` (`db=<id>:none` unmaps a database; URL settings win over the options). The same controls are scriptable as `window.__havenTestHost`:
+The panel keeps its settings in the page URL, so a scenario can be linked or opened by Playwright directly: `/__haven-test/?db=main:read,attachments&db=archive:none&enforce=1&users=120&locale=de-DE&theme=dark` (`db=<id>:none` unmaps a database; `automerge=1` backs all databases with Automerge documents; URL settings win over the options). The same controls are scriptable as `window.__havenTestHost`:
 
 ```ts
 await page.goto("/__haven-test/?enforce=1");
@@ -375,8 +394,26 @@ await page.evaluate(() => window.__havenTestHost!.setLocale("de-DE"));
 await page.evaluate(() => window.__havenTestHost!.setNextScan({ fileName: "receipt.pdf", mimeType: "application/pdf", size: 1024 }));
 await app.getByRole("button", { name: "Scan" }).click();
 expect(await page.evaluate(() => window.__havenTestHost!.log.scans)).toHaveLength(1);
+
+// with ?automerge=1: another device edits the document the app has open
+await page.evaluate(() => window.__havenTestHost!.applyRemoteUpdate("main", "sheet-1", { set: { title: "Renamed elsewhere" } }));
 ```
 
+Agent tools are scriptable through `window.__havenTestHost.agent`, the same controller the Vitest helpers expose as `createFakeBridgeHost().agent`:
+
+```ts
+const agent = () => window.__havenTestHost!.agent;
+const fileRef = await page.evaluate(() =>
+  agent().importFile({ name: "logo.png", mimeType: "image/png", data: new Uint8Array([137, 80, 78, 71]) }),
+);
+const added = await page.evaluate((ref) => agent().call("image_add", { fileRef: ref }), fileRef);
+expect(added).toMatchObject({ ok: true });
+const exported = await page.evaluate(() => agent().call("deck_export", { format: "pptx" }));
+const file = await page.evaluate((ref) => agent().getFile(ref)?.name, (exported as any).result.files[0].fileRef);
+```
+
+`call()` takes the tool's own name or the prefixed one and never throws: failures come back as `{ ok: false, error: { code, message, requiredAction } }`, the codes an agent sees. The mock follows Haven: tool declarations are validated (name, at most 64 tools, 2000-character descriptions, an object `inputSchema`), the prefix is the definition's `agentToolPrefix` (pass it as the `agentToolPrefix` option) or derived from the app id, an app can only `takeFile()` what was imported for it, and file refs expire after ten minutes. `setConsent("allow" | "deny" | fn)` answers the consent step in scripts, `setEnabled(false)` switches access off, and `calls()` lists every call with its outcome.
+
 `setNextScan()` decides only the next scan (pass `bytes` to attach real content); `setScanMode()` decides the ones after it. `setDirectoryUsers()` and `setEnforceCapabilities()` apply to the next call.
 
 The Level 1 and 2 helpers take the same options: `createMockMindooDBAppSession({ enforceCapabilities: true, directoryUsers: generateDirectoryUsers(120) })`, with `setCapabilities()`, `setEnforceCapabilities()` and `setDirectoryUsers()` on the controller, and `createMemoryAttachments()` for a database's `methods.attachments`. `createFakeBridgeHost({ onResponse })` reports every answer with its duration.

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { ay as MindooDBAppComponentInfo, bq as MindooDBAppEmbedRect, aU as MindooDBAppCreateViewNavigatorInput, de as MindooDBAppViewNavigator, ad as MindooDBAppBridgeRpcRequest, bC as MindooDBAppHostTheme, av as MindooDBAppCapability, j as MindooDBAppDefinition, J as MindooDBAppAttachmentApi, e as MindooDBAppBridge, cQ as MindooDBAppSession, cg as MindooDBAppProposeAppInput, dm as MindooDBAppViewport, d8 as MindooDBAppUiPreferences, cm as MindooDBAppQueryResult, dl as MindooDBAppViewUpdateStats, a9 as MindooDBAppBridgePortMessage, aV as MindooDBAppDatabaseInfo, bl as MindooDBAppEmbedCloseReason, a4 as MindooDBAppBridgeErrorPayload, bX as MindooDBAppLaunchContext, b2 as MindooDBAppDocumentApi, dg as MindooDBAppViewNavigatorOpenOptions, bD as MindooDBAppIdentityApi, d4 as MindooDBAppTimestampApi, b0 as MindooDBAppDirectoryApi, l as MindooDBAppDocument, bz as MindooDBAppFulltextSetup, by as MindooDBAppExtractionSetup, cY as MindooDBAppSummarySetup, ch as MindooDBAppProposeAppResult, bN as MindooDBAppIncomingSource, c as MindooDBAppDragStartResult, bj as MindooDBAppDragProfile, bM as MindooDBAppIncomingResult } from '../types-BeRUxGKN.js';
+import { ay as MindooDBAppComponentInfo, bq as MindooDBAppEmbedRect, I as MindooDBAppAgentToolDescriptor, f as MindooDBAppAgentToolErrorCode, V as MindooDBAppBridgeAgentResultMessage, U as MindooDBAppBridgeAgentInvokeMessage, aU as MindooDBAppCreateViewNavigatorInput, de as MindooDBAppViewNavigator, ad as MindooDBAppBridgeRpcRequest, bC as MindooDBAppHostTheme, av as MindooDBAppCapability, d9 as MindooDBAppUpdateDocumentInput, l as MindooDBAppDocument, j as MindooDBAppDefinition, J as MindooDBAppAttachmentApi, e as MindooDBAppBridge, cQ as MindooDBAppSession, cg as MindooDBAppProposeAppInput, dm as MindooDBAppViewport, d8 as MindooDBAppUiPreferences, cm as MindooDBAppQueryResult, dl as MindooDBAppViewUpdateStats, a9 as MindooDBAppBridgePortMessage, aV as MindooDBAppDatabaseInfo, bl as MindooDBAppEmbedCloseReason, a4 as MindooDBAppBridgeErrorPayload, bX as MindooDBAppLaunchContext, b2 as MindooDBAppDocumentApi, dg as MindooDBAppViewNavigatorOpenOptions, bD as MindooDBAppIdentityApi, d4 as MindooDBAppTimestampApi, b0 as MindooDBAppDirectoryApi, bz as MindooDBAppFulltextSetup, by as MindooDBAppExtractionSetup, cY as MindooDBAppSummarySetup, ch as MindooDBAppProposeAppResult, bN as MindooDBAppIncomingSource, c as MindooDBAppDragStartResult, bj as MindooDBAppDragProfile, bM as MindooDBAppIncomingResult } from '../types-BeRUxGKN.js';
 import * as mindoodb from 'mindoodb';
 import 'mindoodb-view-language';
 
@@ -21,6 +21,118 @@ interface MockEmbeddingFinish {
     message?: string;
 }
 
+/**
+ * Haven's side of agent tools, for tests: what `session.agent` talks to.
+ *
+ * It accepts the app's tool declarations and context with Haven's validation, keeps
+ * the files the app hands over (`provideFile`), lets a test hand the app files the way
+ * Haven imports them from the exchange folder (`takeFile`), and calls the app's tools
+ * over the bridge port like Haven's broker, including the consent step for tools
+ * marked `consequentialHint`.
+ */
+
+/** A file in the mock exchange: handed over by the app, or imported for it by the test. */
+interface MockAgentFile {
+    fileRef: string;
+    name: string;
+    mimeType: string;
+    data: Uint8Array;
+    /** `app`: the app produced it (`provideFile`); `host`: imported for the app (`takeFile`). */
+    source: "app" | "host";
+    createdAt: number;
+    expiresAt: number;
+}
+/** How Haven's consent dialog answers a call to a consequential tool. */
+type MockAgentConsent = "allow" | "deny" | ((call: {
+    tool: string;
+    input: Record<string, unknown>;
+}) => boolean | Promise<boolean>);
+type MockAgentCallResult = {
+    ok: true;
+    result: unknown;
+    durationMs: number;
+} | {
+    ok: false;
+    error: {
+        code: MindooDBAppAgentToolErrorCode | "LOCKED" | string;
+        message: string;
+        requiredAction?: string;
+    };
+    durationMs: number;
+};
+/** One tool call as the log records it. */
+interface MockAgentCall {
+    callId: string;
+    tool: string;
+    input: Record<string, unknown>;
+    startedAt: number;
+    outcome?: MockAgentCallResult;
+}
+interface MockAgentHostOptions {
+    /**
+     * The prefix agents see in front of the app's tool names (`agentToolPrefix` in
+     * `haven-app.json`). Without one it is derived from the app id, as Haven does.
+     */
+    agentToolPrefix?: string;
+    /** Whether the user has agent access on (`registerTools` answers `enabled`). Default true. */
+    agentToolsEnabled?: boolean;
+    /** Answer of the consent dialog for consequential tools. Default `"allow"`. */
+    agentConsent?: MockAgentConsent;
+    /** How long a call waits for the app. Default 120 s, Haven's limit. */
+    agentInvokeTimeoutMs?: number;
+}
+interface MockAgentHostController {
+    /** The app's tools as it declared them (without prefix). */
+    tools(): MindooDBAppAgentToolDescriptor[];
+    /** The names agents see: `<prefix>_<name>`. */
+    exposedNames(): string[];
+    readonly prefix: string;
+    /** What the app last passed to `setContext`. */
+    context(): Record<string, unknown> | null;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    setConsent(consent: MockAgentConsent): void;
+    /**
+     * Calls one of the app's tools as an agent would, by its own name or the prefixed
+     * one. Never throws: failures come back as `{ ok: false, error }` with the code the
+     * agent would see.
+     */
+    call(tool: string, input?: Record<string, unknown>): Promise<MockAgentCallResult>;
+    /** Every call so far, oldest first. */
+    calls(): ReadonlyArray<MockAgentCall>;
+    /** Puts a file in the exchange for the app, as Haven's `haven_files_import`; returns its fileRef. */
+    importFile(file: {
+        name: string;
+        mimeType?: string;
+        data: Uint8Array | ArrayBuffer | Blob | string;
+    }): Promise<string>;
+    /** A file the app handed over (`provideFile`), or `null` when unknown or expired. */
+    getFile(fileRef: string): MockAgentFile | null;
+    /** Files in the exchange (both directions), newest first. */
+    files(): MockAgentFile[];
+}
+/** Haven's derivation when the app declares no prefix (`agentAppKey`). */
+declare function mockAgentToolPrefix(appId: string, declared?: string): string;
+/** Haven's checks on declared tools (`validateAgentToolDescriptors`). */
+declare function validateMockAgentTools(raw: unknown): MindooDBAppAgentToolDescriptor[];
+interface MockAgentHost {
+    controller: MockAgentHostController;
+    /** Answers `agent.*` requests; `undefined` for any other method. */
+    dispatch(method: string, params: unknown): Promise<{
+        result: unknown;
+    } | undefined>;
+    /** The app's `agent-result` message. */
+    handleResult(message: MindooDBAppBridgeAgentResultMessage): void;
+    /** Fails pending calls (the app closed or reloaded). */
+    reset(reason?: string): void;
+}
+declare function createMockAgentHost(options: MockAgentHostOptions & {
+    appId: () => string;
+    /** Posts to the app's port; `false` when no app is connected. */
+    post(message: MindooDBAppBridgeAgentInvokeMessage): boolean;
+    onChange?(): void;
+}): MockAgentHost;
+
 type EvaluatingViewDocument = {
     origin: string;
     docId: string;
@@ -105,6 +217,12 @@ interface CreateBrowserTestHostOptions extends CreateFakeBridgeHostOptions {
 interface BrowserTestHost {
     host: FakeBridgeHostController;
     log: BrowserTestHostLog;
+    /**
+     * Haven's agent-tool side (same as `host.agent`): the app's declared tools and
+     * context, `call(tool, input)` as an agent would, `importFile()` to hand the app a
+     * file for `takeFile`, and `getFile()` for what it handed over with `provideFile`.
+     */
+    agent: MockAgentHostController;
     /**
      * 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}.
@@ -126,6 +244,14 @@ interface BrowserTestHost {
     setEnforceCapabilities(enforce: boolean): void;
     /** Replaces the usernames of the tenant directory (`directory.listUsers()`). */
     setDirectoryUsers(users: readonly string[]): void;
+    /**
+     * Another device edits a document and the change syncs in: the app's live queries
+     * update. With Automerge-backed databases (`automerge=1` / `automerge: true`) the
+     * edit is made at `input.json.baseHeads` by another actor and merged, so it is
+     * concurrent to app saves at the same heads. See
+     * `MockMindooDBAppSessionController.applyRemoteUpdate`.
+     */
+    applyRemoteUpdate(databaseId: string, docId: string, input: MindooDBAppUpdateDocumentInput, options?: MockRemoteUpdateOptions): Promise<MindooDBAppDocument>;
     /** Reloads the app frame. The mock data survives; the app's in-memory state does not. */
     reloadApp(): void;
     dispose(): void;
@@ -153,6 +279,8 @@ interface MockDatabasesFromDefinitionOptions {
      * `"none"`: the mock's stateless default.
      */
     attachments?: "memory" | "none";
+    /** Back documents with real Automerge documents (`MockMindooDBAppDatabaseDefinition.automerge`). */
+    automerge?: boolean;
 }
 /**
  * Mock databases for every database a `haven-app.json` declares, granted as requested
@@ -166,10 +294,13 @@ declare function mockDatabasesFromDefinition(definition: Pick<MindooDBAppDefinit
  * - `enforce=1` turns the capability checks on
  * - `users=<count>` fills the directory with generated users
  * - `locale=<tag>`, `theme=dark|light`
+ * - `automerge=1` backs every database with real Automerge documents (concurrent
+ *   `baseHeads` merges, real heads); `automerge=0` turns it off
  */
 interface TestHostUrlSettings {
     overrides: Record<string, MockDatabaseOverride>;
     enforceCapabilities?: boolean;
+    automerge?: boolean;
     directoryUserCount?: number;
     locale?: string;
     theme?: "dark" | "light";
@@ -187,7 +318,7 @@ interface MountHavenTestHostOptions extends Omit<CreateBrowserTestHostOptions, "
         label: string;
     }>;
     /**
-     * Read `db=`, `enforce=`, `users=`, `locale=` and `theme=` from the page URL (see
+     * Read `db=`, `enforce=`, `users=`, `locale=`, `theme=` and `automerge=` 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.
      */
@@ -295,6 +426,22 @@ interface MockMindooDBAppDatabaseDefinition {
      * results the same way they would in Haven.
      */
     summarySetup?: MindooDBAppSummarySetup | null;
+    /**
+     * Back every document with a real Automerge document, like Haven: `update`
+     * applies `set`/`unset`, `json` (at `json.baseHeads`) and `text` patches as
+     * Automerge changes, heads are real Automerge heads, and `applyRemoteUpdate`
+     * on the controller writes as another device so concurrent edits truly
+     * merge. Off by default (plain JSON with `mock-head-N` heads).
+     */
+    automerge?: boolean;
+}
+/** Options of `applyRemoteUpdate`. */
+interface MockRemoteUpdateOptions {
+    /**
+     * Automerge actor id (hex) of the simulated device. Defaults to one fixed
+     * "remote" actor; pass different ids to simulate several devices.
+     */
+    actor?: string;
 }
 /**
  * Stands in for the host-owned sealed channel.
@@ -379,6 +526,15 @@ interface MockMindooDBAppSessionController {
     setEnforceCapabilities(enforce: boolean): void;
     /** Replaces the directory's usernames (see `directoryUsers`). */
     setDirectoryUsers(users: readonly string[]): void;
+    /**
+     * Writes `input` to a document as another device would, then syncs it in:
+     * live queries update like after any write. With `automerge: true` on the
+     * database the edit is made by a different Automerge actor on the history
+     * up to `input.json.baseHeads` (the current state when omitted) and merged,
+     * so it is truly concurrent to app writes at the same heads. Without it, it
+     * is a plain update. Bypasses capability checks (it is not the app writing).
+     */
+    applyRemoteUpdate(databaseId: string, docId: string, input: MindooDBAppUpdateDocumentInput, options?: MockRemoteUpdateOptions): Promise<MindooDBAppDocument>;
     emitThemeChange(theme: MindooDBAppHostTheme): void;
     emitViewportChange(viewport: MindooDBAppViewport): void;
     emitUiPreferencesChange(uiPreferences: MindooDBAppUiPreferences): void;
@@ -451,8 +607,10 @@ type FakeBridgeRpcResponse = {
     error: MindooDBAppBridgeErrorPayload;
     durationMs: number;
 };
-interface CreateFakeBridgeHostOptions extends CreateMockMindooDBAppSessionOptions {
+interface CreateFakeBridgeHostOptions extends CreateMockMindooDBAppSessionOptions, MockAgentHostOptions {
     windowMode?: "parent" | "opener";
+    /** Called when the app's agent tools, context or exchange files change, and after each tool call. */
+    onAgentChange?: () => void;
     requestHandlers?: Record<string, FakeBridgeRequestHandler>;
     /** Called for every RPC request the app sends, before it is answered. */
     onRequest?: (request: MindooDBAppBridgeRpcRequest) => void;
@@ -502,6 +660,8 @@ interface FakeBridgeHostController {
     /** See {@link CreateMockMindooDBAppSessionOptions.directoryUsers}. */
     setDirectoryUsers(users: readonly string[]): void;
     getDirectoryUsers(): string[];
+    /** See {@link MockMindooDBAppSessionController.applyRemoteUpdate}. */
+    applyRemoteUpdate(databaseId: string, docId: string, input: MindooDBAppUpdateDocumentInput, options?: MockRemoteUpdateOptions): Promise<MindooDBAppDocument>;
     /** Embeds the app has open (`session.embeds.open`). */
     listEmbeds(): MockEmbedState[];
     /** Closes an embed and pushes the `embed-event` to the app. */
@@ -519,7 +679,12 @@ interface FakeBridgeHostController {
      * over the port and resolves or rejects with the app's answer.
      */
     requestEmbeddingSave(): Promise<void>;
+    /**
+     * Haven's agent-tool side: the tools and context the app declared, files in the
+     * exchange, and `call()` to run a tool as an agent would.
+     */
+    readonly agent: MockAgentHostController;
 }
 declare function createFakeBridgeHost(options?: CreateFakeBridgeHostOptions): FakeBridgeHostController;
 
-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, type MockEmbedState, type MockEmbeddingFinish, MockForbiddenError, type MockIncomingContentInput, 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 };
+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 MockAgentCall, type MockAgentCallResult, type MockAgentConsent, type MockAgentFile, type MockAgentHost, type MockAgentHostController, type MockAgentHostOptions, type MockDatabaseOverride, type MockDatabasesFromDefinitionOptions, type MockEmbedState, type MockEmbeddingFinish, MockForbiddenError, type MockIncomingContentInput, type MockMindooDBAppDatabaseDefinition, type MockMindooDBAppSessionController, type MockRemoteUpdateOptions, type MockSealedChannelOptions, type MockSeedDocument, type MountHavenTestHostOptions, TEST_HOST_LOCALES, type TestHostUrlSettings, capabilitiesForDefinitionPermissions, createBrowserTestHost, createEvaluatingViewNavigator, createFakeBridgeHost, createMemoryAttachments, createMockAgentHost, createMockMindooDBAppBridge, createMockMindooDBAppSession, generateDirectoryUsers, loadMindoodbForTesting, mockAgentToolPrefix, mockDatabasesFromDefinition, mountHavenTestHost, previewJson, readTestHostUrlSettings, validateMockAgentTools };