mindoodb-app-sdk 0.0.33 → 0.0.36

package/README.md

@@ -418,7 +418,8 @@ const history = await db.documents.listHistory(docId);
 //   identityLabel?,
 //   isDeleted,
 //   isCurrent,
-//   summary?
+//   summary?,
+//   dependencyIds?
 // }
 
 // Load the document state at an exact DAG revision
@@ -446,6 +447,27 @@ const pointInTime = await db.documents.getAtTimestamp(
 
 Historical snapshots include the document data payload as it existed at that revision. When the snapshot has attachments, `attachments` reflects the historical `_attachments` array for that same revision, including the attachment reference that Haven needs to stop at the correct historical `lastChunkId`.
 
+#### What one revision changed
+
+To show a diff, you need both sides of a revision. Pass `{ phase: "before" }` to read the state the revision was written against instead of the state it produced:
+
+```ts
+const after = await db.documents.getAtRevision(docId, revisionId);
+const before = await db.documents.getAtRevision(docId, revisionId, {
+  phase: "before",
+});
+```
+
+`before` is always a single document, even when the revision merged concurrent branches: it is the merge of all its parents, which is exactly what its author had loaded. For the document's creation there is no prior state, so `before` reports `state: "missing"`.
+
+The `dependencyIds` on each history entry are that revision's parents — the edges of the signed change graph. Since a timeline is only one linearization of that graph, use them to draw or walk the graph itself, and `getAtHeads` to materialize any point in it:
+
+```ts
+const merged = await db.documents.getAtHeads(docId, entry.dependencyIds ?? []);
+```
+
+An id in `dependencyIds` may name a revision the timeline does not list, because a change that left the document state untouched produces no timeline row. Draw only the edges whose endpoints you have; `getAtHeads` still resolves the full list.
+
 ### Granular JSON edits
 
 When you need to edit nested objects or lists inside a document — not just top-level fields — describe the change as a **granular JSON patch** rather than rewriting the whole document. This is the model behind structured collaborative editing in apps like [`mindoodb-app-teamgrid`](https://github.com/klehmann/mindoodb-app-teamgrid), where two users can insert different rows into the same worksheet on different devices and the merge keeps both sides cleanly.
@@ -968,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
@@ -1365,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.
@@ -1451,7 +1497,8 @@ Connect options: `launchId?`, `targetOrigin?`, `connectTimeoutMs?`.
 | `undelete(docId)`                  | `Promise<{ ok: true }>`                      |
 | `listHistory(docId)`               | `Promise<MindooDBAppDocumentHistoryEntry[]>` |
 | `getAtTimestamp(docId, timestamp)` | `Promise<MindooDBAppHistoricalDocument>`     |
-| `getAtRevision(docId, revisionId)` | `Promise<MindooDBAppHistoricalDocument>`     |
+| `getAtRevision(docId, revisionId, opts?)` | `Promise<MindooDBAppHistoricalDocument>` |
+| `getAtHeads(docId, headIds)`       | `Promise<MindooDBAppHistoricalDocument>`     |
 
 `getAutomergeSnapshot` and `applyAutomergeChanges` are **discouraged** escape-hatch APIs for binary Automerge sync. Prefer `set`/`unset` and JSON patches (`text`, `richText`, `json`) instead. See [Automerge binary sync (advanced)](#automerge-binary-sync-advanced).
 

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-c6uTlJnB.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 MindooDBAppRevisionVerification, aY as MindooDBAppRichTextBlockSpan, aZ as MindooDBAppRichTextGetOptions, a_ as MindooDBAppRichTextImmutableString, a$ as MindooDBAppRichTextMarkRange, b0 as MindooDBAppRichTextMaterializeValue, b1 as MindooDBAppRichTextPatch, b2 as MindooDBAppRichTextScalar, b3 as MindooDBAppRichTextSpliceStep, b4 as MindooDBAppRichTextStep, b5 as MindooDBAppRichTextStepPatch, b6 as MindooDBAppRichTextTextSpan, b7 as MindooDBAppRuntime, b8 as MindooDBAppScanAttachmentOptions, b9 as MindooDBAppScanAttachmentResult, ba as MindooDBAppScopedDocId, bb as MindooDBAppScopedDocumentSummary, bc as MindooDBAppSealIntent, bd as MindooDBAppSession, be as MindooDBAppShowMenuInput, bf as MindooDBAppShowMenuResult, bg as MindooDBAppSignPreview, bh as MindooDBAppSignPreviewScope, bi as MindooDBAppSignStatementInput, bj as MindooDBAppSignStatementResult, bk as MindooDBAppTextEdit, bl as MindooDBAppTextPatch, bm as MindooDBAppThemeMode, bn as MindooDBAppTimestampApi, bo as MindooDBAppTimestampInput, bp as MindooDBAppTimestampProvider, bq as MindooDBAppTimestampResult, br as MindooDBAppUiPreferences, bs as MindooDBAppUpdateDocumentInput, bt as MindooDBAppViewCursorDocumentListResult, bu as MindooDBAppViewCursorResult, bv as MindooDBAppViewEntry, bw as MindooDBAppViewEntryKind, bx as MindooDBAppViewNavigator, by as MindooDBAppViewNavigatorExpansionState, bz as MindooDBAppViewNavigatorOpenOptions, bA as MindooDBAppViewNavigatorPageOptions, bB as MindooDBAppViewNavigatorPageResult, bC as MindooDBAppViewNavigatorRangeQuery, bD as MindooDBAppViewNavigatorSelectionState, bE as MindooDBAppViewUpdateStats, bF as MindooDBAppViewport, bG as MindooDBAppWritableAttachmentStream } from './types-c6uTlJnB.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

@@ -910,10 +910,16 @@ var MindooDBAppDatabaseImpl = class {
         docId,
         timestamp
       }),
-      getAtRevision: async (docId, revisionId) => await this.rpc.call("documents.history.getAtRevision", {
+      getAtRevision: async (docId, revisionId, options) => await this.rpc.call("documents.history.getAtRevision", {
         databaseId: this.databaseId,
         docId,
-        revisionId
+        revisionId,
+        phase: options?.phase
+      }),
+      getAtHeads: async (docId, headIds) => await this.rpc.call("documents.history.getAtHeads", {
+        databaseId: this.databaseId,
+        docId,
+        headIds
       }),
       listVerification: async (docId, revisionIds) => await this.rpc.call("documents.history.listVerification", {
         databaseId: this.databaseId,
@@ -1054,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, bx as MindooDBAppViewNavigator, bz as MindooDBAppViewNavigatorOpenOptions, i as MindooDBAppAttachmentApi, ar as MindooDBAppIdentityApi, bn as MindooDBAppTimestampApi, a9 as MindooDBAppDirectoryApi, an as MindooDBAppFulltextSetup, am as MindooDBAppExtractionSetup, a as MindooDBAppBridge, bd as MindooDBAppSession, C as MindooDBAppBridgeRpcRequest, aq as MindooDBAppHostTheme, bF as MindooDBAppViewport, br as MindooDBAppUiPreferences, aQ as MindooDBAppQueryResult, bE as MindooDBAppViewUpdateStats, y as MindooDBAppBridgePortMessage } from '../types-c6uTlJnB.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 {
@@ -1077,6 +1548,16 @@ function createDatabaseHandle(definition) {
         attachments: []
       };
     },
+    async getAtHeads(docId, _headIds) {
+      return {
+        id: docId,
+        timestamp: Date.now(),
+        heads: [],
+        state: "missing",
+        data: null,
+        attachments: []
+      };
+    },
     async listVerification() {
       return [];
     }
@@ -1171,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,
@@ -1216,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);
@@ -1224,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;
@@ -1250,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) {
@@ -1750,7 +2263,13 @@ function createFakeBridgeHost(options = {}) {
       case "documents.history.getAtRevision":
         return await state.getDatabase(String(params.databaseId)).documents.getAtRevision(
           String(params.docId),
-          String(params.revisionId)
+          String(params.revisionId),
+          params.phase === "before" ? { phase: "before" } : void 0
+        );
+      case "documents.history.getAtHeads":
+        return await state.getDatabase(String(params.databaseId)).documents.getAtHeads(
+          String(params.docId),
+          Array.isArray(params.headIds) ? params.headIds.map(String) : []
         );
       case "documents.history.listVerification":
         return await state.getDatabase(String(params.databaseId)).documents.listVerification(
@@ -1815,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),
@@ -2164,7 +2693,9 @@ function createFakeBridgeHost(options = {}) {
   return controller;
 }
 export {
+  createEvaluatingViewNavigator,
   createFakeBridgeHost,
   createMockMindooDBAppBridge,
-  createMockMindooDBAppSession
+  createMockMindooDBAppSession,
+  loadMindoodbForTesting
 };

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

@@ -208,7 +208,29 @@ interface MindooDBAppDocumentHistoryEntry {
     isDeleted: boolean;
     isCurrent: boolean;
     summary?: string;
+    /**
+     * The revisions this one was written on top of — the edges of the signed
+     * change graph, in the same id space as {@link revisionId}. More than one id
+     * means this revision merged concurrent branches.
+     *
+     * A timeline is a linearization of that graph, so an id here may name a
+     * revision the timeline does not list (a change that left the document state
+     * untouched produces no timeline row). Draw only the edges whose endpoints you
+     * have; use {@link MindooDBAppDocumentHistoryApi.getAtHeads} to reconstruct
+     * state from the full list.
+     */
+    dependencyIds?: string[];
 }
+/**
+ * Which side of a revision to read: the state it produced (`after`, the
+ * default), or the state it was written against (`before`).
+ *
+ * `before` is a single document even for a revision that merged several
+ * branches: it is the merge of all its parents, which is what its author had
+ * loaded. For the document's creation there is no prior state, so `before`
+ * reports a `missing` snapshot.
+ */
+type MindooDBAppRevisionPhase = "before" | "after";
 /**
  * The cryptographic record behind one revision, as it sits in the append-only
  * store — what a seal or an audit needs and what {@link MindooDBAppDocumentHistoryEntry}
@@ -1274,8 +1296,26 @@ interface MindooDBAppDocumentApi {
      * identifiers — the preferred way to load historical states and the value
      * to pass to historical attachment APIs. Requires the `history`
      * capability.
+     *
+     * Pass `{ phase: "before" }` to read the state the revision was written
+     * against instead of the state it produced, which is how you show what one
+     * revision changed. See {@link MindooDBAppRevisionPhase}.
+     */
+    getAtRevision(docId: string, revisionId: MindooDBAppDocumentRevisionId, options?: {
+        phase?: MindooDBAppRevisionPhase;
+    }): Promise<MindooDBAppHistoricalDocument>;
+    /**
+     * Read-only snapshot of the document as it stood at a set of concurrent
+     * revisions: the merge of those heads, with nothing that came after them.
+     *
+     * Use it to reconstruct a specific point in the change graph rather than in
+     * the timeline — for example, pass a revision's
+     * {@link MindooDBAppDocumentHistoryEntry.dependencyIds} to see exactly the
+     * document its author was editing. An empty or unresolvable head list means
+     * there was no document yet and reports a `missing` snapshot. Requires the
+     * `history` capability.
      */
-    getAtRevision(docId: string, revisionId: MindooDBAppDocumentRevisionId): Promise<MindooDBAppHistoricalDocument>;
+    getAtHeads(docId: string, headIds: MindooDBAppDocumentRevisionId[]): Promise<MindooDBAppHistoricalDocument>;
     /**
      * The signatures and witness receipts behind a document's revisions —
      * everything {@link listHistory} leaves out because a timeline UI does not
@@ -1693,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
@@ -1738,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 {
@@ -1885,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 MindooDBAppRichTextMarkRange 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 MindooDBAppRevisionVerification as aX, type MindooDBAppRichTextBlockSpan as aY, type MindooDBAppRichTextGetOptions as aZ, type MindooDBAppRichTextImmutableString 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 MindooDBAppRichTextMaterializeValue as b0, type MindooDBAppRichTextPatch as b1, type MindooDBAppRichTextScalar as b2, type MindooDBAppRichTextSpliceStep as b3, type MindooDBAppRichTextStep as b4, type MindooDBAppRichTextStepPatch as b5, type MindooDBAppRichTextTextSpan as b6, type MindooDBAppRuntime as b7, type MindooDBAppScanAttachmentOptions as b8, type MindooDBAppScanAttachmentResult as b9, type MindooDBAppViewNavigatorPageOptions as bA, type MindooDBAppViewNavigatorPageResult as bB, type MindooDBAppViewNavigatorRangeQuery as bC, type MindooDBAppViewNavigatorSelectionState as bD, type MindooDBAppViewUpdateStats as bE, type MindooDBAppViewport as bF, type MindooDBAppWritableAttachmentStream as bG, type MindooDBAppScopedDocId as ba, type MindooDBAppScopedDocumentSummary as bb, type MindooDBAppSealIntent as bc, type MindooDBAppSession as bd, type MindooDBAppShowMenuInput as be, type MindooDBAppShowMenuResult as bf, type MindooDBAppSignPreview as bg, type MindooDBAppSignPreviewScope as bh, type MindooDBAppSignStatementInput as bi, type MindooDBAppSignStatementResult as bj, type MindooDBAppTextEdit as bk, type MindooDBAppTextPatch as bl, type MindooDBAppThemeMode as bm, type MindooDBAppTimestampApi as bn, type MindooDBAppTimestampInput as bo, type MindooDBAppTimestampProvider as bp, type MindooDBAppTimestampResult as bq, type MindooDBAppUiPreferences as br, type MindooDBAppUpdateDocumentInput as bs, type MindooDBAppViewCursorDocumentListResult as bt, type MindooDBAppViewCursorResult as bu, type MindooDBAppViewEntry as bv, type MindooDBAppViewEntryKind as bw, type MindooDBAppViewNavigator as bx, type MindooDBAppViewNavigatorExpansionState as by, type MindooDBAppViewNavigatorOpenOptions 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.33",
+  "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.46",
+    "@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"