mindoodb-app-sdk 0.0.34 → 0.0.36

package/README.md

@@ -990,9 +990,33 @@ const setup = await db.getFulltextSetup(); // null when never configured
 ```
 
 - Without `include`, every non-underscore top-level field with extractable text is indexed (auto mode). Pass `include: ["subject", "body"]` to pin the indexed fields, including nested/long-text fields outside the summary buffer.
-- `attachments: true` indexes attachment text under the synthetic `_attachments` field using the host's extractors (Haven ships PDF, Office, and plain-text extractors). Restrict a query to attachment content with `text: { query, fields: ["_attachments"] }`.
+- `attachments: true` indexes attachment text under the synthetic `_attachments` field using the host's extractors (Haven ships anydoc for Office/PDF/… plus plain-text extractors). Restrict a query to attachment content with `text: { query, fields: ["_attachments"] }`.
 - Changing the configuration (including `language`) rebuilds the index in the background; queries during the rebuild report `coverage: "rebuilding"`.
 
+**Extracting text from bytes you already have** (requires `attachments`):
+
+```ts
+const stream = await db.attachments.openReadStream(docId, fileName);
+const chunks: Uint8Array[] = [];
+for (;;) {
+  const chunk = await stream.read();
+  if (chunk === null) break;
+  chunks.push(chunk);
+}
+await stream.close();
+const bytes = concatUint8Arrays(chunks); // your helper
+
+const { text, handled, format, engine } = await db.attachments.extractText({
+  bytes,
+  mimeType: "application/pdf",
+  fileName,
+  format: "markdown", // default — or "plainText"
+});
+if (handled) {
+  console.log(engine, format, text.slice(0, 200));
+}
+```
+
 **Live queries** keep a query result up to date. The callback receives the initial result and runs again whenever the result actually changed — the host coalesces bursts of writes and fingerprints results, so you only hear about real changes:
 
 ```ts
@@ -1387,7 +1411,7 @@ You do **not** need a full Haven environment to test apps that use `mindoodb-app
 
 The SDK ships a dedicated `mindoodb-app-sdk/testing` entrypoint with two levels of test helpers:
 
-- **Level 1 -- app tests:** Returns a fake `MindooDBAppSession` and bridge for unit, composable, store, and component tests. No `postMessage` or `MessageChannel` involved.
+- **Level 1 -- app tests:** Returns a fake `MindooDBAppSession` and bridge for unit, composable, store, and component tests. No `postMessage` or `MessageChannel` involved. With the optional `mindoodb` peer, `createViewNavigator` evaluates view definitions against seeded documents (same VirtualView engine as Haven).
 - **Level 2 -- bridge protocol tests:** A fake host harness that exercises the real `createMindooDBAppBridge()` handshake over `postMessage` and `MessageChannel`. Useful for integration-style tests.
 
 Use Level 1 when you are testing app behavior. Use Level 2 when you want to validate the bridge transport itself.

package/TESTING.md

@@ -15,10 +15,13 @@ import {
 The testing entrypoint emulates document storage with real Automerge documents,
 so `@automerge/automerge` is declared as an optional peer dependency. Add it to
 your app's `devDependencies` when you import `mindoodb-app-sdk/testing`
-(the runtime SDK entrypoint does not need it):
+(the runtime SDK entrypoint does not need it).
+
+Evaluating VirtualViews also need the optional `mindoodb` peer (same core engine
+Haven uses):
 
 ```bash
-pnpm add -D @automerge/automerge
+pnpm add -D @automerge/automerge mindoodb
 ```
 
 ## Pick a level
@@ -99,11 +102,64 @@ When you pass `databases`, the mock session also exposes them through `session.g
 Each database entry can provide:
 
 - `info`
+- `documents` — seed documents into the mock store (used by `list`/`query` and by evaluating VirtualViews)
 - `methods.documents`
