mindoodb-app-sdk 0.0.18 → 0.0.19

package/README.md

@@ -390,11 +390,13 @@ Every `MindooDBAppDocument` snapshot also exposes a `heads?: string[]` field. Th
 
 `nextCursor` is the latest checkpoint reached by the page. Persist it after each successful call when you are building your own index or sync loop. If there were no changes after the supplied cursor, `nextCursor` is `null`.
 
-`documents.update()` accepts three independent operations on the same call:
+`documents.update()` accepts five independent kinds of operations on the same call, applied atomically to one new document revision:
 
 - `set` -- assign top-level fields (shallow JSON merge).
 - `unset` -- remove top-level fields entirely.
-- `text` -- one or more **granular text patches** applied to specific JSON paths. Each patch carries the `baseHeads` version it was authored against and is merged on the Haven side with any concurrent changes that arrived since. This is the recommended way to edit collaborative text fields like a markdown body. See [Collaborative text editing](#collaborative-text-editing) below.
+- `json` -- a **granular JSON patch** of `set` / `unset` / `listInsert` / `listDelete` operations applied at specific paths inside `document.data`, against a `baseHeads` version. See [Granular JSON edits](#granular-json-edits) below.
+- `text` -- one or more **granular text patches** applied to specific string paths. Each patch carries the `baseHeads` version it was authored against and is merged on the Haven side with any concurrent changes that arrived since. This is the recommended way to edit collaborative text fields like a markdown body. See [Collaborative text editing](#collaborative-text-editing) below.
+- `richText` -- one or more **rich-text span snapshots** for formatted-document fields (Word/.docx style). See [Collaborative rich-text editing](#collaborative-rich-text-editing) below.
 
 Prefer sending small, intentional field-level changes instead of rewriting whole documents when only a few fields changed. This keeps MindooDB change tracking more meaningful and helps Automerge produce cleaner merge results.
 
@@ -444,6 +446,85 @@ 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`.
 
+### 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.
+
+A JSON patch is a bag of four operation kinds applied at specific JSON paths inside `document.data`, all carried with the document version (`baseHeads`) the app was looking at when it composed them:
+
+- `set` — assign or replace a value at a path
+- `unset` — remove a key (or list entry, when the host accepts it) at a path
+- `listInsert` — splice values into a list at a position
+- `listDelete` — remove a contiguous run of entries from a list
+
+```ts
+interface MindooDBAppJsonSetPatch {
+  path: Array<string | number>;
+  value: unknown;
+}
+
+interface MindooDBAppJsonUnsetPatch {
+  path: Array<string | number>;
+}
+
+interface MindooDBAppJsonListInsertPatch {
+  path: Array<string | number>;
+  index: number;
+  values: unknown[];
+}
+
+interface MindooDBAppJsonListDeletePatch {
+  path: Array<string | number>;
+  index: number;
+  deleteCount: number;
+}
+
+interface MindooDBAppJsonPatch {
+  baseHeads?: string[];
+  set?: MindooDBAppJsonSetPatch[];
+  unset?: MindooDBAppJsonUnsetPatch[];
+  listInsert?: MindooDBAppJsonListInsertPatch[];
+  listDelete?: MindooDBAppJsonListDeletePatch[];
+}
+```
+
+Send the patch through `documents.update({ json })`:
+
+```ts
+const doc = await db.documents.get(docId);
+
+await db.documents.update(docId, {
+  json: {
+    baseHeads: doc!.heads,
+    set: [
+      { path: ["worksheets", "ws-1", "title"], value: "Q1 numbers" },
+      {
+        path: ["worksheets", "ws-1", "cellsByRowCol", "row-3:col-2", "value"],
+        value: 42,
+      },
+    ],
+    listInsert: [
+      {
+        path: ["worksheets", "ws-1", "rowOrder"],
+        index: 5,
+        values: ["row-new"],
+      },
+    ],
+    listDelete: [
+      {
+        path: ["worksheets", "ws-1", "tombstoneRows"],
+        index: 0,
+        deleteCount: 1,
+      },
+    ],
+  },
+});
+```
+
+Haven applies the patch causally at `baseHeads` and merges it with any concurrent changes that arrived since, the same way the text and rich-text APIs do. List inserts authored against the same `baseHeads` interleave cleanly via Automerge's list CRDT instead of overwriting each other — which is exactly what makes two users inserting different rows on the same worksheet at the same time merge into a consistent grid rather than a last-writer-wins.
+
+Patch flavors compose. `set`/`unset` (top-level fields), `json`, `text`, and `richText` can all appear in the same `documents.update()` call and are applied atomically to one new document revision. Prefer small, intentional operations over whole-document rewrites so MindooDB change tracking stays meaningful and Automerge produces cleaner merges.
+
 ### Collaborative text editing
 
 MindooDB stores collaborative text fields as Automerge text CRDTs internally, but apps never touch Automerge directly -- the SDK bridge is JSON-only. Instead, your app describes text changes as **granular splice operations** against a known document version, and Haven applies and merges them on its side.
@@ -579,6 +660,120 @@ Buffer API at a glance:
 
 The [`mindoodb-app-teamedit`](https://github.com/klehmann/mindoodb-app-teamedit) sample wires `MindooDBTextBuffer` to a Milkdown markdown editor with Save / Refresh / preview pane, and is the recommended starting point for building your own collaborative text app.
 
+### Collaborative rich-text editing
+
+For structured documents that need formatting — headings, bold/italic runs, lists, tables, fonts, colors — use the **rich-text patch API**. This is the surface behind the Word/.docx mode in [`mindoodb-app-teamedit`](https://github.com/klehmann/mindoodb-app-teamedit), where two users can edit the same document at the same time and Haven merges both formatting and structure on its side via Automerge's rich-text CRDT.
+
+Rich-text fields are stored internally as Automerge rich-text, but apps never see Automerge directly. The bridge speaks JSON and represents a rich-text field as an ordered list of **spans** — text runs with marks for inline formatting, plus block markers for paragraphs, headings, lists, and tables:
+
+```ts
+interface MindooDBAppRichTextTextSpan {
+  type: "text";
+  value: string;
+  // Inline marks: bold, italic, underline, font, color, link, ...
+  marks?: Record<string, MindooDBAppRichTextMaterializeValue>;
+}
+
+interface MindooDBAppRichTextBlockSpan {
+  type: "block";
+  // Block markers: paragraph, heading, list item, table cell, ...
+  value: Record<string, MindooDBAppRichTextMaterializeValue>;
+}
+
+type MindooDBAppRichTextSpan =
+  | MindooDBAppRichTextTextSpan
+  | MindooDBAppRichTextBlockSpan;
+```
+
+#### Reading the current spans
+
+```ts
+const snapshot = await db.documents.getRichText(docId, ["body"]);
+// snapshot = { path: ["body"], heads: ["<commit>"], spans: [...] }
+
+editor.loadFromSpans(snapshot.spans);
+```
+
+`getRichText(docId, path, options?)` also accepts `{ revisionId }` so you can load the rich-text spans of an exact historical document revision (handy for read-only revision pickers).
+
+#### Writing back a span snapshot
+
+The simplest write is a full snapshot — replace the field's spans with the editor's current state:
+
+```ts
+await db.documents.update(docId, {
+  richText: [
+    {
+      path: ["body"],
+      baseHeads: snapshot.heads,
+      spans: editor.toSpans(),
+    },
+  ],
+});
+```
+
+Haven applies the snapshot via Automerge's `updateSpans` and merges it with any concurrent rich-text changes that arrived since `baseHeads`. The optional `updateSpansConfig` field is forwarded to Automerge for editors that need to tune merge behavior at the span level.
+
+#### High-level: `createMindooDBRichTextHandle`
+
+For editors that emit a complete spans array after each transaction, the SDK ships a buffer helper that mirrors `MindooDBTextBuffer`:
+
+```ts
+import { createMindooDBRichTextHandle } from "mindoodb-app-sdk";
+
+const doc = await db.documents.get(docId);
+const initial = await db.documents.getRichText(doc!.id, ["body"]);
+
+const handle = createMindooDBRichTextHandle({
+  database: db,
+  document: doc!,
+  path: ["body"],
+  spans: initial.spans,
+});
+
+editor.loadFromSpans(handle.spans);
+
+// Editor reports a fresh spans array after every change.
+editor.on("change", (spans) => {
+  handle.replaceSpans(spans);
+});
+
+// On save (e.g. Cmd+S) flush the local snapshot to Haven.
+async function save() {
+  const result = await handle.flush();
+  if (result.reconciled) {
+    // Haven merged in concurrent rich-text edits; show the canonical merged spans.
+    editor.loadFromSpans(result.snapshot.spans);
+  }
+}
+
+// Optional: poll for remote changes while the editor is idle.
+handle.startPolling(2000);
+handle.on("change", (snapshot) => {
+  if (!handle.dirty) editor.loadFromSpans(snapshot.spans);
+});
+```
+
+Handle API at a glance:
+
+| Member                               | Description                                                                   |
+| ------------------------------------ | ----------------------------------------------------------------------------- |
+| `spans`                              | Current local span snapshot                                                   |
+| `dirty`                              | Whether local edits are buffered                                              |
+| `baseHeads`                          | Heads the local snapshot was authored against                                 |
+| `replaceSpans(spans)`                | Replace the local spans buffer with a fresh snapshot                          |
+| `refresh()`                          | Re-read `getRichText` and return the canonical snapshot                       |
+| `pollOnce()`                         | Re-read and reconcile if the document advanced and there are no local edits  |
+| `startPolling(ms)` / `stopPolling()` | Poll `pollOnce` on a timer                                                    |
+| `flush(updateSpansConfig?)`          | Send pending spans to Haven; resolves to `{ document, snapshot, reconciled }` |
+| `on/off("change", listener)`         | Subscribe to local or reconciled-change events                                |
+
+Like the text buffer, the rich-text handle always sends the original `baseHeads` captured when it was created or last reconciled, so two windows editing the same document at the same heads merge correctly without overwriting each other.
+
+#### End-to-end sample
+
+The Word/.docx mode in [`mindoodb-app-teamedit`](https://github.com/klehmann/mindoodb-app-teamedit) wires `MindooDBRichTextHandle` to an `@eigenpal/docx-editor-vue` editor and is the recommended starting point for building your own collaborative rich-text app.
+
 ### Incremental sync
 
 The changefeed-backed `documents.list()` API is also the right primitive for app-side indexes, search, and other derived caches.
@@ -675,12 +870,41 @@ const scan = await db.attachments.scan(docId, {
   preset: "a4-portrait",
   mimeType: "application/pdf",
 });
+// scan = { ok: true, attachment: { attachmentId, fileName, mimeType, size } }
+//   or { ok: false }                    if the user cancelled the scanner
+//   or rejected with an error           if the host has no scanner UI
 
 // Remove
 await db.attachments.remove(docId, "old-file.txt");
 ```
 
-`attachments.scan()` asks Haven to open its document scanner UI. Haven handles camera/file selection, edge detection, manual corner correction, output sizing, and filename confirmation, then writes the resulting image as a normal attachment. Hosts that do not provide scanner UI may reject this method or return `{ ok: false }`.
+`attachments.scan()` asks Haven to open its document scanner UI on top of your app. Haven handles camera or file selection, runs edge detection through a slim on-device OpenCV WebAssembly pipeline, lets the user fine-tune the corners, applies the perspective correction to the chosen output size, and writes the resulting bytes as a normal MindooDoc attachment via the same path `openWriteStream` would have taken. The scanner runs entirely locally — the picked image and the perspective-corrected result never leave the browser tab.
+
+Options shape:
+
+```ts
+type MindooDBAppDocumentScanPreset =
+  | "auto"            // free-form, keep the detected aspect ratio
+  | "a4-portrait"
+  | "a4-landscape"
+  | "letter-portrait"
+  | "letter-landscape";
+
+interface MindooDBAppScanAttachmentOptions {
+  defaultFileName?: string;                                  // suggested filename in the dialog
+  preset?: MindooDBAppDocumentScanPreset;                    // output page geometry
+  mimeType?: "image/jpeg" | "image/png" | "application/pdf"; // output format
+}
+
+interface MindooDBAppScanAttachmentResult {
+  ok: boolean;
+  attachment?: MindooDBAppAttachmentInfo | null;
+}
+```
+
+Apps need both the `attachments` and `update` capabilities for this method, because the scanner writes the resulting bytes back to the document. Hosts that do not provide scanner UI may reject this method or return `{ ok: false }`.
+
+The same scanner is also reachable as a top-level **Quick Scan** entry in Haven's sidebar. There it runs detached from any document — the user can download the resulting file or hand it to the operating system's share sheet, but the "Add to document" action is hidden because there is no document context. Apps do not need to do anything to support this; it is part of Haven, not the SDK.
 
 For historical reads, pass the same `revisionId` you received from `documents.listHistory()` or from a `MindooDBAppHistoricalDocument`. This tells Haven to resolve the attachment from that revision's document payload instead of the latest document state:
 
@@ -983,6 +1207,7 @@ Connect options: `launchId?`, `targetOrigin?`, `connectTimeoutMs?`.
 | ---------------------------------- | -------------------------------------------- |
 | `list(query?)`                     | `Promise<MindooDBAppDocumentListResult>`     |
 | `get(docId)`                       | `Promise<MindooDBAppDocument \| null>`       |
+| `getRichText(docId, path, opts?)`  | `Promise<MindooDBAppRichTextSnapshot>`       |
 | `create(input)`                    | `Promise<MindooDBAppDocument>`               |
 | `update(docId, patch)`             | `Promise<MindooDBAppDocument>`               |
 | `delete(docId)`                    | `Promise<{ ok: true }>`                      |
@@ -1003,11 +1228,13 @@ For `update(docId, patch)`, use `MindooDBAppUpdateDocumentInput`:
 interface MindooDBAppUpdateDocumentInput {
   set?: Record<string, unknown>; // shallow assign top-level fields
   unset?: string[]; // remove top-level fields entirely
+  json?: MindooDBAppJsonPatch; // granular structured edits at JSON paths
   text?: MindooDBAppTextPatch[]; // granular collaborative text edits
+  richText?: MindooDBAppRichTextPatch[]; // collaborative rich-text span snapshots
 }
 ```
 
-`set` and `unset` apply to top-level fields only. `text` patches operate on string fields at any JSON path inside `document.data` and are merged on the Haven side using the document's Automerge heads. See [Collaborative text editing](#collaborative-text-editing).
+`set` and `unset` apply to top-level fields only. `json`, `text`, and `richText` patches operate at any JSON path inside `document.data` and are merged on the Haven side using the document's Automerge heads. See [Granular JSON edits](#granular-json-edits), [Collaborative text editing](#collaborative-text-editing), and [Collaborative rich-text editing](#collaborative-rich-text-editing).
 
 ### MindooDBAppAttachmentApi
 
@@ -1070,6 +1297,7 @@ interface MindooDBAppUpdateDocumentInput {
 | ------------------------------------------ | ------------------------------------------------------------------------------------------- |
 | `createMindooDBAppBridge()`                | Create the bridge object used to connect to Haven                                           |
 | `createMindooDBTextBuffer(options)`        | Create an editor-friendly buffer for granular collaborative text edits on a document field  |
+| `createMindooDBRichTextHandle(options)`    | Create an editor-friendly handle for collaborative rich-text span snapshots on a document field |
 | `canPreviewAttachment(fileName, mimeType)` | Check if Haven can preview a file (returns mode or `null`)                                  |
 | `createViewLanguage<T>()`                  | Create a typed expression builder for view definitions                                      |
 | `abbreviateCanonicalName(value)`           | Convert a canonical Notes-style name like `cn=Jane/ou=Dev/o=Mindoo` to `Jane/Dev/Mindoo`    |

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { M as MindooDBAppAttachmentPreviewMode, a as MindooDBAppBridge, b as MindooDBAppDatabase, c as MindooDBAppDocument } from './types-jzokkBX5.js';
-export { d as MindooDBAppAttachmentApi, e as MindooDBAppAttachmentChunk, f as MindooDBAppAttachmentInfo, g as MindooDBAppAttachmentPreviewOptions, h as MindooDBAppAttachmentPreviewSession, i as MindooDBAppBridgeConnectMessage, j as MindooDBAppBridgeConnectOptions, k as MindooDBAppBridgeConnectedMessage, l as MindooDBAppBridgeErrorPayload, m as MindooDBAppBridgeHandshakeErrorMessage, n as MindooDBAppBridgePortMessage, o as MindooDBAppBridgeRpcError, p as MindooDBAppBridgeRpcMessage, q as MindooDBAppBridgeRpcRequest, r as MindooDBAppBridgeRpcSuccess, s as MindooDBAppBridgeStreamAbortRequest, t as MindooDBAppBridgeStreamAck, u as MindooDBAppBridgeStreamCloseRequest, v as MindooDBAppBridgeStreamError, w as MindooDBAppBridgeStreamMessage, x as MindooDBAppBridgeStreamOpenResult, y as MindooDBAppBridgeStreamReadRequest, z as MindooDBAppBridgeStreamWriteRequest, A as MindooDBAppBridgeThemeChangedMessage, B as MindooDBAppBridgeUiPreferencesChangedMessage, C as MindooDBAppBridgeViewportChangedMessage, D as MindooDBAppCapability, E as MindooDBAppConfiguredViewCategorizationStyle, F as MindooDBAppConfiguredViewColumn, G as MindooDBAppConfiguredViewColumnRole, H as MindooDBAppConfiguredViewExpressionMode, I as MindooDBAppConfiguredViewFieldExpression, J as MindooDBAppConfiguredViewFilterDefinition, K as MindooDBAppConfiguredViewFilterMode, L as MindooDBAppConfiguredViewFilterRule, N as MindooDBAppConfiguredViewFormulaExpression, O as MindooDBAppConfiguredViewFormulaFilterDefinition, P as MindooDBAppConfiguredViewPreviewMode, Q as MindooDBAppConfiguredViewRuleFilterDefinition, R as MindooDBAppConfiguredViewRuleMatchMode, S as MindooDBAppConfiguredViewRuleOperator, T as MindooDBAppConfiguredViewValueExpression, U as MindooDBAppCreateDocumentInput, V as MindooDBAppCreateViewInput, W as MindooDBAppCreateViewNavigatorInput, X as MindooDBAppDatabaseInfo, Y as MindooDBAppDocumentApi, Z as MindooDBAppDocumentHeadCursorResult, _ as MindooDBAppDocumentHistoryEntry, $ as MindooDBAppDocumentListQuery, a0 as MindooDBAppDocumentListResult, a1 as MindooDBAppDocumentRevisionId, a2 as MindooDBAppDocumentScanPreset, a3 as MindooDBAppDocumentSummary, a4 as MindooDBAppHistoricalDocument, a5 as MindooDBAppHistoryQuery, a6 as MindooDBAppHostTheme, a7 as MindooDBAppJsonListDeletePatch, a8 as MindooDBAppJsonListInsertPatch, a9 as MindooDBAppJsonPatch, aa as MindooDBAppJsonSetPatch, ab as MindooDBAppJsonUnsetPatch, ac as MindooDBAppLaunchContext, ad as MindooDBAppMenuAnchor, ae as MindooDBAppMenuApi, af as MindooDBAppMenuCommandItem, ag as MindooDBAppMenuDismissReason, ah as MindooDBAppMenuDismissedResult, ai as MindooDBAppMenuItem, aj as MindooDBAppMenuKind, ak as MindooDBAppMenuPlacement, al as MindooDBAppMenuPointAnchor, am as MindooDBAppMenuRect, an as MindooDBAppMenuRectAnchor, ao as MindooDBAppMenuSelectionResult, ap as MindooDBAppMenuSeparatorItem, aq as MindooDBAppReadableAttachmentStream, ar as MindooDBAppResolvedViewDefinition, as as MindooDBAppResolvedViewSource, at as MindooDBAppRuntime, au as MindooDBAppScanAttachmentOptions, av as MindooDBAppScanAttachmentResult, aw as MindooDBAppScopedDocId, ax as MindooDBAppScopedDocumentSummary, ay as MindooDBAppSession, az as MindooDBAppShowMenuInput, aA as MindooDBAppShowMenuResult, aB as MindooDBAppTextEdit, aC as MindooDBAppTextPatch, aD as MindooDBAppThemeMode, aE as MindooDBAppUiPreferences, aF as MindooDBAppUpdateDocumentInput, aG as MindooDBAppViewCursorDocumentListResult, aH as MindooDBAppViewCursorResult, aI as MindooDBAppViewEntry, aJ as MindooDBAppViewEntryKind, aK as MindooDBAppViewNavigator, aL as MindooDBAppViewNavigatorExpansionState, aM as MindooDBAppViewNavigatorOpenOptions, aN as MindooDBAppViewNavigatorPageOptions, aO as MindooDBAppViewNavigatorPageResult, aP as MindooDBAppViewNavigatorRangeQuery, aQ as MindooDBAppViewNavigatorSelectionState, aR as MindooDBAppViewport, aS as MindooDBAppWritableAttachmentStream } from './types-jzokkBX5.js';
+import { M as MindooDBAppAttachmentPreviewMode, a as MindooDBAppBridge, b as MindooDBAppDatabase, c as MindooDBAppDocument, d as MindooDBAppRichTextSpan, e as MindooDBAppRichTextSnapshot } from './types-nFt-aryL.js';
+export { f as MindooDBAppAttachmentApi, g as MindooDBAppAttachmentChunk, h as MindooDBAppAttachmentInfo, i as MindooDBAppAttachmentPreviewOptions, j as MindooDBAppAttachmentPreviewSession, k as MindooDBAppBridgeConnectMessage, l as MindooDBAppBridgeConnectOptions, m as MindooDBAppBridgeConnectedMessage, n as MindooDBAppBridgeErrorPayload, o as MindooDBAppBridgeHandshakeErrorMessage, p as MindooDBAppBridgePortMessage, q as MindooDBAppBridgeRpcError, r as MindooDBAppBridgeRpcMessage, s as MindooDBAppBridgeRpcRequest, t as MindooDBAppBridgeRpcSuccess, u as MindooDBAppBridgeStreamAbortRequest, v as MindooDBAppBridgeStreamAck, w as MindooDBAppBridgeStreamCloseRequest, x as MindooDBAppBridgeStreamError, y as MindooDBAppBridgeStreamMessage, z as MindooDBAppBridgeStreamOpenResult, A as MindooDBAppBridgeStreamReadRequest, B as MindooDBAppBridgeStreamWriteRequest, C as MindooDBAppBridgeThemeChangedMessage, D as MindooDBAppBridgeUiPreferencesChangedMessage, E as MindooDBAppBridgeViewportChangedMessage, F as MindooDBAppCapability, G as MindooDBAppConfiguredViewCategorizationStyle, H as MindooDBAppConfiguredViewColumn, I as MindooDBAppConfiguredViewColumnRole, J as MindooDBAppConfiguredViewExpressionMode, K as MindooDBAppConfiguredViewFieldExpression, L as MindooDBAppConfiguredViewFilterDefinition, N as MindooDBAppConfiguredViewFilterMode, O as MindooDBAppConfiguredViewFilterRule, P as MindooDBAppConfiguredViewFormulaExpression, Q as MindooDBAppConfiguredViewFormulaFilterDefinition, R as MindooDBAppConfiguredViewPreviewMode, S as MindooDBAppConfiguredViewRuleFilterDefinition, T as MindooDBAppConfiguredViewRuleMatchMode, U as MindooDBAppConfiguredViewRuleOperator, V as MindooDBAppConfiguredViewValueExpression, W as MindooDBAppCreateDocumentInput, X as MindooDBAppCreateViewInput, Y as MindooDBAppCreateViewNavigatorInput, Z as MindooDBAppDatabaseInfo, _ as MindooDBAppDocumentApi, $ as MindooDBAppDocumentHeadCursorResult, a0 as MindooDBAppDocumentHistoryEntry, a1 as MindooDBAppDocumentListQuery, a2 as MindooDBAppDocumentListResult, a3 as MindooDBAppDocumentRevisionId, a4 as MindooDBAppDocumentScanPreset, a5 as MindooDBAppDocumentSummary, a6 as MindooDBAppHistoricalDocument, a7 as MindooDBAppHistoryQuery, a8 as MindooDBAppHostTheme, a9 as MindooDBAppJsonListDeletePatch, aa as MindooDBAppJsonListInsertPatch, ab as MindooDBAppJsonPatch, ac as MindooDBAppJsonSetPatch, ad as MindooDBAppJsonUnsetPatch, ae as MindooDBAppLaunchContext, 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 MindooDBAppReadableAttachmentStream, at as MindooDBAppResolvedViewDefinition, au as MindooDBAppResolvedViewSource, av as MindooDBAppRichTextBlockSpan, aw as MindooDBAppRichTextGetOptions, ax as MindooDBAppRichTextImmutableString, ay as MindooDBAppRichTextMaterializeValue, az as MindooDBAppRichTextPatch, aA as MindooDBAppRichTextScalar, aB as MindooDBAppRichTextTextSpan, aC as MindooDBAppRuntime, aD as MindooDBAppScanAttachmentOptions, aE as MindooDBAppScanAttachmentResult, aF as MindooDBAppScopedDocId, aG as MindooDBAppScopedDocumentSummary, aH as MindooDBAppSession, aI as MindooDBAppShowMenuInput, aJ as MindooDBAppShowMenuResult, aK as MindooDBAppTextEdit, aL as MindooDBAppTextPatch, aM as MindooDBAppThemeMode, aN as MindooDBAppUiPreferences, aO as MindooDBAppUpdateDocumentInput, aP as MindooDBAppViewCursorDocumentListResult, aQ as MindooDBAppViewCursorResult, aR as MindooDBAppViewEntry, aS as MindooDBAppViewEntryKind, aT as MindooDBAppViewNavigator, aU as MindooDBAppViewNavigatorExpansionState, aV as MindooDBAppViewNavigatorOpenOptions, aW as MindooDBAppViewNavigatorPageOptions, aX as MindooDBAppViewNavigatorPageResult, aY as MindooDBAppViewNavigatorRangeQuery, aZ as MindooDBAppViewNavigatorSelectionState, a_ as MindooDBAppViewport, a$ as MindooDBAppWritableAttachmentStream } from './types-nFt-aryL.js';
 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';
 
 /**
@@ -37,6 +37,50 @@ declare function expandAbbreviatedName(value: string): string;
  */
 declare function createMindooDBAppBridge(): MindooDBAppBridge;
 
+interface CreateMindooDBRichTextHandleOptions {
+    database: MindooDBAppDatabase;
+    document: MindooDBAppDocument;
+    path: Array<string | number>;
+    spans?: MindooDBAppRichTextSpan[];
+    pollIntervalMs?: number;
+}
+interface MindooDBRichTextHandleFlushResult {
+    document: MindooDBAppDocument;
+    snapshot: MindooDBAppRichTextSnapshot;
+    reconciled: boolean;
+}
+type MindooDBRichTextHandleChangeListener = (snapshot: MindooDBAppRichTextSnapshot) => void;
+/**
+ * Local rich-text span buffer for SDK apps.
+ *
+ * The helper deliberately mirrors the causal shape of `MindooDBTextBuffer`:
+ * local editor code replaces the current span snapshot, then `flush()` sends a
+ * separate `richText` patch with the document heads the snapshot was based on.
+ */
+declare class MindooDBRichTextHandle {
+    private readonly options;
+    private spansInternal;
+    private heads;
+    private dirtyInternal;
+    private listeners;
+    private pollTimer;
+    constructor(options: CreateMindooDBRichTextHandleOptions);
+    get spans(): MindooDBAppRichTextSpan[];
+    get dirty(): boolean;
+    get baseHeads(): string[];
+    on(event: "change", listener: MindooDBRichTextHandleChangeListener): void;
+    off(event: "change", listener: MindooDBRichTextHandleChangeListener): void;
+    replaceSpans(spans: MindooDBAppRichTextSpan[]): void;
+    startPolling(intervalMs?: number): void;
+    stopPolling(): void;
+    reconcile(document: MindooDBAppDocument, snapshot: MindooDBAppRichTextSnapshot): boolean;
+    refresh(): Promise<MindooDBAppRichTextSnapshot>;
+    pollOnce(): Promise<boolean>;
+    flush(updateSpansConfig?: Record<string, unknown>): Promise<MindooDBRichTextHandleFlushResult>;
+    private emitChange;
+}
+declare function createMindooDBRichTextHandle(options: CreateMindooDBRichTextHandleOptions): MindooDBRichTextHandle;
+
 /**
  * Options used to create a text buffer for one string field in a MindooDB
  * document.
@@ -130,4 +174,4 @@ declare class MindooDBTextBuffer {
 /** Create a local text buffer for one string field in a document. */
 declare function createMindooDBTextBuffer(options: CreateMindooDBTextBufferOptions): MindooDBTextBuffer;
 
-export { type CreateMindooDBTextBufferOptions, MindooDBAppAttachmentPreviewMode, MindooDBAppBridge, MindooDBAppDatabase, MindooDBAppDocument, MindooDBTextBuffer, type MindooDBTextBufferFlushResult, abbreviateCanonicalName, canPreviewAttachment, createMindooDBAppBridge, createMindooDBTextBuffer, expandAbbreviatedName };
+export { type CreateMindooDBRichTextHandleOptions, type CreateMindooDBTextBufferOptions, MindooDBAppAttachmentPreviewMode, MindooDBAppBridge, MindooDBAppDatabase, MindooDBAppDocument, MindooDBAppRichTextSnapshot, MindooDBAppRichTextSpan, MindooDBRichTextHandle, type MindooDBRichTextHandleChangeListener, type MindooDBRichTextHandleFlushResult, MindooDBTextBuffer, type MindooDBTextBufferFlushResult, abbreviateCanonicalName, canPreviewAttachment, createMindooDBAppBridge, createMindooDBRichTextHandle, createMindooDBTextBuffer, expandAbbreviatedName };

package/dist/index.js

@@ -726,6 +726,12 @@ var MindooDBAppDatabaseImpl = class {
         databaseId: this.databaseId,
         docId
       }),
+      getRichText: async (docId, path, options) => await this.rpc.call("documents.richText.get", {
+        databaseId: this.databaseId,
+        docId,
+        path,
+        revisionId: options?.revisionId
+      }),
       create: async (input) => await this.rpc.call("documents.create", {
         databaseId: this.databaseId,
         input
@@ -987,6 +993,141 @@ function createMindooDBAppBridge() {
   };
 }
 
+// src/richTextHandle.ts
+var MindooDBRichTextHandle = class {
+  constructor(options) {
+    this.options = options;
+    this.spansInternal = cloneSpans(options.spans ?? []);
+    this.heads = options.document.heads ? [...options.document.heads] : [];
+  }
+  options;
+  spansInternal;
+  heads;
+  dirtyInternal = false;
+  listeners = /* @__PURE__ */ new Set();
+  pollTimer = null;
+  get spans() {
+    return cloneSpans(this.spansInternal);
+  }
+  get dirty() {
+    return this.dirtyInternal;
+  }
+  get baseHeads() {
+    return [...this.heads];
+  }
+  on(event, listener) {
+    this.listeners.add(listener);
+  }
+  off(event, listener) {
+    this.listeners.delete(listener);
+  }
+  replaceSpans(spans) {
+    this.spansInternal = cloneSpans(spans);
+    this.dirtyInternal = true;
+    this.emitChange();
+  }
+  startPolling(intervalMs = this.options.pollIntervalMs ?? 2e3) {
+    this.stopPolling();
+    this.pollTimer = setInterval(() => {
+      void this.pollOnce();
+    }, intervalMs);
+  }
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  reconcile(document, snapshot) {
+    const previous = JSON.stringify(this.spansInternal);
+    this.spansInternal = cloneSpans(snapshot.spans);
+    this.heads = snapshot.heads ?? document.heads ?? [];
+    this.dirtyInternal = false;
+    const changed = JSON.stringify(this.spansInternal) !== previous;
+    if (changed) {
+      this.emitChange();
+    }
+    return changed;
+  }
+  async refresh() {
+    const snapshot = await this.options.database.documents.getRichText(
+      this.options.document.id,
+      this.options.path
+    );
+    return snapshot;
+  }
+  async pollOnce() {
+    if (this.dirtyInternal) {
+      return false;
+    }
+    const document = await this.options.database.documents.get(
+      this.options.document.id
+    );
+    if (!document) {
+      return false;
+    }
+    const snapshot = await this.refresh();
+    return this.reconcile(document, snapshot);
+  }
+  async flush(updateSpansConfig) {
+    if (!this.dirtyInternal) {
+      return {
+        document: this.options.document,
+        snapshot: {
+          path: [...this.options.path],
+          heads: [...this.heads],
+          spans: cloneSpans(this.spansInternal)
+        },
+        reconciled: false
+      };
+    }
+    const localSpansAtFlush = JSON.stringify(this.spansInternal);
+    const document = await this.options.database.documents.update(
+      this.options.document.id,
+      {
+        richText: [{
+          path: this.options.path,
+          baseHeads: this.heads,
+          spans: cloneSpans(this.spansInternal),
+          updateSpansConfig
+        }]
+      }
+    );
+    const snapshot = await this.options.database.documents.getRichText(
+      this.options.document.id,
+      this.options.path
+    );
+    const reconciled = JSON.stringify(snapshot.spans) !== localSpansAtFlush;
+    this.spansInternal = cloneSpans(snapshot.spans);
+    this.heads = snapshot.heads ?? document.heads ?? [];
+    this.dirtyInternal = false;
+    if (reconciled) {
+      this.emitChange();
+    }
+    return {
+      document,
+      snapshot,
+      reconciled
+    };
+  }
+  emitChange() {
+    const snapshot = {
+      path: [...this.options.path],
+      heads: [...this.heads],
+      spans: cloneSpans(this.spansInternal)
+    };
+    for (const listener of this.listeners) {
+      listener(snapshot);
+    }
+  }
+};
+function createMindooDBRichTextHandle(options) {
+  return new MindooDBRichTextHandle(options);
+}
+function cloneSpans(spans) {
+  return structuredClone(spans);
+}
+
 // src/textBuffer.ts
 var MindooDBTextBuffer = class {
   constructor(options) {
@@ -1135,10 +1276,12 @@ import {
   mindooDBViewLanguageHelpersByName
 } from "mindoodb-view-language";
 export {
+  MindooDBRichTextHandle,
   MindooDBTextBuffer,
   abbreviateCanonicalName,
   canPreviewAttachment,
   createMindooDBAppBridge,
+  createMindooDBRichTextHandle,
   createMindooDBTextBuffer,
   createViewLanguage,
   expandAbbreviatedName

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { ac as MindooDBAppLaunchContext, X as MindooDBAppDatabaseInfo, Y as MindooDBAppDocumentApi, W as MindooDBAppCreateViewNavigatorInput, aK as MindooDBAppViewNavigator, aM as MindooDBAppViewNavigatorOpenOptions, d as MindooDBAppAttachmentApi, a as MindooDBAppBridge, ay as MindooDBAppSession, q as MindooDBAppBridgeRpcRequest, a6 as MindooDBAppHostTheme, aR as MindooDBAppViewport, aE as MindooDBAppUiPreferences, n as MindooDBAppBridgePortMessage } from '../types-jzokkBX5.js';
+import { ae as MindooDBAppLaunchContext, Z as MindooDBAppDatabaseInfo, _ as MindooDBAppDocumentApi, Y as MindooDBAppCreateViewNavigatorInput, aT as MindooDBAppViewNavigator, aV as MindooDBAppViewNavigatorOpenOptions, f as MindooDBAppAttachmentApi, a as MindooDBAppBridge, aH as MindooDBAppSession, s as MindooDBAppBridgeRpcRequest, a8 as MindooDBAppHostTheme, a_ as MindooDBAppViewport, aN as MindooDBAppUiPreferences, p as MindooDBAppBridgePortMessage } from '../types-nFt-aryL.js';
 import 'mindoodb-view-language';
 
 type MaybePromise<T> = T | Promise<T>;

package/dist/testing/index.js

@@ -26,6 +26,9 @@ function applyDocumentUpdatePatch(current, patch) {
   for (const textPatch of patch.text ?? []) {
     applyMockTextPatch(next, textPatch.path, textPatch.edits);
   }
+  for (const richTextPatch of patch.richText ?? []) {
+    setValueAtPath(next, richTextPatch.path, structuredClone(richTextPatch.spans));
+  }
   return next;
 }
 function applyMockJsonPatch(target, patch) {
@@ -125,6 +128,16 @@ function applyMockTextPatch(target, path, edits) {
   }
   parent[leaf] = value;
 }
+function readRichTextSpansAtPath(target, path) {
+  let value = target;
+  for (const segment of path) {
+    if (value == null || typeof value !== "object") {
+      return [];
+    }
+    value = value[segment];
+  }
+  return Array.isArray(value) ? value : [];
+}
 function mergeLaunchContext(current, patch) {
   if (!patch) {
     return {
@@ -567,6 +580,17 @@ function createDatabaseHandle(definition) {
         updatedAt: document.updatedAt
       };
     },
+    async getRichText(docId, path, _options) {
+      const document = storedDocuments.get(docId);
+      if (!document || document.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      return {
+        path: [...path],
+        heads: document.heads ? [...document.heads] : void 0,
+        spans: structuredClone(readRichTextSpansAtPath(document.data, path))
+      };
+    },
     async create(input) {
       const callerId = typeof input.id === "string" && input.id.length > 0 ? input.id : null;
       if (callerId) {
@@ -1140,6 +1164,11 @@ function createFakeBridgeHost(options = {}) {
         return await state.getDatabase(String(params.databaseId)).documents.getHeadCursor();
       case "documents.get":
         return await state.getDatabase(String(params.databaseId)).documents.get(String(params.docId));
+      case "documents.richText.get":
+        return await state.getDatabase(String(params.databaseId)).documents.getRichText(
+          String(params.docId),
+          params.path
+        );
       case "documents.create":
         return await state.getDatabase(String(params.databaseId)).documents.create(
           params.input

package/dist/{types-jzokkBX5.d.ts → types-nFt-aryL.d.ts}

@@ -277,6 +277,43 @@ interface MindooDBAppTextPatch {
     baseHeads?: string[];
     edits: MindooDBAppTextEdit[];
 }
+type MindooDBAppRichTextScalar = string | number | boolean | null;
+interface MindooDBAppRichTextImmutableString {
+    type: "immutableString";
+    value: string;
+}
+type MindooDBAppRichTextMaterializeValue = MindooDBAppRichTextScalar | MindooDBAppRichTextImmutableString | MindooDBAppRichTextMaterializeValue[] | {
+    [key: string]: MindooDBAppRichTextMaterializeValue;
+};
+interface MindooDBAppRichTextTextSpan {
+    type: "text";
+    value: string;
+    marks?: Record<string, MindooDBAppRichTextMaterializeValue>;
+}
+interface MindooDBAppRichTextBlockSpan {
+    type: "block";
+    value: Record<string, MindooDBAppRichTextMaterializeValue>;
+}
+type MindooDBAppRichTextSpan = MindooDBAppRichTextTextSpan | MindooDBAppRichTextBlockSpan;
+interface MindooDBAppRichTextPatch {
+    /** Path to the Automerge rich-text field inside the document payload. */
+    path: Array<string | number>;
+    /** Automerge heads of the document state this rich-text snapshot was based on. */
+    baseHeads?: string[];
+    /** Full JSON-safe span snapshot to apply with Automerge `updateSpans`. */
+    spans: MindooDBAppRichTextSpan[];
+    /** Optional Automerge `updateSpans` configuration, kept JSON-safe over the bridge. */
+    updateSpansConfig?: Record<string, unknown>;
+}
+interface MindooDBAppRichTextSnapshot {
+    path: Array<string | number>;
+    heads?: string[];
+    spans: MindooDBAppRichTextSpan[];
+}
+interface MindooDBAppRichTextGetOptions {
+    /** Stable revision id previously obtained from `documents.listHistory()`. */
+    revisionId?: MindooDBAppDocumentRevisionId;
+}
 /**
  * Sets the value at `path` inside the document payload.
  *
@@ -347,6 +384,8 @@ interface MindooDBAppUpdateDocumentInput {
     json?: MindooDBAppJsonPatch;
     /** Granular text edits to apply at document paths. */
     text?: MindooDBAppTextPatch[];
+    /** Rich-text span snapshots to apply at document paths. */
+    richText?: MindooDBAppRichTextPatch[];
 }
 /** Query used for history lookups at a specific timestamp. */
 interface MindooDBAppHistoryQuery {
@@ -560,6 +599,7 @@ interface MindooDBAppDocumentApi {
     list(query?: MindooDBAppDocumentListQuery): Promise<MindooDBAppDocumentListResult>;
     getHeadCursor(): Promise<MindooDBAppDocumentHeadCursorResult>;
     get(docId: string): Promise<MindooDBAppDocument | null>;
+    getRichText(docId: string, path: Array<string | number>, options?: MindooDBAppRichTextGetOptions): Promise<MindooDBAppRichTextSnapshot>;
     create(input: MindooDBAppCreateDocumentInput): Promise<MindooDBAppDocument>;
     update(docId: string, patch: MindooDBAppUpdateDocumentInput): Promise<MindooDBAppDocument>;
     delete(docId: string): Promise<{
@@ -737,4 +777,4 @@ interface MindooDBAppBridge {
     connect(options?: MindooDBAppBridgeConnectOptions): Promise<MindooDBAppSession>;
 }
 
-export type { MindooDBAppDocumentListQuery as $, MindooDBAppBridgeThemeChangedMessage as A, MindooDBAppBridgeUiPreferencesChangedMessage as B, MindooDBAppBridgeViewportChangedMessage as C, MindooDBAppCapability as D, MindooDBAppConfiguredViewCategorizationStyle as E, MindooDBAppConfiguredViewColumn as F, MindooDBAppConfiguredViewColumnRole as G, MindooDBAppConfiguredViewExpressionMode as H, MindooDBAppConfiguredViewFieldExpression as I, MindooDBAppConfiguredViewFilterDefinition as J, MindooDBAppConfiguredViewFilterMode as K, MindooDBAppConfiguredViewFilterRule as L, MindooDBAppAttachmentPreviewMode as M, MindooDBAppConfiguredViewFormulaExpression as N, MindooDBAppConfiguredViewFormulaFilterDefinition as O, MindooDBAppConfiguredViewPreviewMode as P, MindooDBAppConfiguredViewRuleFilterDefinition as Q, MindooDBAppConfiguredViewRuleMatchMode as R, MindooDBAppConfiguredViewRuleOperator as S, MindooDBAppConfiguredViewValueExpression as T, MindooDBAppCreateDocumentInput as U, MindooDBAppCreateViewInput as V, MindooDBAppCreateViewNavigatorInput as W, MindooDBAppDatabaseInfo as X, MindooDBAppDocumentApi as Y, MindooDBAppDocumentHeadCursorResult as Z, MindooDBAppDocumentHistoryEntry as _, MindooDBAppBridge as a, MindooDBAppDocumentListResult as a0, MindooDBAppDocumentRevisionId as a1, MindooDBAppDocumentScanPreset as a2, MindooDBAppDocumentSummary as a3, MindooDBAppHistoricalDocument as a4, MindooDBAppHistoryQuery as a5, MindooDBAppHostTheme as a6, MindooDBAppJsonListDeletePatch as a7, MindooDBAppJsonListInsertPatch as a8, MindooDBAppJsonPatch as a9, MindooDBAppShowMenuResult as aA, MindooDBAppTextEdit as aB, MindooDBAppTextPatch as aC, MindooDBAppThemeMode as aD, MindooDBAppUiPreferences as aE, MindooDBAppUpdateDocumentInput as aF, MindooDBAppViewCursorDocumentListResult as aG, MindooDBAppViewCursorResult as aH, MindooDBAppViewEntry as aI, MindooDBAppViewEntryKind as aJ, MindooDBAppViewNavigator as aK, MindooDBAppViewNavigatorExpansionState as aL, MindooDBAppViewNavigatorOpenOptions as aM, MindooDBAppViewNavigatorPageOptions as aN, MindooDBAppViewNavigatorPageResult as aO, MindooDBAppViewNavigatorRangeQuery as aP, MindooDBAppViewNavigatorSelectionState as aQ, MindooDBAppViewport as aR, MindooDBAppWritableAttachmentStream as aS, MindooDBAppJsonSetPatch as aa, MindooDBAppJsonUnsetPatch as ab, MindooDBAppLaunchContext as ac, MindooDBAppMenuAnchor as ad, MindooDBAppMenuApi as ae, MindooDBAppMenuCommandItem as af, MindooDBAppMenuDismissReason as ag, MindooDBAppMenuDismissedResult as ah, MindooDBAppMenuItem as ai, MindooDBAppMenuKind as aj, MindooDBAppMenuPlacement as ak, MindooDBAppMenuPointAnchor as al, MindooDBAppMenuRect as am, MindooDBAppMenuRectAnchor as an, MindooDBAppMenuSelectionResult as ao, MindooDBAppMenuSeparatorItem as ap, MindooDBAppReadableAttachmentStream as aq, MindooDBAppResolvedViewDefinition as ar, MindooDBAppResolvedViewSource as as, MindooDBAppRuntime as at, MindooDBAppScanAttachmentOptions as au, MindooDBAppScanAttachmentResult as av, MindooDBAppScopedDocId as aw, MindooDBAppScopedDocumentSummary as ax, MindooDBAppSession as ay, MindooDBAppShowMenuInput as az, MindooDBAppDatabase as b, MindooDBAppDocument as c, MindooDBAppAttachmentApi as d, MindooDBAppAttachmentChunk as e, MindooDBAppAttachmentInfo as f, MindooDBAppAttachmentPreviewOptions as g, MindooDBAppAttachmentPreviewSession as h, MindooDBAppBridgeConnectMessage as i, MindooDBAppBridgeConnectOptions as j, MindooDBAppBridgeConnectedMessage as k, MindooDBAppBridgeErrorPayload as l, MindooDBAppBridgeHandshakeErrorMessage as m, MindooDBAppBridgePortMessage as n, MindooDBAppBridgeRpcError as o, MindooDBAppBridgeRpcMessage as p, MindooDBAppBridgeRpcRequest as q, MindooDBAppBridgeRpcSuccess as r, MindooDBAppBridgeStreamAbortRequest as s, MindooDBAppBridgeStreamAck as t, MindooDBAppBridgeStreamCloseRequest as u, MindooDBAppBridgeStreamError as v, MindooDBAppBridgeStreamMessage as w, MindooDBAppBridgeStreamOpenResult as x, MindooDBAppBridgeStreamReadRequest as y, MindooDBAppBridgeStreamWriteRequest as z };
+export type { MindooDBAppDocumentHeadCursorResult as $, MindooDBAppBridgeStreamReadRequest as A, MindooDBAppBridgeStreamWriteRequest as B, MindooDBAppBridgeThemeChangedMessage as C, MindooDBAppBridgeUiPreferencesChangedMessage as D, MindooDBAppBridgeViewportChangedMessage as E, MindooDBAppCapability as F, MindooDBAppConfiguredViewCategorizationStyle as G, MindooDBAppConfiguredViewColumn as H, MindooDBAppConfiguredViewColumnRole as I, MindooDBAppConfiguredViewExpressionMode as J, MindooDBAppConfiguredViewFieldExpression as K, MindooDBAppConfiguredViewFilterDefinition as L, MindooDBAppAttachmentPreviewMode as M, MindooDBAppConfiguredViewFilterMode as N, MindooDBAppConfiguredViewFilterRule as O, MindooDBAppConfiguredViewFormulaExpression as P, MindooDBAppConfiguredViewFormulaFilterDefinition as Q, MindooDBAppConfiguredViewPreviewMode as R, MindooDBAppConfiguredViewRuleFilterDefinition as S, MindooDBAppConfiguredViewRuleMatchMode as T, MindooDBAppConfiguredViewRuleOperator as U, MindooDBAppConfiguredViewValueExpression as V, MindooDBAppCreateDocumentInput as W, MindooDBAppCreateViewInput as X, MindooDBAppCreateViewNavigatorInput as Y, MindooDBAppDatabaseInfo as Z, MindooDBAppDocumentApi as _, MindooDBAppBridge as a, MindooDBAppWritableAttachmentStream as a$, MindooDBAppDocumentHistoryEntry as a0, MindooDBAppDocumentListQuery as a1, MindooDBAppDocumentListResult as a2, MindooDBAppDocumentRevisionId as a3, MindooDBAppDocumentScanPreset as a4, MindooDBAppDocumentSummary as a5, MindooDBAppHistoricalDocument as a6, MindooDBAppHistoryQuery as a7, MindooDBAppHostTheme as a8, MindooDBAppJsonListDeletePatch as a9, MindooDBAppRichTextScalar as aA, MindooDBAppRichTextTextSpan as aB, MindooDBAppRuntime as aC, MindooDBAppScanAttachmentOptions as aD, MindooDBAppScanAttachmentResult as aE, MindooDBAppScopedDocId as aF, MindooDBAppScopedDocumentSummary as aG, MindooDBAppSession as aH, MindooDBAppShowMenuInput as aI, MindooDBAppShowMenuResult as aJ, MindooDBAppTextEdit as aK, MindooDBAppTextPatch as aL, MindooDBAppThemeMode as aM, MindooDBAppUiPreferences as aN, MindooDBAppUpdateDocumentInput as aO, MindooDBAppViewCursorDocumentListResult as aP, MindooDBAppViewCursorResult as aQ, MindooDBAppViewEntry as aR, MindooDBAppViewEntryKind as aS, MindooDBAppViewNavigator as aT, MindooDBAppViewNavigatorExpansionState as aU, MindooDBAppViewNavigatorOpenOptions as aV, MindooDBAppViewNavigatorPageOptions as aW, MindooDBAppViewNavigatorPageResult as aX, MindooDBAppViewNavigatorRangeQuery as aY, MindooDBAppViewNavigatorSelectionState as aZ, MindooDBAppViewport as a_, MindooDBAppJsonListInsertPatch as aa, MindooDBAppJsonPatch as ab, MindooDBAppJsonSetPatch as ac, MindooDBAppJsonUnsetPatch as ad, MindooDBAppLaunchContext as ae, MindooDBAppMenuAnchor as af, MindooDBAppMenuApi as ag, MindooDBAppMenuCommandItem as ah, MindooDBAppMenuDismissReason as ai, MindooDBAppMenuDismissedResult as aj, MindooDBAppMenuItem as ak, MindooDBAppMenuKind as al, MindooDBAppMenuPlacement as am, MindooDBAppMenuPointAnchor as an, MindooDBAppMenuRect as ao, MindooDBAppMenuRectAnchor as ap, MindooDBAppMenuSelectionResult as aq, MindooDBAppMenuSeparatorItem as ar, MindooDBAppReadableAttachmentStream as as, MindooDBAppResolvedViewDefinition as at, MindooDBAppResolvedViewSource as au, MindooDBAppRichTextBlockSpan as av, MindooDBAppRichTextGetOptions as aw, MindooDBAppRichTextImmutableString as ax, MindooDBAppRichTextMaterializeValue as ay, MindooDBAppRichTextPatch as az, MindooDBAppDatabase as b, MindooDBAppDocument as c, MindooDBAppRichTextSpan as d, MindooDBAppRichTextSnapshot as e, MindooDBAppAttachmentApi as f, MindooDBAppAttachmentChunk as g, MindooDBAppAttachmentInfo as h, MindooDBAppAttachmentPreviewOptions as i, MindooDBAppAttachmentPreviewSession as j, MindooDBAppBridgeConnectMessage as k, MindooDBAppBridgeConnectOptions as l, MindooDBAppBridgeConnectedMessage as m, MindooDBAppBridgeErrorPayload as n, MindooDBAppBridgeHandshakeErrorMessage as o, MindooDBAppBridgePortMessage as p, MindooDBAppBridgeRpcError as q, MindooDBAppBridgeRpcMessage as r, MindooDBAppBridgeRpcRequest as s, MindooDBAppBridgeRpcSuccess as t, MindooDBAppBridgeStreamAbortRequest as u, MindooDBAppBridgeStreamAck as v, MindooDBAppBridgeStreamCloseRequest as w, MindooDBAppBridgeStreamError as x, MindooDBAppBridgeStreamMessage as y, MindooDBAppBridgeStreamOpenResult as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindoodb-app-sdk",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "engines": {
     "node": ">=22.13.0"
   },