-- `methods.views` for session-level `createView()` and `openView()` calls
+- `methods.views` for session-level `createView()` and `openView()` calls (overrides the default evaluating navigator)
 - `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.
 
+### Evaluating VirtualViews
+
+With the optional `mindoodb` peer installed (`pnpm add -D mindoodb`),
+`session.createViewNavigator({ definition, databaseIds })` evaluates the view
+definition against seeded (and later created) documents using the same
+VirtualView engine Haven uses. That means class-scoped filters,
+`childDocumentsBetween`, and multi-database origins work in Vitest without a
+full Haven host:
+
+```ts
+import { createViewLanguage } from "mindoodb-view-language";
+import { createMockMindooDBAppSession } from "mindoodb-app-sdk/testing";
+
+const v = createViewLanguage();
+const mock = createMockMindooDBAppSession({
+  databases: [{
+    info: { id: "teacher_core", title: "Core", capabilities: ["read", "views"] },
+    documents: [
+      { id: "obs_a", data: { type: "observation", classGroupId: "cls_a" } },
+      { id: "obs_b", data: { type: "observation", classGroupId: "cls_b" } },
+    ],
+  }],
+});
+
+const navigator = await mock.session.createViewNavigator({
+  databaseIds: ["teacher_core"],
+  definition: {
+    id: "class-detail-v1",
+    title: "Class",
+    filter: {
+      mode: "expression",
+      expression: v.and(
+        v.eq(v.field("type"), "observation"),
+        v.eq(v.field("classGroupId"), "cls_a"),
+      ),
+    },
+    columns: [
+      { name: "type", role: "category", expression: v.field("type") },
+      { name: "sourceType", role: "display", expression: v.field("type") },
+    ],
+  },
+  options: { includeCategories: false, includeDocuments: true },
+});
+
+await navigator.expandAll();
+const page = await navigator.entriesForward({ limit: 100 });
+// page.entries → only obs_a
+```
+
+Without `mindoodb`, the testing entrypoint falls back to an empty navigator and
+logs a warning — install the peer for realistic view tests.
+
 The default in-memory document store also implements `documents.query()` and `documents.liveQuery()`: expression and formula-string filters are evaluated against the seeded documents, `sortBy`/`limit`/`offset` work as documented, and live query callbacks fire automatically after `create`/`update`/`delete`/`undelete` mutations. Full-text `text` clauses are supported with a deterministic mock implementation (token matching with prefix/AND semantics and an occurrence-count `textScore`) — assert on membership and relative ordering, not absolute scores, since real hosts use a BM25-style engine. That means app code built on queries and live queries is testable at Level 1 without any extra setup:
 
 ```ts

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { M as MindooDBAppAttachmentPreviewMode, a as MindooDBAppBridge, b as MindooDBAppDatabase, c as MindooDBAppDocument, d as MindooDBAppRichTextSpan, e as MindooDBAppRichTextSnapshot } from './types-Bl6CrBn1.js';
-export { f as MINDOODB_APP_SEAL_SIGNING_DOMAIN, g as MindooDBAppAccessDecision, h as MindooDBAppAccessTier, i as MindooDBAppAttachmentApi, j as MindooDBAppAttachmentChunk, k as MindooDBAppAttachmentInfo, l as MindooDBAppAttachmentPreviewOptions, m as MindooDBAppAttachmentPreviewSession, n as MindooDBAppAutomergeChangesPatch, o as MindooDBAppAutomergeChangesSince, p as MindooDBAppAutomergeGetOptions, q as MindooDBAppAutomergePatchResult, r as MindooDBAppAutomergeSnapshot, s as MindooDBAppBridgeConnectMessage, t as MindooDBAppBridgeConnectOptions, u as MindooDBAppBridgeConnectedMessage, v as MindooDBAppBridgeErrorPayload, w as MindooDBAppBridgeHandshakeErrorMessage, x as MindooDBAppBridgeLocaleChangedMessage, y as MindooDBAppBridgePortMessage, z as MindooDBAppBridgeQueryResultMessage, A as MindooDBAppBridgeRpcError, B as MindooDBAppBridgeRpcMessage, C as MindooDBAppBridgeRpcRequest, D as MindooDBAppBridgeRpcSuccess, E as MindooDBAppBridgeStreamAbortRequest, F as MindooDBAppBridgeStreamAck, G as MindooDBAppBridgeStreamCloseRequest, H as MindooDBAppBridgeStreamError, I as MindooDBAppBridgeStreamMessage, J as MindooDBAppBridgeStreamOpenResult, K as MindooDBAppBridgeStreamReadRequest, L as MindooDBAppBridgeStreamWriteRequest, N as MindooDBAppBridgeThemeChangedMessage, O as MindooDBAppBridgeUiPreferencesChangedMessage, P as MindooDBAppBridgeViewChangedMessage, Q as MindooDBAppBridgeViewportChangedMessage, R as MindooDBAppCapability, S as MindooDBAppConfiguredViewCategorizationStyle, T as MindooDBAppConfiguredViewColumn, U as MindooDBAppConfiguredViewColumnRole, V as MindooDBAppConfiguredViewExpressionMode, W as MindooDBAppConfiguredViewFieldExpression, X as MindooDBAppConfiguredViewFilterDefinition, Y as MindooDBAppConfiguredViewFilterMode, Z as MindooDBAppConfiguredViewFilterRule, _ as MindooDBAppConfiguredViewFormulaExpression, $ as MindooDBAppConfiguredViewFormulaFilterDefinition, a0 as MindooDBAppConfiguredViewPreviewMode, a1 as MindooDBAppConfiguredViewRuleFilterDefinition, a2 as MindooDBAppConfiguredViewRuleMatchMode, a3 as MindooDBAppConfiguredViewRuleOperator, a4 as MindooDBAppConfiguredViewValueExpression, a5 as MindooDBAppCreateDocumentInput, a6 as MindooDBAppCreateViewInput, a7 as MindooDBAppCreateViewNavigatorInput, a8 as MindooDBAppDatabaseInfo, a9 as MindooDBAppDirectoryApi, aa as MindooDBAppDirectoryEntry, ab as MindooDBAppDocumentApi, ac as MindooDBAppDocumentHeadCursorResult, ad as MindooDBAppDocumentHistoryEntry, ae as MindooDBAppDocumentListQuery, af as MindooDBAppDocumentListResult, ag as MindooDBAppDocumentQuery, ah as MindooDBAppDocumentRevisionId, ai as MindooDBAppDocumentScanPreset, aj as MindooDBAppDocumentSummary, ak as MindooDBAppEntryAttachmentRef, al as MindooDBAppEntryProvenance, am as MindooDBAppExtractionSetup, an as MindooDBAppFulltextSetup, ao as MindooDBAppHistoricalDocument, ap as MindooDBAppHistoryQuery, aq as MindooDBAppHostTheme, ar as MindooDBAppIdentityApi, as as MindooDBAppJsonListDeletePatch, at as MindooDBAppJsonListInsertPatch, au as MindooDBAppJsonPatch, av as MindooDBAppJsonSetPatch, aw as MindooDBAppJsonTextMarkPatch, ax as MindooDBAppJsonTextSplicePatch, ay as MindooDBAppJsonTextUnmarkPatch, az as MindooDBAppJsonUnsetPatch, aA as MindooDBAppLaunchContext, aB as MindooDBAppLiveQuerySubscription, aC as MindooDBAppMenuAnchor, aD as MindooDBAppMenuApi, aE as MindooDBAppMenuCommandItem, aF as MindooDBAppMenuDismissReason, aG as MindooDBAppMenuDismissedResult, aH as MindooDBAppMenuItem, aI as MindooDBAppMenuKind, aJ as MindooDBAppMenuPlacement, aK as MindooDBAppMenuPointAnchor, aL as MindooDBAppMenuRect, aM as MindooDBAppMenuRectAnchor, aN as MindooDBAppMenuSelectionResult, aO as MindooDBAppMenuSeparatorItem, aP as MindooDBAppQueryCoverage, aQ as MindooDBAppQueryResult, aR as MindooDBAppQueryRow, aS as MindooDBAppQuerySortKey, aT as MindooDBAppQueryTextClause, aU as MindooDBAppReadableAttachmentStream, aV as MindooDBAppResolvedViewDefinition, aW as MindooDBAppResolvedViewSource, aX as MindooDBAppRevisionPhase, aY as MindooDBAppRevisionVerification, aZ as MindooDBAppRichTextBlockSpan, a_ as MindooDBAppRichTextGetOptions, a$ as MindooDBAppRichTextImmutableString, b0 as MindooDBAppRichTextMarkRange, b1 as MindooDBAppRichTextMaterializeValue, b2 as MindooDBAppRichTextPatch, b3 as MindooDBAppRichTextScalar, b4 as MindooDBAppRichTextSpliceStep, b5 as MindooDBAppRichTextStep, b6 as MindooDBAppRichTextStepPatch, b7 as MindooDBAppRichTextTextSpan, b8 as MindooDBAppRuntime, b9 as MindooDBAppScanAttachmentOptions, ba as MindooDBAppScanAttachmentResult, bb as MindooDBAppScopedDocId, bc as MindooDBAppScopedDocumentSummary, bd as MindooDBAppSealIntent, be as MindooDBAppSession, bf as MindooDBAppShowMenuInput, bg as MindooDBAppShowMenuResult, bh as MindooDBAppSignPreview, bi as MindooDBAppSignPreviewScope, bj as MindooDBAppSignStatementInput, bk as MindooDBAppSignStatementResult, bl as MindooDBAppTextEdit, bm as MindooDBAppTextPatch, bn as MindooDBAppThemeMode, bo as MindooDBAppTimestampApi, bp as MindooDBAppTimestampInput, bq as MindooDBAppTimestampProvider, br as MindooDBAppTimestampResult, bs as MindooDBAppUiPreferences, bt as MindooDBAppUpdateDocumentInput, bu as MindooDBAppViewCursorDocumentListResult, bv as MindooDBAppViewCursorResult, bw as MindooDBAppViewEntry, bx as MindooDBAppViewEntryKind, by as MindooDBAppViewNavigator, bz as MindooDBAppViewNavigatorExpansionState, bA as MindooDBAppViewNavigatorOpenOptions, bB as MindooDBAppViewNavigatorPageOptions, bC as MindooDBAppViewNavigatorPageResult, bD as MindooDBAppViewNavigatorRangeQuery, bE as MindooDBAppViewNavigatorSelectionState, bF as MindooDBAppViewUpdateStats, bG as MindooDBAppViewport, bH as MindooDBAppWritableAttachmentStream } from './types-Bl6CrBn1.js';
+import { M as MindooDBAppAttachmentPreviewMode, a as MindooDBAppBridge, b as MindooDBAppDatabase, c as MindooDBAppDocument, d as MindooDBAppRichTextSpan, e as MindooDBAppRichTextSnapshot } from './types-qW1XwmiZ.js';
+export { f as MINDOODB_APP_SEAL_SIGNING_DOMAIN, g as MindooDBAppAccessDecision, h as MindooDBAppAccessTier, i as MindooDBAppAttachmentApi, j as MindooDBAppAttachmentChunk, k as MindooDBAppAttachmentInfo, l as MindooDBAppAttachmentPreviewOptions, m as MindooDBAppAttachmentPreviewSession, n as MindooDBAppAutomergeChangesPatch, o as MindooDBAppAutomergeChangesSince, p as MindooDBAppAutomergeGetOptions, q as MindooDBAppAutomergePatchResult, r as MindooDBAppAutomergeSnapshot, s as MindooDBAppBridgeConnectMessage, t as MindooDBAppBridgeConnectOptions, u as MindooDBAppBridgeConnectedMessage, v as MindooDBAppBridgeErrorPayload, w as MindooDBAppBridgeHandshakeErrorMessage, x as MindooDBAppBridgeLocaleChangedMessage, y as MindooDBAppBridgePortMessage, z as MindooDBAppBridgeQueryResultMessage, A as MindooDBAppBridgeRpcError, B as MindooDBAppBridgeRpcMessage, C as MindooDBAppBridgeRpcRequest, D as MindooDBAppBridgeRpcSuccess, E as MindooDBAppBridgeStreamAbortRequest, F as MindooDBAppBridgeStreamAck, G as MindooDBAppBridgeStreamCloseRequest, H as MindooDBAppBridgeStreamError, I as MindooDBAppBridgeStreamMessage, J as MindooDBAppBridgeStreamOpenResult, K as MindooDBAppBridgeStreamReadRequest, L as MindooDBAppBridgeStreamWriteRequest, N as MindooDBAppBridgeThemeChangedMessage, O as MindooDBAppBridgeUiPreferencesChangedMessage, P as MindooDBAppBridgeViewChangedMessage, Q as MindooDBAppBridgeViewportChangedMessage, R as MindooDBAppCapability, S as MindooDBAppConfiguredViewCategorizationStyle, T as MindooDBAppConfiguredViewColumn, U as MindooDBAppConfiguredViewColumnRole, V as MindooDBAppConfiguredViewExpressionMode, W as MindooDBAppConfiguredViewFieldExpression, X as MindooDBAppConfiguredViewFilterDefinition, Y as MindooDBAppConfiguredViewFilterMode, Z as MindooDBAppConfiguredViewFilterRule, _ as MindooDBAppConfiguredViewFormulaExpression, $ as MindooDBAppConfiguredViewFormulaFilterDefinition, a0 as MindooDBAppConfiguredViewPreviewMode, a1 as MindooDBAppConfiguredViewRuleFilterDefinition, a2 as MindooDBAppConfiguredViewRuleMatchMode, a3 as MindooDBAppConfiguredViewRuleOperator, a4 as MindooDBAppConfiguredViewValueExpression, a5 as MindooDBAppCreateDocumentInput, a6 as MindooDBAppCreateViewInput, a7 as MindooDBAppCreateViewNavigatorInput, a8 as MindooDBAppDatabaseInfo, a9 as MindooDBAppDirectoryApi, aa as MindooDBAppDirectoryEntry, ab as MindooDBAppDocumentApi, ac as MindooDBAppDocumentHeadCursorResult, ad as MindooDBAppDocumentHistoryEntry, ae as MindooDBAppDocumentListQuery, af as MindooDBAppDocumentListResult, ag as MindooDBAppDocumentQuery, ah as MindooDBAppDocumentRevisionId, ai as MindooDBAppDocumentScanPreset, aj as MindooDBAppDocumentSummary, ak as MindooDBAppEntryAttachmentRef, al as MindooDBAppEntryProvenance, am as MindooDBAppExtractDocumentTextInput, an as MindooDBAppExtractDocumentTextResult, ao as MindooDBAppExtractTextFormat, ap as MindooDBAppExtractionSetup, aq as MindooDBAppFulltextSetup, ar as MindooDBAppHistoricalDocument, as as MindooDBAppHistoryQuery, at as MindooDBAppHostTheme, au as MindooDBAppIdentityApi, av as MindooDBAppJsonListDeletePatch, aw as MindooDBAppJsonListInsertPatch, ax as MindooDBAppJsonPatch, ay as MindooDBAppJsonSetPatch, az as MindooDBAppJsonTextMarkPatch, aA as MindooDBAppJsonTextSplicePatch, aB as MindooDBAppJsonTextUnmarkPatch, aC as MindooDBAppJsonUnsetPatch, aD as MindooDBAppLaunchContext, aE as MindooDBAppLiveQuerySubscription, aF as MindooDBAppMenuAnchor, aG as MindooDBAppMenuApi, aH as MindooDBAppMenuCommandItem, aI as MindooDBAppMenuDismissReason, aJ as MindooDBAppMenuDismissedResult, aK as MindooDBAppMenuItem, aL as MindooDBAppMenuKind, aM as MindooDBAppMenuPlacement, aN as MindooDBAppMenuPointAnchor, aO as MindooDBAppMenuRect, aP as MindooDBAppMenuRectAnchor, aQ as MindooDBAppMenuSelectionResult, aR as MindooDBAppMenuSeparatorItem, aS as MindooDBAppQueryCoverage, aT as MindooDBAppQueryResult, aU as MindooDBAppQueryRow, aV as MindooDBAppQuerySortKey, aW as MindooDBAppQueryTextClause, aX as MindooDBAppReadableAttachmentStream, aY as MindooDBAppResolvedViewDefinition, aZ as MindooDBAppResolvedViewSource, a_ as MindooDBAppRevisionPhase, a$ as MindooDBAppRevisionVerification, b0 as MindooDBAppRichTextBlockSpan, b1 as MindooDBAppRichTextGetOptions, b2 as MindooDBAppRichTextImmutableString, b3 as MindooDBAppRichTextMarkRange, b4 as MindooDBAppRichTextMaterializeValue, b5 as MindooDBAppRichTextPatch, b6 as MindooDBAppRichTextScalar, b7 as MindooDBAppRichTextSpliceStep, b8 as MindooDBAppRichTextStep, b9 as MindooDBAppRichTextStepPatch, ba as MindooDBAppRichTextTextSpan, bb as MindooDBAppRuntime, bc as MindooDBAppScanAttachmentOptions, bd as MindooDBAppScanAttachmentResult, be as MindooDBAppScopedDocId, bf as MindooDBAppScopedDocumentSummary, bg as MindooDBAppSealIntent, bh as MindooDBAppSession, bi as MindooDBAppShowMenuInput, bj as MindooDBAppShowMenuResult, bk as MindooDBAppSignPreview, bl as MindooDBAppSignPreviewScope, bm as MindooDBAppSignStatementInput, bn as MindooDBAppSignStatementResult, bo as MindooDBAppTextEdit, bp as MindooDBAppTextPatch, bq as MindooDBAppThemeMode, br as MindooDBAppTimestampApi, bs as MindooDBAppTimestampInput, bt as MindooDBAppTimestampProvider, bu as MindooDBAppTimestampResult, bv as MindooDBAppUiPreferences, bw as MindooDBAppUpdateDocumentInput, bx as MindooDBAppViewCursorDocumentListResult, by as MindooDBAppViewCursorResult, bz as MindooDBAppViewEntry, bA as MindooDBAppViewEntryKind, bB as MindooDBAppViewNavigator, bC as MindooDBAppViewNavigatorExpansionState, bD as MindooDBAppViewNavigatorOpenOptions, bE as MindooDBAppViewNavigatorPageOptions, bF as MindooDBAppViewNavigatorPageResult, bG as MindooDBAppViewNavigatorRangeQuery, bH as MindooDBAppViewNavigatorSelectionState, bI as MindooDBAppViewUpdateStats, bJ as MindooDBAppViewport, bK as MindooDBAppWritableAttachmentStream } from './types-qW1XwmiZ.js';
 import { MindooDBAppBooleanExpression } from 'mindoodb-view-language';
 export { MindooDBAppBooleanExpression, MindooDBAppExpression, MindooDBAppFilterDefinition, MindooDBAppViewCategoryChildrenPageRequest, MindooDBAppViewColumn, MindooDBAppViewColumnRole, MindooDBAppViewDefinition, MindooDBAppViewExpansionState, MindooDBAppViewExpressionBase, MindooDBAppViewExpressionDatePart, MindooDBAppViewExpressionOperation, MindooDBAppViewFieldExpression, MindooDBAppViewIfExpression, MindooDBAppViewLetExpression, MindooDBAppViewLiteralExpression, MindooDBAppViewLookupByPath, MindooDBAppViewOperationExpression, MindooDBAppViewOriginExpression, MindooDBAppViewPageRequest, MindooDBAppViewPageResult, MindooDBAppViewRow, MindooDBAppViewSortDirection, MindooDBAppViewTotalMode, MindooDBAppViewValueExpressionRef, MindooDBAppViewVariableExpression, createViewLanguage } from 'mindoodb-view-language';
 import { MindooDB, MindooQuerySortKey, MindooQueryOptions, MindooQueryResult } from 'mindoodb';

package/dist/index.js

@@ -1060,6 +1060,16 @@ var MindooDBAppDatabaseImpl = class {
           timestamp: options?.timestamp,
           revisionId: options?.revisionId
         });
+      },
+      extractText: async (input) => {
+        return await this.rpc.call("attachments.extractText", {
+          databaseId: this.databaseId,
+          bytes: input.bytes,
+          mimeType: input.mimeType,
+          fileName: input.fileName,
+          format: input.format,
+          languages: input.languages
+        });
       }
     };
   }

package/dist/testing/index.d.ts

@@ -1,6 +1,26 @@
-import { aA as MindooDBAppLaunchContext, a8 as MindooDBAppDatabaseInfo, ab as MindooDBAppDocumentApi, a7 as MindooDBAppCreateViewNavigatorInput, by as MindooDBAppViewNavigator, bA as MindooDBAppViewNavigatorOpenOptions, i as MindooDBAppAttachmentApi, ar as MindooDBAppIdentityApi, bo as MindooDBAppTimestampApi, a9 as MindooDBAppDirectoryApi, an as MindooDBAppFulltextSetup, am as MindooDBAppExtractionSetup, a as MindooDBAppBridge, be as MindooDBAppSession, C as MindooDBAppBridgeRpcRequest, aq as MindooDBAppHostTheme, bG as MindooDBAppViewport, bs as MindooDBAppUiPreferences, aQ as MindooDBAppQueryResult, bF as MindooDBAppViewUpdateStats, y as MindooDBAppBridgePortMessage } from '../types-Bl6CrBn1.js';
+import { a7 as MindooDBAppCreateViewNavigatorInput, bB as MindooDBAppViewNavigator, aD as MindooDBAppLaunchContext, a8 as MindooDBAppDatabaseInfo, ab as MindooDBAppDocumentApi, bD as MindooDBAppViewNavigatorOpenOptions, i as MindooDBAppAttachmentApi, au as MindooDBAppIdentityApi, br as MindooDBAppTimestampApi, a9 as MindooDBAppDirectoryApi, c as MindooDBAppDocument, aq as MindooDBAppFulltextSetup, ap as MindooDBAppExtractionSetup, a as MindooDBAppBridge, bh as MindooDBAppSession, C as MindooDBAppBridgeRpcRequest, at as MindooDBAppHostTheme, bJ as MindooDBAppViewport, bv as MindooDBAppUiPreferences, aT as MindooDBAppQueryResult, bI as MindooDBAppViewUpdateStats, y as MindooDBAppBridgePortMessage } from '../types-qW1XwmiZ.js';
+import * as mindoodb from 'mindoodb';
 import 'mindoodb-view-language';
 
+type EvaluatingViewDocument = {
+    origin: string;
+    docId: string;
+    data: Record<string, unknown>;
+    createdAt?: string | null;
+    lastModifiedAt?: string | null;
+    witnessed?: boolean;
+    awaitingWitness?: boolean;
+};
+type MindoodbVirtualViews = typeof mindoodb;
+declare function loadMindoodbForTesting(): Promise<MindoodbVirtualViews | null>;
+/**
+ * Build an async SDK navigator that evaluates `input.definition` against the
+ * provided materialised documents (same engine Haven uses for bridge views).
+ *
+ * Returns `null` when the optional `mindoodb` peer is not installed.
+ */
+declare function createEvaluatingViewNavigator(input: MindooDBAppCreateViewNavigatorInput, documents: EvaluatingViewDocument[]): Promise<MindooDBAppViewNavigator | null>;
+
 type MaybePromise<T> = T | Promise<T>;
 type MockViewApi = {
     create(input: MindooDBAppCreateViewNavigatorInput): MaybePromise<MindooDBAppViewNavigator>;
@@ -14,9 +34,23 @@ type MockDatabaseMethods = {
     timestamps?: Partial<MindooDBAppTimestampApi>;
     directory?: Partial<MindooDBAppDirectoryApi>;
 };
+interface MockSeedDocument {
+    id: string;
+    data: Record<string, unknown>;
+    updatedAt?: string;
+    isDeleted?: boolean;
+    heads?: string[];
+    attachments?: MindooDBAppDocument["attachments"];
+}
 interface MockMindooDBAppDatabaseDefinition {
     info: MindooDBAppDatabaseInfo;
     methods?: MockDatabaseMethods;
+    /**
+     * Documents pre-loaded into the mock database store. Used by
+     * `documents.list` / `query` and by the evaluating VirtualView navigator
+     * (`session.createViewNavigator`).
+     */
+    documents?: MockSeedDocument[];
     /**
      * Initial full-text configuration returned by `getFulltextSetup()`.
      * `setFulltextSetup()` overwrites it for the lifetime of the handle.
@@ -51,6 +85,7 @@ interface MockMindooDBAppSessionController {
     emitUiPreferencesChange(uiPreferences: MindooDBAppUiPreferences): void;
     emitLocaleChange(locale: string): void;
 }
+
 declare function createMockMindooDBAppSession(options?: CreateMockMindooDBAppSessionOptions): MockMindooDBAppSessionController;
 declare function createMockMindooDBAppBridge(options?: CreateMockMindooDBAppSessionOptions): MockMindooDBAppSessionController;
 type FakeBridgeRequestHandler = (params: unknown, context: {
@@ -88,4 +123,4 @@ interface FakeBridgeHostController {
 }
 declare function createFakeBridgeHost(options?: CreateFakeBridgeHostOptions): FakeBridgeHostController;
 
-export { type CreateFakeBridgeHostOptions, type CreateMockMindooDBAppSessionOptions, type FakeBridgeHostController, type FakeBridgePortMessageHandler, type FakeBridgeRequestHandler, type MockMindooDBAppDatabaseDefinition, type MockMindooDBAppSessionController, createFakeBridgeHost, createMockMindooDBAppBridge, createMockMindooDBAppSession };
+export { type CreateFakeBridgeHostOptions, type CreateMockMindooDBAppSessionOptions, type EvaluatingViewDocument, type FakeBridgeHostController, type FakeBridgePortMessageHandler, type FakeBridgeRequestHandler, type MockMindooDBAppDatabaseDefinition, type MockMindooDBAppSessionController, type MockSeedDocument, createEvaluatingViewNavigator, createFakeBridgeHost, createMockMindooDBAppBridge, createMockMindooDBAppSession, loadMindoodbForTesting };

package/dist/testing/index.js

@@ -1,9 +1,470 @@
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
 import {
-  evaluateExpression,
+  evaluateExpression as evaluateExpression2,
   parseMindooDBFormulaBooleanExpression
 } from "mindoodb-view-language";
+
+// src/testing/evaluatingViewNavigator.ts
+import { evaluateExpression, getFieldValue } from "mindoodb-view-language";
+var mindoodbModulePromise = null;
+async function loadMindoodbForTesting() {
+  if (!mindoodbModulePromise) {
+    mindoodbModulePromise = import("mindoodb").then((mod) => mod).catch(() => null);
+  }
+  return mindoodbModulePromise;
+}
+function toFormulaBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "false" && normalized !== "0" && normalized !== "no";
+  }
+  return Boolean(value);
+}
+function matchesFilter(mindoodb, definition, doc, origin, createdAt, lastModifiedAt, witnessed, awaitingWitness) {
+  void mindoodb;
+  if (!definition.filter) return true;
+  return toFormulaBoolean(
+    evaluateExpression(definition.filter.expression, {
+      doc,
+      values: doc,
+      origin,
+      createdAt,
+      lastModifiedAt,
+      witnessed,
+      awaitingWitness,
+      variables: {}
+    })
+  );
+}
+function computeColumnValues(definition, doc, origin, createdAt, lastModifiedAt, witnessed, awaitingWitness) {
+  const values = {};
+  for (const [key, value] of Object.entries(doc)) {
+    if (!key.startsWith("_")) values[key] = value;
+  }
+  for (const column of definition.columns) {
+    const expression = column.expression;
+    const value = expression.kind === "field" ? getFieldValue(doc, expression.path) ?? getFieldValue(values, expression.path) : evaluateExpression(expression, {
+      doc,
+      values,
+      origin,
+      createdAt,
+      lastModifiedAt,
+      witnessed,
+      awaitingWitness,
+      variables: {}
+    });
+    values[column.name] = value;
+  }
+  return values;
+}
+function mapSorting(mindoodb, direction) {
+  switch (direction) {
+    case "ascending":
+      return mindoodb.ColumnSorting.ASCENDING;
+    case "descending":
+      return mindoodb.ColumnSorting.DESCENDING;
+    default:
+      return mindoodb.ColumnSorting.NONE;
+  }
+}
+function mapTotalMode(mindoodb, mode) {
+  switch (mode) {
+    case "sum":
+      return mindoodb.TotalMode.SUM;
+    case "average":
+      return mindoodb.TotalMode.AVERAGE;
+    default:
+      return mindoodb.TotalMode.NONE;
+  }
+}
+function getCategoryPath(entry) {
+  const path = [];
+  let current = entry.isCategory() ? entry : entry.getParent();
+  while (current && !current.isRoot()) {
+    if (current.isCategory()) path.unshift(current.getCategoryValue());
+    current = current.getParent();
+  }
+  return path;
+}
+function serializeEntry(navigator, entry) {
+  const parent = entry.getParent();
+  return {
+    key: entry.getPositionStr(),
+    kind: entry.isCategory() ? "category" : "document",
+    origin: entry.origin,
+    docId: entry.docId,
+    level: entry.getLevel(),
+    parentKey: parent && !parent.isRoot() ? parent.getPositionStr() : null,
+    categoryPath: getCategoryPath(entry),
+    categoryValue: entry.isCategory() ? entry.getCategoryValue() : null,
+    columnValues: entry.getColumnValues(),
+    childCount: entry.getChildCount(),
+    descendantDocumentCount: entry.getDescendantDocumentCount(),
+    descendantCount: entry.getDescendantCount(),
+    descendantCategoryCount: entry.getDescendantCategoryCount(),
+    siblingCount: entry.getSiblingCount(),
+    childCategoryCount: entry.getChildCategoryCount(),
+    childDocumentCount: entry.getChildDocumentCount(),
+    position: entry.getPositionStr(),
+    expanded: entry.isCategory() ? navigator.isExpanded(entry) : false,
+    selected: navigator.isSelected(entry.origin, entry.docId),
+    isVisible: true
+  };
+}
+async function buildVirtualView(mindoodb, definition, documents, categorizationStyle) {
+  const builder = mindoodb.VirtualViewFactory.createView().withCategorizationStyle(
+    categorizationStyle === "category_then_document" ? mindoodb.CategorizationStyle.CATEGORY_THEN_DOCUMENT : mindoodb.CategorizationStyle.DOCUMENT_THEN_CATEGORY
+  );
+  for (const column of definition.columns) {
+    const commonOptions = {
+      title: column.title,
+      isHidden: column.hidden,
+      expression: column.expression
+    };
+    switch (column.role) {
+      case "category":
+        builder.addCategoryColumn(column.name, {
+          ...commonOptions,
+          sorting: mapSorting(
+            mindoodb,
+            column.sorting === "none" ? "ascending" : column.sorting
+          )
+        });
+        break;
+      case "sort":
+        builder.addSortedColumn(
+          column.name,
+          mapSorting(
+            mindoodb,
+            !column.sorting || column.sorting === "none" ? "ascending" : column.sorting
+          ),
+          commonOptions
+        );
+        break;
+      case "display":
+        if (column.sorting && column.sorting !== "none") {
+          builder.addSortedColumn(column.name, mapSorting(mindoodb, column.sorting), commonOptions);
+        } else {
+          builder.addDisplayColumn(column.name, commonOptions);
+        }
+        break;
+      case "total":
+        builder.addTotalColumn(
+          column.name,
+          mapTotalMode(mindoodb, column.totalMode === "none" ? "sum" : column.totalMode),
+          commonOptions
+        );
+        break;
+    }
+  }
+  const view = await builder.build();
+  const changes = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    if (!matchesFilter(
+      mindoodb,
+      definition,
+      document.data,
+      document.origin,
+      document.createdAt,
+      document.lastModifiedAt,
+      document.witnessed,
+      document.awaitingWitness
+    )) {
+      continue;
+    }
+    const change = changes.get(document.origin) ?? new mindoodb.VirtualViewDataChange(document.origin);
+    change.addEntry(
+      document.docId,
+      computeColumnValues(
+        definition,
+        document.data,
+        document.origin,
+        document.createdAt,
+        document.lastModifiedAt,
+        document.witnessed,
+        document.awaitingWitness
+      )
+    );
+    changes.set(document.origin, change);
+  }
+  for (const change of changes.values()) {
+    if (change.hasChanges()) view.applyChanges(change);
+  }
+  view.getRoot();
+  return view;
+}
+function createCoreNavigator(mindoodb, view, options) {
+  const builder = mindoodb.VirtualViewFactory.createNavigator(view);
+  const includeCategories = options?.includeCategories ?? true;
+  const includeDocuments = options?.includeDocuments ?? true;
+  if (!includeCategories && includeDocuments) builder.documentsOnly();
+  else if (includeCategories && !includeDocuments) builder.categoriesOnly();
+  if (options?.hideEmptyCategories) builder.hideEmptyCategories();
+  if (Array.isArray(options?.rootCategoryPath) && options.rootCategoryPath.length > 0) {
+    builder.fromCategory(options.rootCategoryPath.map((part) => String(part)).join("\\"));
+  } else if (options?.rootEntryKey) {
+    const temp = mindoodb.VirtualViewFactory.createSimpleNavigator(view);
+    const rootEntry = temp.getPos(options.rootEntryKey);
+    if (rootEntry) builder.fromEntry(rootEntry);
+  }
+  return builder.build();
+}
+function normalizePageLimit(limit) {
+  return Math.max(1, Math.min(1e3, Math.trunc(limit ?? 100)));
+}
+function pageEntries(navigator, direction, options = {}) {
+  const entries = [];
+  const startOk = options.startPosition ? navigator.gotoPos(options.startPosition) : direction === "forward" ? navigator.gotoFirst() : navigator.gotoLast();
+  if (!startOk) {
+    return { entries, nextPosition: null, hasMore: false };
+  }
+  const moveNext = () => {
+    if (direction === "forward") {
+      return options.selectedOnly ? navigator.gotoNextSelected() : navigator.gotoNext();
+    }
+    return options.selectedOnly ? navigator.gotoPrevSelected() : navigator.gotoPrev();
+  };
+  if (options.selectedOnly) {
+    const current = navigator.getCurrentEntry();
+    if (!current || !navigator.isSelected(current.origin, current.docId)) {
+      if (!moveNext()) return { entries, nextPosition: null, hasMore: false };
+    }
+  }
+  const limit = normalizePageLimit(options.limit);
+  let nextPosition = null;
+  let hasMore = false;
+  while (true) {
+    const current = navigator.getCurrentEntry();
+    if (!current) break;
+    entries.push(serializeEntry(navigator, current));
+    if (entries.length >= limit) {
+      hasMore = moveNext();
+      nextPosition = hasMore ? navigator.getCurrentEntry()?.getPositionStr() ?? null : null;
+      break;
+    }
+    if (!moveNext()) break;
+  }
+  return { entries, nextPosition, hasMore };
+}
+function resolveEntry(navigator, entryKey) {
+  const entry = navigator.getPos(entryKey);
+  if (!entry) {
+    throw new Error(`Unknown view entry: ${entryKey}`);
+  }
+  return entry;
+}
+function wrapNavigator(definition, navigator) {
+  const updateListeners = /* @__PURE__ */ new Set();
+  let viewCursor = null;
+  return {
+    async getDefinition() {
+      return definition;
+    },
+    async getViewCursor() {
+      return viewCursor;
+    },
+    async refresh() {
+      return viewCursor;
+    },
+    onDidUpdate(listener) {
+      updateListeners.add(listener);
+      return () => updateListeners.delete(listener);
+    },
+    async getCurrentEntry() {
+      const entry = navigator.getCurrentEntry();
+      return entry ? serializeEntry(navigator, entry) : null;
+    },
+    async gotoFirst() {
+      return navigator.gotoFirst();
+    },
+    async gotoLast() {
+      return navigator.gotoLast();
+    },
+    async gotoNext() {
+      return navigator.gotoNext();
+    },
+    async gotoPrev() {
+      return navigator.gotoPrev();
+    },
+    async gotoNextSibling() {
+      return navigator.gotoNextSibling();
+    },
+    async gotoPrevSibling() {
+      return navigator.gotoPrevSibling();
+    },
+    async gotoParent() {
+      return navigator.gotoParent();
+    },
+    async gotoFirstChild() {
+      return navigator.gotoFirstChild();
+    },
+    async gotoLastChild() {
+      return navigator.gotoLastChild();
+    },
+    async gotoPos(position) {
+      return navigator.gotoPos(position);
+    },
+    async getPos(position) {
+      const entry = navigator.getPos(position);
+      return entry ? serializeEntry(navigator, entry) : null;
+    },
+    async findCategoryEntryByParts(parts) {
+      const entry = navigator.findCategoryEntryByParts(parts);
+      return entry ? serializeEntry(navigator, entry) : null;
+    },
+    async entriesForward(options) {
+      return pageEntries(navigator, "forward", options);
+    },
+    async entriesBackward(options) {
+      return pageEntries(navigator, "backward", options);
+    },
+    async gotoNextSelected() {
+      return navigator.gotoNextSelected();
+    },
+    async gotoPrevSelected() {
+      return navigator.gotoPrevSelected();
+    },
+    async select(origin, docId, selectParentCategories = false) {
+      navigator.select(origin, docId, selectParentCategories);
+    },
+    async deselect(origin, docId) {
+      navigator.deselect(origin, docId);
+    },
+    async selectAllEntries() {
+      navigator.selectAllEntries();
+    },
+    async deselectAllEntries() {
+      navigator.deselectAllEntries();
+    },
+    async isSelected(origin, docId) {
+      return navigator.isSelected(origin, docId);
+    },
+    async getSelectionState() {
+      return {
+        selectAllByDefault: navigator.isSelectAllByDefault(),
+        entryKeys: Array.from(navigator.getSelectedOrDeselectedEntries())
+      };
+    },
+    async setSelectionState(state) {
+      if (state.selectAllByDefault) navigator.selectAllEntries();
+      else navigator.deselectAllEntries();
+      navigator.setSelectedOrDeselectedEntries(new Set(state.entryKeys));
+    },
+    async expand(origin, docId) {
+      navigator.expand(origin, docId);
+    },
+    async collapse(origin, docId) {
+      navigator.collapse(origin, docId);
+    },
+    async expandAll() {
+      navigator.expandAll();
+    },
+    async collapseAll() {
+      navigator.collapseAll();
+    },
+    async expandToLevel(level) {
+      navigator.expandToLevel(level);
+    },
+    async isExpanded(entryKey) {
+      const entry = navigator.getPos(entryKey);
+      return entry ? navigator.isExpanded(entry) : false;
+    },
+    async getExpansionState() {
+      return {
+        expandAllByDefault: navigator.isExpandAllByDefault(),
+        expandLevel: navigator.getExpandLevel(),
+        entryKeys: Array.from(navigator.getExpandedOrCollapsedEntries())
+      };
+    },
+    async setExpansionState(state) {
+      if (state.expandAllByDefault) navigator.expandAll();
+      else navigator.collapseAll();
+      navigator.expandToLevel(state.expandLevel);
+      navigator.setExpandedOrCollapsedEntries(new Set(state.entryKeys));
+    },
+    async childEntries(entryKey, descending) {
+      return navigator.childEntries(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childCategories(entryKey, descending) {
+      return navigator.childCategories(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childDocuments(entryKey, descending) {
+      return navigator.childDocuments(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childCategoriesByKey(entryKey, key, exact, descending) {
+      return navigator.childCategoriesByKey(
+        resolveEntry(navigator, entryKey),
+        String(key ?? ""),
+        Boolean(exact),
+        descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childDocumentsByKey(entryKey, key, exact, descending) {
+      return navigator.childDocumentsByKey(
+        resolveEntry(navigator, entryKey),
+        String(key ?? ""),
+        Boolean(exact),
+        descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childCategoriesBetween(entryKey, range) {
+      return navigator.childCategoriesBetween(
+        resolveEntry(navigator, entryKey),
+        range.startKey,
+        range.endKey,
+        range.descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childDocumentsBetween(entryKey, range) {
+      return navigator.childDocumentsBetween(
+        resolveEntry(navigator, entryKey),
+        range.startKey,
+        range.endKey,
+        range.descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async getSortedDocIds(descending) {
+      const page = pageEntries(navigator, descending ? "backward" : "forward", { limit: 1e3 });
+      return collectSortedDocIds(page.entries);
+    },
+    async getSortedDocIdsScoped(entryKey, descending) {
+      const docs = navigator.childDocuments(resolveEntry(navigator, entryKey), descending);
+      return docs.map((entry) => ({ origin: entry.origin, docId: entry.docId }));
+    },
+    async dispose() {
+      updateListeners.clear();
+    }
+  };
+}
+function collectSortedDocIds(entries) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.kind !== "document" || !entry.docId) continue;
+    const key = `${entry.origin}:${entry.docId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({ origin: entry.origin, docId: entry.docId });
+  }
+  return results;
+}
+async function createEvaluatingViewNavigator(input, documents) {
+  const mindoodb = await loadMindoodbForTesting();
+  if (!mindoodb) return null;
+  const view = await buildVirtualView(
+    mindoodb,
+    input.definition,
+    documents,
+    input.categorizationStyle
+  );
+  const navigator = createCoreNavigator(mindoodb, view, input.options);
+  return wrapNavigator(input.definition, navigator);
+}
+
+// src/testing/index.ts
 var PROTOCOL = "mindoodb-app-bridge";
 var MOCK_SIGNING_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAmockmockmockmockmockmockmockmockmockmockmoc=\n-----END PUBLIC KEY-----\n";
 function createBridgeErrorPayload(error, fallbackCode = "bridge-error") {
@@ -378,7 +839,7 @@ function persistMockAutomergeDocument(document, automergeDoc) {
   document.data = structuredClone(automergeDoc);
   document.heads = Automerge.getHeads(automergeDoc);
 }
-function getFieldValue(source, field) {
+function getFieldValue2(source, field) {
   return field.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
       return current[part];
@@ -391,7 +852,7 @@ function matchesDocumentFilter(document, filter) {
     return true;
   }
   return Object.entries(filter).every(
-    ([field, expected]) => getFieldValue(document.data, field) === expected
+    ([field, expected]) => getFieldValue2(document.data, field) === expected
   );
 }
 function matchesMockIdPrefix(docId, idPrefix) {
@@ -454,7 +915,7 @@ function computeMockTextScore(document, clause) {
   if (terms.length === 0) {
     return void 0;
   }
-  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue(document.data, field))).join(" ") : collectMockText(
+  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue2(document.data, field))).join(" ") : collectMockText(
     Object.fromEntries(
       Object.entries(document.data).filter(([key]) => !key.startsWith("_"))
     )
@@ -497,14 +958,14 @@ function runMockDocumentQuery(storedDocuments, databaseId, query) {
       origin: databaseId,
       variables: {}
     };
-    if (filter && !mockExpressionToBoolean(evaluateExpression(filter, context))) {
+    if (filter && !mockExpressionToBoolean(evaluateExpression2(filter, context))) {
       continue;
     }
     const sortValues = sortBy.map((key) => {
       if (key.special === "textScore") {
         return textScore ?? 0;
       }
-      return key.expression ? evaluateExpression(key.expression, context) : getFieldValue(document.data, key.field ?? "");
+      return key.expression ? evaluateExpression2(key.expression, context) : getFieldValue2(document.data, key.field ?? "");
     });
     matches.push({ document, sortValues, textScore });
   }
@@ -531,7 +992,7 @@ function runMockDocumentQuery(storedDocuments, databaseId, query) {
     fields: query?.fields ? Object.fromEntries(
       query.fields.map((field) => [
         field,
-        getFieldValue(document.data, field)
+        getFieldValue2(document.data, field)
       ])
     ) : structuredClone(document.data),
     lastModified: document.updatedAt ? Date.parse(document.updatedAt) || 0 : 0,
@@ -760,6 +1221,16 @@ function createDatabaseHandle(definition) {
   let changeCounter = 0;
   const defaultViewFactory = async () => createDefaultViewNavigator();
   const storedDocuments = /* @__PURE__ */ new Map();
+  for (const seed of definition.documents ?? []) {
+    storedDocuments.set(seed.id, {
+      id: seed.id,
+      data: structuredClone(seed.data),
+      heads: seed.heads ? [...seed.heads] : void 0,
+      attachments: seed.attachments ? structuredClone(seed.attachments) : [],
+      updatedAt: seed.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      isDeleted: seed.isDeleted ?? false
+    });
+  }
   const liveQuerySubscriptions = /* @__PURE__ */ new Set();
   const notifyLiveQueries = () => {
     for (const subscription of liveQuerySubscriptions) {
@@ -832,7 +1303,7 @@ function createDatabaseHandle(definition) {
         const projectedData = query?.fields ? Object.fromEntries(
           query.fields.map((field) => [
             field,
-            getFieldValue(document.data, field)
+            getFieldValue2(document.data, field)
           ])
         ) : document.data;
         return {
@@ -1181,12 +1652,22 @@ function createDatabaseHandle(definition) {
     },
     async openPreview(_docId, _attachmentName, _options) {
       return { ok: true };
+    },
+    async extractText(input) {
+      const format = input.format ?? "markdown";
+      const text = new TextDecoder("utf-8", { fatal: false }).decode(input.bytes);
+      return {
+        text,
+        handled: true,
+        format,
+        engine: "mock-utf-8"
+      };
     }
   };
   const methods = definition.methods ?? {};
   let fulltextSetup = definition.fulltextSetup ?? null;
   let extractionSetup = definition.extractionSetup ?? null;
-  return {
+  const databaseHandle = {
     async info() {
       return {
         ...definition.info,
@@ -1226,6 +1707,15 @@ function createDatabaseHandle(definition) {
       extractionSetup = config === null ? null : { ...config };
     }
   };
+  return {
+    handle: databaseHandle,
+    listViewDocuments: () => Array.from(storedDocuments.values()).filter((document) => !document.isDeleted).map((document) => ({
+      origin: definition.info.id,
+      docId: document.id,
+      data: structuredClone(document.data),
+      createdAt: document.updatedAt ?? null
+    }))
+  };
 }
 function createMockSessionState(options = {}) {
   let launchContext = createDefaultLaunchContext(options.launchContext);
@@ -1234,6 +1724,7 @@ function createMockSessionState(options = {}) {
   const uiPreferencesListeners = /* @__PURE__ */ new Set();
   const localeListeners = /* @__PURE__ */ new Set();
   const databaseHandles = /* @__PURE__ */ new Map();
+  const databaseViewDocumentLists = /* @__PURE__ */ new Map();
   const databaseViewApis = /* @__PURE__ */ new Map();
   const sessionViews = /* @__PURE__ */ new Map();
   let activeMenuResolve = null;
@@ -1260,15 +1751,27 @@ function createMockSessionState(options = {}) {
   };
   const setDatabases = (definitions) => {
     databaseHandles.clear();
+    databaseViewDocumentLists.clear();
     databaseViewApis.clear();
     databaseInfos = definitions.map((definition) => ({
       ...definition.info,
       capabilities: [...definition.info.capabilities]
     }));
     for (const definition of definitions) {
-      databaseHandles.set(definition.info.id, createDatabaseHandle(definition));
+      const created = createDatabaseHandle(definition);
+      databaseHandles.set(definition.info.id, created.handle);
+      databaseViewDocumentLists.set(definition.info.id, created.listViewDocuments);
       databaseViewApis.set(definition.info.id, {
-        async create(_input) {
+        async create(input) {
+          const documents = input.databaseIds.flatMap((databaseId) => {
+            const list = databaseViewDocumentLists.get(databaseId);
+            return list ? list() : [];
+          });
+          const evaluating = await createEvaluatingViewNavigator(input, documents);
+          if (evaluating) return evaluating;
+          console.warn(
+            "[mindoodb-app-sdk/testing] mindoodb peer not available; using empty view navigator. Install mindoodb as a devDependency for evaluating VirtualViews."
+          );
           return await createDefaultViewNavigator();
         },
         async open(_viewId) {
@@ -1831,6 +2334,16 @@ function createFakeBridgeHost(options = {}) {
           String(params.attachmentName),
           typeof params.revisionId === "string" ? { revisionId: params.revisionId } : typeof params.timestamp === "number" ? { timestamp: params.timestamp } : void 0
         );
+      case "attachments.extractText":
+        return await state.getDatabase(String(params.databaseId)).attachments.extractText({
+          bytes: params.bytes instanceof Uint8Array ? params.bytes : new Uint8Array(
+            params.bytes instanceof ArrayBuffer ? params.bytes : Array.isArray(params.bytes) ? params.bytes : []
+          ),
+          mimeType: typeof params.mimeType === "string" ? params.mimeType : "",
+          fileName: typeof params.fileName === "string" ? params.fileName : void 0,
+          format: params.format === "plainText" || params.format === "markdown" ? params.format : void 0,
+          languages: Array.isArray(params.languages) ? params.languages.filter((entry) => typeof entry === "string") : void 0
+        });
       case "attachments.preparePreviewSession":
         return await state.getDatabase(String(params.databaseId)).attachments.preparePreviewSession(
           String(params.docId),
@@ -2180,7 +2693,9 @@ function createFakeBridgeHost(options = {}) {
   return controller;
 }
 export {
+  createEvaluatingViewNavigator,
   createFakeBridgeHost,
   createMockMindooDBAppBridge,
-  createMockMindooDBAppSession
+  createMockMindooDBAppSession,
+  loadMindoodbForTesting
 };

package/dist/{types-Bl6CrBn1.d.ts → types-qW1XwmiZ.d.ts}

@@ -1733,6 +1733,32 @@ interface MindooDBAppViewNavigator {
  * `timestamp`/`revisionId` options) additionally require `history`, and
  * mutations (`openWriteStream`, `remove`, `scan`) require `update`.
  */
+/**
+ * Output format for {@link MindooDBAppAttachmentApi.extractText}.
+ * `"markdown"` (default) keeps anydoc's GFM; `"plainText"` strips markup.
+ * OCR / plain-file paths return the same string for either value.
+ */
+type MindooDBAppExtractTextFormat = "markdown" | "plainText";
+/** Bytes-in extraction request for {@link MindooDBAppAttachmentApi.extractText}. */
+interface MindooDBAppExtractDocumentTextInput {
+    bytes: Uint8Array;
+    mimeType: string;
+    fileName?: string;
+    /** Default `"markdown"`. */
+    format?: MindooDBAppExtractTextFormat;
+    /** Optional OCR language hints when the host falls back to OCR. */
+    languages?: string[];
+}
+/** Result of {@link MindooDBAppAttachmentApi.extractText}. */
+interface MindooDBAppExtractDocumentTextResult {
+    text: string;
+    /** False when the host has no extractor for this format. */
+    handled: boolean;
+    /** Resolved output format (defaults to `"markdown"`). */
+    format: MindooDBAppExtractTextFormat;
+    /** Engine label, e.g. `anydoc@0.1.2` or `tesseract`. */
+    engine?: string;
+}
 interface MindooDBAppAttachmentApi {
     /**
      * Attachment metadata of a document. Pass `options.revisionId` (preferred
@@ -1778,6 +1804,13 @@ interface MindooDBAppAttachmentApi {
     openPreview(docId: string, attachmentName: string, options?: MindooDBAppAttachmentPreviewOptions): Promise<{
         ok: true;
     }>;
+    /**
+     * Extract searchable / displayable text from document bytes the app already
+     * holds (e.g. after {@link openReadStream}). Haven runs anydoc for Office/PDF
+     * (Markdown by default), UTF-8 decode for plain text, and OCR for images /
+     * scanned PDFs. Requires the `attachments` capability.
+     */
+    extractText(input: MindooDBAppExtractDocumentTextInput): Promise<MindooDBAppExtractDocumentTextResult>;
 }
 /** Database handle returned from `session.openDatabase()`. */
 interface MindooDBAppDatabase {
@@ -1925,4 +1958,4 @@ interface MindooDBAppBridge {
     connect(options?: MindooDBAppBridgeConnectOptions): Promise<MindooDBAppSession>;
 }
 
-export { type MindooDBAppConfiguredViewFormulaFilterDefinition as $, type MindooDBAppBridgeRpcError as A, type MindooDBAppBridgeRpcMessage as B, type MindooDBAppBridgeRpcRequest as C, type MindooDBAppBridgeRpcSuccess as D, type MindooDBAppBridgeStreamAbortRequest as E, type MindooDBAppBridgeStreamAck as F, type MindooDBAppBridgeStreamCloseRequest as G, type MindooDBAppBridgeStreamError as H, type MindooDBAppBridgeStreamMessage as I, type MindooDBAppBridgeStreamOpenResult as J, type MindooDBAppBridgeStreamReadRequest as K, type MindooDBAppBridgeStreamWriteRequest as L, type MindooDBAppAttachmentPreviewMode as M, type MindooDBAppBridgeThemeChangedMessage as N, type MindooDBAppBridgeUiPreferencesChangedMessage as O, type MindooDBAppBridgeViewChangedMessage as P, type MindooDBAppBridgeViewportChangedMessage as Q, type MindooDBAppCapability as R, type MindooDBAppConfiguredViewCategorizationStyle as S, type MindooDBAppConfiguredViewColumn as T, type MindooDBAppConfiguredViewColumnRole as U, type MindooDBAppConfiguredViewExpressionMode as V, type MindooDBAppConfiguredViewFieldExpression as W, type MindooDBAppConfiguredViewFilterDefinition as X, type MindooDBAppConfiguredViewFilterMode as Y, type MindooDBAppConfiguredViewFilterRule as Z, type MindooDBAppConfiguredViewFormulaExpression as _, type MindooDBAppBridge as a, type MindooDBAppRichTextImmutableString as a$, type MindooDBAppConfiguredViewPreviewMode as a0, type MindooDBAppConfiguredViewRuleFilterDefinition as a1, type MindooDBAppConfiguredViewRuleMatchMode as a2, type MindooDBAppConfiguredViewRuleOperator as a3, type MindooDBAppConfiguredViewValueExpression as a4, type MindooDBAppCreateDocumentInput as a5, type MindooDBAppCreateViewInput as a6, type MindooDBAppCreateViewNavigatorInput as a7, type MindooDBAppDatabaseInfo as a8, type MindooDBAppDirectoryApi as a9, type MindooDBAppLaunchContext as aA, type MindooDBAppLiveQuerySubscription as aB, type MindooDBAppMenuAnchor as aC, type MindooDBAppMenuApi as aD, type MindooDBAppMenuCommandItem as aE, type MindooDBAppMenuDismissReason as aF, type MindooDBAppMenuDismissedResult as aG, type MindooDBAppMenuItem as aH, type MindooDBAppMenuKind as aI, type MindooDBAppMenuPlacement as aJ, type MindooDBAppMenuPointAnchor as aK, type MindooDBAppMenuRect as aL, type MindooDBAppMenuRectAnchor as aM, type MindooDBAppMenuSelectionResult as aN, type MindooDBAppMenuSeparatorItem as aO, type MindooDBAppQueryCoverage as aP, type MindooDBAppQueryResult as aQ, type MindooDBAppQueryRow as aR, type MindooDBAppQuerySortKey as aS, type MindooDBAppQueryTextClause as aT, type MindooDBAppReadableAttachmentStream as aU, type MindooDBAppResolvedViewDefinition as aV, type MindooDBAppResolvedViewSource as aW, type MindooDBAppRevisionPhase as aX, type MindooDBAppRevisionVerification as aY, type MindooDBAppRichTextBlockSpan as aZ, type MindooDBAppRichTextGetOptions as a_, type MindooDBAppDirectoryEntry as aa, type MindooDBAppDocumentApi as ab, type MindooDBAppDocumentHeadCursorResult as ac, type MindooDBAppDocumentHistoryEntry as ad, type MindooDBAppDocumentListQuery as ae, type MindooDBAppDocumentListResult as af, type MindooDBAppDocumentQuery as ag, type MindooDBAppDocumentRevisionId as ah, type MindooDBAppDocumentScanPreset as ai, type MindooDBAppDocumentSummary as aj, type MindooDBAppEntryAttachmentRef as ak, type MindooDBAppEntryProvenance as al, type MindooDBAppExtractionSetup as am, type MindooDBAppFulltextSetup as an, type MindooDBAppHistoricalDocument as ao, type MindooDBAppHistoryQuery as ap, type MindooDBAppHostTheme as aq, type MindooDBAppIdentityApi as ar, type MindooDBAppJsonListDeletePatch as as, type MindooDBAppJsonListInsertPatch as at, type MindooDBAppJsonPatch as au, type MindooDBAppJsonSetPatch as av, type MindooDBAppJsonTextMarkPatch as aw, type MindooDBAppJsonTextSplicePatch as ax, type MindooDBAppJsonTextUnmarkPatch as ay, type MindooDBAppJsonUnsetPatch as az, type MindooDBAppDatabase as b, type MindooDBAppRichTextMarkRange as b0, type MindooDBAppRichTextMaterializeValue as b1, type MindooDBAppRichTextPatch as b2, type MindooDBAppRichTextScalar as b3, type MindooDBAppRichTextSpliceStep as b4, type MindooDBAppRichTextStep as b5, type MindooDBAppRichTextStepPatch as b6, type MindooDBAppRichTextTextSpan as b7, type MindooDBAppRuntime as b8, type MindooDBAppScanAttachmentOptions as b9, type MindooDBAppViewNavigatorOpenOptions as bA, type MindooDBAppViewNavigatorPageOptions as bB, type MindooDBAppViewNavigatorPageResult as bC, type MindooDBAppViewNavigatorRangeQuery as bD, type MindooDBAppViewNavigatorSelectionState as bE, type MindooDBAppViewUpdateStats as bF, type MindooDBAppViewport as bG, type MindooDBAppWritableAttachmentStream as bH, type MindooDBAppScanAttachmentResult as ba, type MindooDBAppScopedDocId as bb, type MindooDBAppScopedDocumentSummary as bc, type MindooDBAppSealIntent as bd, type MindooDBAppSession as be, type MindooDBAppShowMenuInput as bf, type MindooDBAppShowMenuResult as bg, type MindooDBAppSignPreview as bh, type MindooDBAppSignPreviewScope as bi, type MindooDBAppSignStatementInput as bj, type MindooDBAppSignStatementResult as bk, type MindooDBAppTextEdit as bl, type MindooDBAppTextPatch as bm, type MindooDBAppThemeMode as bn, type MindooDBAppTimestampApi as bo, type MindooDBAppTimestampInput as bp, type MindooDBAppTimestampProvider as bq, type MindooDBAppTimestampResult as br, type MindooDBAppUiPreferences as bs, type MindooDBAppUpdateDocumentInput as bt, type MindooDBAppViewCursorDocumentListResult as bu, type MindooDBAppViewCursorResult as bv, type MindooDBAppViewEntry as bw, type MindooDBAppViewEntryKind as bx, type MindooDBAppViewNavigator as by, type MindooDBAppViewNavigatorExpansionState as bz, type MindooDBAppDocument as c, type MindooDBAppRichTextSpan as d, type MindooDBAppRichTextSnapshot as e, MINDOODB_APP_SEAL_SIGNING_DOMAIN as f, type MindooDBAppAccessDecision as g, type MindooDBAppAccessTier as h, type MindooDBAppAttachmentApi as i, type MindooDBAppAttachmentChunk as j, type MindooDBAppAttachmentInfo as k, type MindooDBAppAttachmentPreviewOptions as l, type MindooDBAppAttachmentPreviewSession as m, type MindooDBAppAutomergeChangesPatch as n, type MindooDBAppAutomergeChangesSince as o, type MindooDBAppAutomergeGetOptions as p, type MindooDBAppAutomergePatchResult as q, type MindooDBAppAutomergeSnapshot as r, type MindooDBAppBridgeConnectMessage as s, type MindooDBAppBridgeConnectOptions as t, type MindooDBAppBridgeConnectedMessage as u, type MindooDBAppBridgeErrorPayload as v, type MindooDBAppBridgeHandshakeErrorMessage as w, type MindooDBAppBridgeLocaleChangedMessage as x, type MindooDBAppBridgePortMessage as y, type MindooDBAppBridgeQueryResultMessage as z };
+export { type MindooDBAppConfiguredViewFormulaFilterDefinition as $, type MindooDBAppBridgeRpcError as A, type MindooDBAppBridgeRpcMessage as B, type MindooDBAppBridgeRpcRequest as C, type MindooDBAppBridgeRpcSuccess as D, type MindooDBAppBridgeStreamAbortRequest as E, type MindooDBAppBridgeStreamAck as F, type MindooDBAppBridgeStreamCloseRequest as G, type MindooDBAppBridgeStreamError as H, type MindooDBAppBridgeStreamMessage as I, type MindooDBAppBridgeStreamOpenResult as J, type MindooDBAppBridgeStreamReadRequest as K, type MindooDBAppBridgeStreamWriteRequest as L, type MindooDBAppAttachmentPreviewMode as M, type MindooDBAppBridgeThemeChangedMessage as N, type MindooDBAppBridgeUiPreferencesChangedMessage as O, type MindooDBAppBridgeViewChangedMessage as P, type MindooDBAppBridgeViewportChangedMessage as Q, type MindooDBAppCapability as R, type MindooDBAppConfiguredViewCategorizationStyle as S, type MindooDBAppConfiguredViewColumn as T, type MindooDBAppConfiguredViewColumnRole as U, type MindooDBAppConfiguredViewExpressionMode as V, type MindooDBAppConfiguredViewFieldExpression as W, type MindooDBAppConfiguredViewFilterDefinition as X, type MindooDBAppConfiguredViewFilterMode as Y, type MindooDBAppConfiguredViewFilterRule as Z, type MindooDBAppConfiguredViewFormulaExpression as _, type MindooDBAppBridge as a, type MindooDBAppRevisionVerification as a$, type MindooDBAppConfiguredViewPreviewMode as a0, type MindooDBAppConfiguredViewRuleFilterDefinition as a1, type MindooDBAppConfiguredViewRuleMatchMode as a2, type MindooDBAppConfiguredViewRuleOperator as a3, type MindooDBAppConfiguredViewValueExpression as a4, type MindooDBAppCreateDocumentInput as a5, type MindooDBAppCreateViewInput as a6, type MindooDBAppCreateViewNavigatorInput as a7, type MindooDBAppDatabaseInfo as a8, type MindooDBAppDirectoryApi as a9, type MindooDBAppJsonTextSplicePatch as aA, type MindooDBAppJsonTextUnmarkPatch as aB, type MindooDBAppJsonUnsetPatch as aC, type MindooDBAppLaunchContext as aD, type MindooDBAppLiveQuerySubscription as aE, type MindooDBAppMenuAnchor as aF, type MindooDBAppMenuApi as aG, type MindooDBAppMenuCommandItem as aH, type MindooDBAppMenuDismissReason as aI, type MindooDBAppMenuDismissedResult as aJ, type MindooDBAppMenuItem as aK, type MindooDBAppMenuKind as aL, type MindooDBAppMenuPlacement as aM, type MindooDBAppMenuPointAnchor as aN, type MindooDBAppMenuRect as aO, type MindooDBAppMenuRectAnchor as aP, type MindooDBAppMenuSelectionResult as aQ, type MindooDBAppMenuSeparatorItem as aR, type MindooDBAppQueryCoverage as aS, type MindooDBAppQueryResult as aT, type MindooDBAppQueryRow as aU, type MindooDBAppQuerySortKey as aV, type MindooDBAppQueryTextClause as aW, type MindooDBAppReadableAttachmentStream as aX, type MindooDBAppResolvedViewDefinition as aY, type MindooDBAppResolvedViewSource as aZ, type MindooDBAppRevisionPhase as a_, type MindooDBAppDirectoryEntry as aa, type MindooDBAppDocumentApi as ab, type MindooDBAppDocumentHeadCursorResult as ac, type MindooDBAppDocumentHistoryEntry as ad, type MindooDBAppDocumentListQuery as ae, type MindooDBAppDocumentListResult as af, type MindooDBAppDocumentQuery as ag, type MindooDBAppDocumentRevisionId as ah, type MindooDBAppDocumentScanPreset as ai, type MindooDBAppDocumentSummary as aj, type MindooDBAppEntryAttachmentRef as ak, type MindooDBAppEntryProvenance as al, type MindooDBAppExtractDocumentTextInput as am, type MindooDBAppExtractDocumentTextResult as an, type MindooDBAppExtractTextFormat as ao, type MindooDBAppExtractionSetup as ap, type MindooDBAppFulltextSetup as aq, type MindooDBAppHistoricalDocument as ar, type MindooDBAppHistoryQuery as as, type MindooDBAppHostTheme as at, type MindooDBAppIdentityApi as au, type MindooDBAppJsonListDeletePatch as av, type MindooDBAppJsonListInsertPatch as aw, type MindooDBAppJsonPatch as ax, type MindooDBAppJsonSetPatch as ay, type MindooDBAppJsonTextMarkPatch as az, type MindooDBAppDatabase as b, type MindooDBAppRichTextBlockSpan as b0, type MindooDBAppRichTextGetOptions as b1, type MindooDBAppRichTextImmutableString as b2, type MindooDBAppRichTextMarkRange as b3, type MindooDBAppRichTextMaterializeValue as b4, type MindooDBAppRichTextPatch as b5, type MindooDBAppRichTextScalar as b6, type MindooDBAppRichTextSpliceStep as b7, type MindooDBAppRichTextStep as b8, type MindooDBAppRichTextStepPatch as b9, type MindooDBAppViewEntryKind as bA, type MindooDBAppViewNavigator as bB, type MindooDBAppViewNavigatorExpansionState as bC, type MindooDBAppViewNavigatorOpenOptions as bD, type MindooDBAppViewNavigatorPageOptions as bE, type MindooDBAppViewNavigatorPageResult as bF, type MindooDBAppViewNavigatorRangeQuery as bG, type MindooDBAppViewNavigatorSelectionState as bH, type MindooDBAppViewUpdateStats as bI, type MindooDBAppViewport as bJ, type MindooDBAppWritableAttachmentStream as bK, type MindooDBAppRichTextTextSpan as ba, type MindooDBAppRuntime as bb, type MindooDBAppScanAttachmentOptions as bc, type MindooDBAppScanAttachmentResult as bd, type MindooDBAppScopedDocId as be, type MindooDBAppScopedDocumentSummary as bf, type MindooDBAppSealIntent as bg, type MindooDBAppSession as bh, type MindooDBAppShowMenuInput as bi, type MindooDBAppShowMenuResult as bj, type MindooDBAppSignPreview as bk, type MindooDBAppSignPreviewScope as bl, type MindooDBAppSignStatementInput as bm, type MindooDBAppSignStatementResult as bn, type MindooDBAppTextEdit as bo, type MindooDBAppTextPatch as bp, type MindooDBAppThemeMode as bq, type MindooDBAppTimestampApi as br, type MindooDBAppTimestampInput as bs, type MindooDBAppTimestampProvider as bt, type MindooDBAppTimestampResult as bu, type MindooDBAppUiPreferences as bv, type MindooDBAppUpdateDocumentInput as bw, type MindooDBAppViewCursorDocumentListResult as bx, type MindooDBAppViewCursorResult as by, type MindooDBAppViewEntry as bz, type MindooDBAppDocument as c, type MindooDBAppRichTextSpan as d, type MindooDBAppRichTextSnapshot as e, MINDOODB_APP_SEAL_SIGNING_DOMAIN as f, type MindooDBAppAccessDecision as g, type MindooDBAppAccessTier as h, type MindooDBAppAttachmentApi as i, type MindooDBAppAttachmentChunk as j, type MindooDBAppAttachmentInfo as k, type MindooDBAppAttachmentPreviewOptions as l, type MindooDBAppAttachmentPreviewSession as m, type MindooDBAppAutomergeChangesPatch as n, type MindooDBAppAutomergeChangesSince as o, type MindooDBAppAutomergeGetOptions as p, type MindooDBAppAutomergePatchResult as q, type MindooDBAppAutomergeSnapshot as r, type MindooDBAppBridgeConnectMessage as s, type MindooDBAppBridgeConnectOptions as t, type MindooDBAppBridgeConnectedMessage as u, type MindooDBAppBridgeErrorPayload as v, type MindooDBAppBridgeHandshakeErrorMessage as w, type MindooDBAppBridgeLocaleChangedMessage as x, type MindooDBAppBridgePortMessage as y, type MindooDBAppBridgeQueryResultMessage as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindoodb-app-sdk",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "engines": {
     "node": ">=22.13.0"
   },
@@ -36,26 +36,30 @@
     }
   },
   "dependencies": {
-    "mindoodb-view-language": "0.0.14"
+    "mindoodb-view-language": "0.0.15"
   },
   "peerDependencies": {
-    "@automerge/automerge": "^3.2.1"
+    "@automerge/automerge": "^3.3.2",
+    "mindoodb": ">=0.0.48"
   },
   "peerDependenciesMeta": {
     "@automerge/automerge": {
       "optional": true
+    },
+    "mindoodb": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@automerge/automerge": "^3.2.1",
-    "mindoodb": "^0.0.47",
+    "@automerge/automerge": "^3.3.2",
+    "mindoodb": "^0.0.48",
     "@types/node": "25.5.0",
     "tsup": "^8.5.1",
     "typescript": "^6.0.2",
     "vitest": "^4.1.2"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/testing/index.ts --format esm --dts --clean --external @automerge/automerge --tsconfig tsconfig.build.json",
+    "build": "tsup src/index.ts src/testing/index.ts --format esm --dts --clean --external @automerge/automerge --external mindoodb --tsconfig tsconfig.build.json",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest"