mindoodb-app-sdk 0.0.32 → 0.0.34

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

@@ -1,3 +1,6 @@
+// src/types.ts
+var MINDOODB_APP_SEAL_SIGNING_DOMAIN = "mindoodb-seal/v1";
+
 // src/attachmentPreview.ts
 function canPreviewAttachment(fileName, mimeType) {
   const normalizedMimeType = mimeType.toLowerCase();
@@ -907,10 +910,42 @@ 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,
+        docId,
+        revisionIds
+      })
+    };
+    this.identity = {
+      signStatement: async (input) => await this.rpc.call("identity.signStatement", {
+        databaseId: this.databaseId,
+        ...input
+      })
+    };
+    this.timestamps = {
+      rfc3161: async (input) => await this.rpc.call("timestamps.rfc3161", {
+        databaseId: this.databaseId,
+        ...input
+      }),
+      listProviders: async () => await this.rpc.call("timestamps.listProviders", {
+        databaseId: this.databaseId
+      })
+    };
+    this.directory = {
+      excerpt: async (publicKeys) => await this.rpc.call("directory.excerpt", {
+        databaseId: this.databaseId,
+        publicKeys
       })
     };
     this.attachments = {
@@ -1032,6 +1067,9 @@ var MindooDBAppDatabaseImpl = class {
   databaseId;
   documents;
   attachments;
+  identity;
+  timestamps;
+  directory;
   /** Returns database metadata for the currently opened binding. */
   async info() {
     return await this.rpc.call("databases.info", {
@@ -1539,6 +1577,7 @@ async function queryDocuments(db, filter, sortBy, options) {
   return db.query({ filter: expression, sortBy }, options);
 }
 export {
+  MINDOODB_APP_SEAL_SIGNING_DOMAIN,
   MindooDBRichTextHandle,
   MindooDBTextBuffer,
   abbreviateCanonicalName,

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { au as MindooDBAppLaunchContext, a7 as MindooDBAppDatabaseInfo, a8 as MindooDBAppDocumentApi, a6 as MindooDBAppCreateViewNavigatorInput, bh as MindooDBAppViewNavigator, bj as MindooDBAppViewNavigatorOpenOptions, h as MindooDBAppAttachmentApi, ai as MindooDBAppFulltextSetup, ah as MindooDBAppExtractionSetup, a as MindooDBAppBridge, b5 as MindooDBAppSession, B as MindooDBAppBridgeRpcRequest, al as MindooDBAppHostTheme, bp as MindooDBAppViewport, bb as MindooDBAppUiPreferences, aK as MindooDBAppQueryResult, bo as MindooDBAppViewUpdateStats, x as MindooDBAppBridgePortMessage } from '../types-B-NelfTY.js';
+import { aA as MindooDBAppLaunchContext, a8 as MindooDBAppDatabaseInfo, ab as MindooDBAppDocumentApi, a7 as MindooDBAppCreateViewNavigatorInput, by as MindooDBAppViewNavigator, bA as MindooDBAppViewNavigatorOpenOptions, i as MindooDBAppAttachmentApi, ar as MindooDBAppIdentityApi, bo as MindooDBAppTimestampApi, a9 as MindooDBAppDirectoryApi, an as MindooDBAppFulltextSetup, am as MindooDBAppExtractionSetup, a as MindooDBAppBridge, be as MindooDBAppSession, C as MindooDBAppBridgeRpcRequest, aq as MindooDBAppHostTheme, bG as MindooDBAppViewport, bs as MindooDBAppUiPreferences, aQ as MindooDBAppQueryResult, bF as MindooDBAppViewUpdateStats, y as MindooDBAppBridgePortMessage } from '../types-Bl6CrBn1.js';
 import 'mindoodb-view-language';
 
 type MaybePromise<T> = T | Promise<T>;
@@ -10,6 +10,9 @@ type MockDatabaseMethods = {
     documents?: Partial<MindooDBAppDocumentApi>;
     views?: Partial<MockViewApi>;
     attachments?: Partial<MindooDBAppAttachmentApi>;
+    identity?: Partial<MindooDBAppIdentityApi>;
+    timestamps?: Partial<MindooDBAppTimestampApi>;
+    directory?: Partial<MindooDBAppDirectoryApi>;
 };
 interface MockMindooDBAppDatabaseDefinition {
     info: MindooDBAppDatabaseInfo;

package/dist/testing/index.js

@@ -5,6 +5,7 @@ import {
   parseMindooDBFormulaBooleanExpression
 } from "mindoodb-view-language";
 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") {
   if (error && typeof error === "object" && "message" in error) {
     const namedError = error;
@@ -746,6 +747,14 @@ function createDefaultViewNavigator() {
     }
   };
 }
+async function mockSha256Hex(value) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    return null;
+  }
+  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 function createDatabaseHandle(definition) {
   let createCounter = 0;
   let changeCounter = 0;
@@ -1067,6 +1076,69 @@ function createDatabaseHandle(definition) {
         data: null,
         attachments: []
       };
+    },
+    async getAtHeads(docId, _headIds) {
+      return {
+        id: docId,
+        timestamp: Date.now(),
+        heads: [],
+        state: "missing",
+        data: null,
+        attachments: []
+      };
+    },
+    async listVerification() {
+      return [];
+    }
+  };
+  const defaultIdentity = {
+    async signStatement(input) {
+      if (input.preview.svg != null && input.preview.renderDigest != null) {
+        const actual = await mockSha256Hex(input.preview.svg);
+        if (actual != null && actual !== input.preview.renderDigest) {
+          return { ok: false, reason: "render-mismatch" };
+        }
+      }
+      return {
+        ok: true,
+        signature: `mock-signature-${input.statement.byteLength}`,
+        publicKey: MOCK_SIGNING_PUBLIC_KEY_PEM,
+        fingerprint: "0".repeat(64),
+        domain: input.domain,
+        signedAt: Date.now()
+      };
+    }
+  };
+  const defaultTimestamps = {
+    async rfc3161(input) {
+      return {
+        token: `mock-timestamp-token-${input.digest.byteLength}`,
+        providerId: input.providerId ?? "mock",
+        providerName: "Mock TSA (test host)",
+        transport: "direct",
+        genTime: Date.now(),
+        rootInPublicTrustStores: false
+      };
+    },
+    async listProviders() {
+      return [
+        {
+          id: "mock",
+          name: "Mock TSA (test host)",
+          qualified: false,
+          rootInPublicTrustStores: false,
+          browserReachable: true
+        }
+      ];
+    }
+  };
+  const defaultDirectory = {
+    async excerpt(publicKeys) {
+      return publicKeys.map((signingPublicKey) => ({
+        signingPublicKey,
+        fingerprint: "0".repeat(64),
+        status: "unknown"
+      }));
     }
   };
   const defaultViews = {
@@ -1129,6 +1201,18 @@ function createDatabaseHandle(definition) {
       ...defaultAttachments,
       ...methods.attachments
     },
+    identity: {
+      ...defaultIdentity,
+      ...methods.identity
+    },
+    timestamps: {
+      ...defaultTimestamps,
+      ...methods.timestamps
+    },
+    directory: {
+      ...defaultDirectory,
+      ...methods.directory
+    },
     async getFulltextSetup() {
       return fulltextSetup === null ? null : { ...fulltextSetup };
     },
@@ -1676,7 +1760,34 @@ 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(
+          String(params.docId),
+          Array.isArray(params.revisionIds) ? params.revisionIds.map(String) : void 0
+        );
+      case "identity.signStatement": {
+        const { databaseId: _databaseId, ...input } = params;
+        return await state.getDatabase(String(params.databaseId)).identity.signStatement(
+          input
+        );
+      }
+      case "timestamps.rfc3161": {
+        const { databaseId: _databaseId, ...input } = params;
+        return await state.getDatabase(String(params.databaseId)).timestamps.rfc3161(input);
+      }
+      case "timestamps.listProviders":
+        return await state.getDatabase(String(params.databaseId)).timestamps.listProviders();
+      case "directory.excerpt":
+        return await state.getDatabase(String(params.databaseId)).directory.excerpt(
+          Array.isArray(params.publicKeys) ? params.publicKeys.map(String) : []
         );
       case "attachments.list":
         return await state.getDatabase(String(params.databaseId)).attachments.list(

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

@@ -102,7 +102,7 @@ interface MindooDBAppResolvedViewDefinition {
     columns: MindooDBAppConfiguredViewColumn[];
 }
 /** Permission/capability flags exposed for a database binding inside the app session. */
-type MindooDBAppCapability = "read" | "create" | "update" | "delete" | "history" | "attachments" | "views";
+type MindooDBAppCapability = "read" | "create" | "update" | "delete" | "history" | "attachments" | "views" | "sign" | "timestamps" | "directory";
 /** Metadata about the current app launch supplied by the Haven host. */
 interface MindooDBAppLaunchContext {
     appId: string;
@@ -208,6 +208,108 @@ 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}
+ * deliberately omits.
+ *
+ * Nothing here requires the document's decryption key. `metadataSignature`
+ * covers the entry id, and an entry id ends in the hash of the *plaintext*
+ * Automerge change, so an outsider can attribute every change to a key and
+ * order the whole edit DAG while learning nothing about what any change
+ * contained.
+ *
+ * Byte fields are base64 rather than `Uint8Array` because these records are
+ * written verbatim into evidence bundles as JSON, and read back years later by
+ * a verifier that has no Haven, no tenant and no network.
+ */
+interface MindooDBAppRevisionVerification {
+    /** Matches `revisionId` in {@link MindooDBAppDocumentHistoryEntry}. */
+    revisionId: MindooDBAppDocumentRevisionId;
+    /** Store entry id: `<docId>_d_<depsFingerprint>_<automergeChangeHash>`. */
+    entryId: string;
+    entryType: string;
+    docId: string;
+    /** Database name the entry lives under; bound into the witness receipt. */
+    dbid: string;
+    /** SHA-256 of the *encrypted* payload. */
+    contentHash: string;
+    createdAt: number;
+    createdByPublicKey: string;
+    decryptionKeyId: string;
+    dependencyIds: string[];
+    attachmentRefs?: MindooDBAppEntryAttachmentRef[];
+    provenance?: MindooDBAppEntryProvenance;
+    /** Base64 legacy signature, over the ciphertext only. */
+    signature: string;
+    /**
+     * Base64 signature over the canonical metadata layout, which includes the
+     * entry id. Absent on entries written before this field existed — those
+     * cannot be bound to a plaintext change at all, and a verifier must report
+     * them as unattributable rather than pass them.
+     */
+    metadataSignature?: string;
+    /** Epoch ms at which a witnessing server accepted the entry. */
+    receivedAt?: number;
+    receivedByPublicKey?: string;
+    /** Base64 Ed25519 signature by the witness over the receipt layout. */
+    receivedDateSignature?: string;
+    receiptScheme?: string;
+    entryVersion?: number;
+    /**
+     * The tenant's trusted witness keys *as of* `receivedAt`. A receipt is only
+     * worth something if its signer was trusted when it was made, and that set
+     * changes over a tenant's life — so it is resolved at read time and carried
+     * along, not left for the verifier to guess.
+     */
+    trustedWitnessKeys?: string[];
+}
+/** Attachment reference bound into an entry's metadata signature. */
+interface MindooDBAppEntryAttachmentRef {
+    attachmentId: string;
+    lastChunkId: string;
+    size: number;
+}
+/** Where a copied entry came from, as recorded in its signed metadata. */
+interface MindooDBAppEntryProvenance {
+    sourceTenantId: string;
+    sourceDbId: string;
+    source: {
+        entryType: string;
+        id: string;
+        docId: string;
+        decryptionKeyId: string;
+        createdAt: number;
+        dependencyIds: string[];
+        contentHash: string;
+        createdByPublicKey: string;
+        attachmentRefs?: MindooDBAppEntryAttachmentRef[];
+    };
+    /** Base64 signature by the original author. */
+    sourceMetadataSignature?: string;
 }
 /** Historical snapshot returned for a document at a specific timestamp. */
 interface MindooDBAppHistoricalDocument {
@@ -1175,8 +1277,10 @@ interface MindooDBAppDocumentApi {
     getDefaultCreateKeyId(): Promise<string>;
     /**
      * List the document's revision timeline (newest first), including author
-     * identity metadata and the stable `revisionId` per entry. Requires the
-     * `history` capability.
+     * identity metadata and the stable `revisionId` per entry. Entries are
+     * metadata-only — document bodies are not included; load a revision with
+     * {@link getAtRevision} or {@link getAtTimestamp}. Requires the `history`
+     * capability.
      */
     listHistory(docId: string): Promise<MindooDBAppDocumentHistoryEntry[]>;
     /**
@@ -1192,8 +1296,204 @@ 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.
+     */
+    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
+     * need it and an audit cannot do without it.
+     *
+     * Pass `revisionIds` to fetch only the revisions being sealed; omit it for
+     * the whole document. Requires the `history` capability.
+     */
+    listVerification(docId: string, revisionIds?: MindooDBAppDocumentRevisionId[]): Promise<MindooDBAppRevisionVerification[]>;
+}
+/**
+ * Signing with the launching user's MindooDB identity key.
+ *
+ * The app never touches the key, and never signs silently: every call opens a
+ * Haven dialog showing what is about to be signed. Requires the `sign`
+ * capability, which only grants the *right to ask*.
+ */
+interface MindooDBAppIdentityApi {
+    /**
+     * Ask the user to sign `input.statement` under `input.domain`.
+     *
+     * Resolves with `ok: false` when the user declines or when the preview SVG
+     * does not match the `renderDigest` inside the statement — neither is an
+     * error, and both should leave the app's UI intact.
      */
-    getAtRevision(docId: string, revisionId: MindooDBAppDocumentRevisionId): Promise<MindooDBAppHistoricalDocument>;
+    signStatement(input: MindooDBAppSignStatementInput): Promise<MindooDBAppSignStatementResult>;
+}
+/** RFC 3161 timestamps over app-supplied digests. */
+interface MindooDBAppTimestampApi {
+    /**
+     * Obtain a timestamp token. Haven calls a browser-reachable TSA directly
+     * where it can, and otherwise proxies through the tenant's server; the
+     * returned `transport` says which happened.
+     *
+     * A token proves the digest existed *no later than* `genTime`. It cannot
+     * prove a lower bound, and no amount of UI wording should imply otherwise.
+     * Requires the `timestamps` capability.
+     */
+    rfc3161(input: MindooDBAppTimestampInput): Promise<MindooDBAppTimestampResult>;
+    /** Providers this host can currently reach, best first. */
+    listProviders(): Promise<MindooDBAppTimestampProvider[]>;
+}
+/** Read-only lookups against the tenant's user directory. */
+interface MindooDBAppDirectoryApi {
+    /**
+     * Resolve the directory's claims about specific signing keys.
+     *
+     * Only the keys asked for are returned, and unknown keys come back with
+     * `status: "unknown"` rather than being dropped — an evidence excerpt should
+     * name the keys it could not resolve. Requires the `directory` capability.
+     */
+    excerpt(publicKeys: string[]): Promise<MindooDBAppDirectoryEntry[]>;
+}
+/**
+ * The only signing domain apps may request today. Domain separation is not
+ * decoration: the same Ed25519 key signs store entries and auth challenges, and
+ * an app that could choose its own prefix could have the user unwittingly sign
+ * something that replays as one of those.
+ */
+declare const MINDOODB_APP_SEAL_SIGNING_DOMAIN = "mindoodb-seal/v1";
+/** What the seal asserts about the material it covers. */
+type MindooDBAppSealIntent = "approval" | "countersign" | "authorship";
+/**
+ * What Haven shows the user before signing.
+ *
+ * This is the WYSIWYS ("what you see is what you sign") surface. The app hands
+ * over the exact picture and wording it wants attested; Haven checks the SVG
+ * against `renderDigest` — which is inside the signed bytes — and refuses to
+ * sign when they disagree. Without that check a signature would attest to bytes
+ * nobody ever looked at.
+ */
+interface MindooDBAppSignPreview {
+    /** Headline of the consent dialog, e.g. "Approve page 3 of Site survey". */
+    title: string;
+    intent: MindooDBAppSealIntent;
+    /**
+     * SVG source of what is being sealed, shown inline. Haven verifies that its
+     * SHA-256 equals {@link renderDigest} before rendering it.
+     */
+    svg?: string;
+    /** Lower-case hex SHA-256 of `svg`, as it appears in the statement. */
+    renderDigest?: string;
+    /** One row per sealed document, shown as a list the user can read. */
+    scope: MindooDBAppSignPreviewScope[];
+    /** Free-text note that is part of the signed statement. */
+    note?: string;
+}
+/** One sealed document as presented in the consent dialog. */
+interface MindooDBAppSignPreviewScope {
+    label: string;
+    detail?: string;
+}
+/** Request to sign a canonical statement with the launching user's identity key. */
+interface MindooDBAppSignStatementInput {
+    /** Must be {@link MINDOODB_APP_SEAL_SIGNING_DOMAIN}. */
+    domain: string;
+    /** Canonical (RFC 8785) statement bytes. Signed verbatim under `domain`. */
+    statement: Uint8Array;
+    preview: MindooDBAppSignPreview;
+}
+/**
+ * Outcome of a signing request.
+ *
+ * Declining is an ordinary outcome, not an error: `ok: false` with a `reason`,
+ * so an app can distinguish "the user said no" from "the bridge broke" without
+ * inspecting error strings.
+ */
+type MindooDBAppSignStatementResult = {
+    ok: true;
+    /** Base64 Ed25519 signature over `domain || 0x00 || statement`. */
+    signature: string;
+    /** PEM public key of the signing identity. */
+    publicKey: string;
+    /** Lower-case hex SHA-256 of the DER SubjectPublicKeyInfo. */
+    fingerprint: string;
+    domain: string;
+    /** Client wall-clock at signing. Not evidence — the TSA token is. */
+    signedAt: number;
+} | {
+    ok: false;
+    reason: "declined" | "render-mismatch";
+};
+/** Request for an RFC 3161 token over a digest the app computed. */
+interface MindooDBAppTimestampInput {
+    /** Raw digest bytes to be timestamped (32 bytes for SHA-256). */
+    digest: Uint8Array;
+    /** @defaultValue `"SHA-256"` */
+    hashAlgorithm?: "SHA-256" | "SHA-512";
+    /**
+     * Preferred provider id from {@link MindooDBAppTimestampProvider}. Apps name
+     * a provider, never a URL — the URL set is server configuration, so a hostile
+     * app cannot aim the host at an address of its choosing.
+     */
+    providerId?: string;
+    /** Ask the TSA to include its certificate chain in the token. @defaultValue `true` */
+    requestCertificates?: boolean;
+}
+/** A timestamp token, with enough context to verify it offline later. */
+interface MindooDBAppTimestampResult {
+    /** Base64 DER `TimeStampResp`. */
+    token: string;
+    providerId: string;
+    providerName?: string;
+    /** Where the token came from: a direct browser call or the tenant's server. */
+    transport: "direct" | "proxy";
+    /** TSA-asserted time, epoch ms, as parsed from the token. */
+    genTime?: number;
+    policyOid?: string;
+    /** True when the token chains to a root in public trust stores. */
+    rootInPublicTrustStores?: boolean;
+    /** PEM chain extracted from the token, for a verifier with no trust store. */
+    certificateChainPem?: string;
+}
+/** A timestamping provider this host can reach. */
+interface MindooDBAppTimestampProvider {
+    id: string;
+    name: string;
+    /** eIDAS-qualified. Free and non-qualified are the common case. */
+    qualified: boolean;
+    rootInPublicTrustStores: boolean;
+    policyOid?: string;
+    /** Reachable straight from the browser (CORS-enabled), no server needed. */
+    browserReachable: boolean;
+}
+/**
+ * One directory entry, for the identity excerpt a bundle carries.
+ *
+ * This is the weakest link in the evidence and the docs say so plainly: it
+ * records what the tenant's directory claimed about a key, which is an
+ * agreement between the parties, not a cryptographic fact.
+ */
+interface MindooDBAppDirectoryEntry {
+    /** PEM Ed25519 signing key, as it appears in entry metadata. */
+    signingPublicKey: string;
+    fingerprint: string;
+    label?: string;
+    email?: string;
+    status: "active" | "revoked" | "unknown";
 }
 type MindooDBAppViewEntryKind = "category" | "document";
 /** Unique document identity within a multi-source view. */
@@ -1485,6 +1785,17 @@ interface MindooDBAppDatabase {
     info(): Promise<MindooDBAppDatabaseInfo>;
     documents: MindooDBAppDocumentApi;
     attachments: MindooDBAppAttachmentApi;
+    /**
+     * Signing, timestamping and directory lookups.
+     *
+     * These hang off a database rather than the session because each one is
+     * granted per binding and resolves through that binding's tenant — the
+     * signing identity, the server that proxies timestamps and the directory
+     * being quoted are all the tenant's, not the app's.
+     */
+    identity: MindooDBAppIdentityApi;
+    timestamps: MindooDBAppTimestampApi;
+    directory: MindooDBAppDirectoryApi;
     /**
      * Read the database's full-text index configuration from the synced
      * `dbsetup` document. Resolves to `null` when full-text indexing has
@@ -1614,4 +1925,4 @@ interface MindooDBAppBridge {
     connect(options?: MindooDBAppBridgeConnectOptions): Promise<MindooDBAppSession>;
 }
 
-export type { MindooDBAppConfiguredViewPreviewMode as $, MindooDBAppBridgeRpcMessage as A, MindooDBAppBridgeRpcRequest as B, MindooDBAppBridgeRpcSuccess as C, MindooDBAppBridgeStreamAbortRequest as D, MindooDBAppBridgeStreamAck as E, MindooDBAppBridgeStreamCloseRequest as F, MindooDBAppBridgeStreamError as G, MindooDBAppBridgeStreamMessage as H, MindooDBAppBridgeStreamOpenResult as I, MindooDBAppBridgeStreamReadRequest as J, MindooDBAppBridgeStreamWriteRequest as K, MindooDBAppBridgeThemeChangedMessage as L, MindooDBAppAttachmentPreviewMode as M, MindooDBAppBridgeUiPreferencesChangedMessage as N, MindooDBAppBridgeViewChangedMessage as O, MindooDBAppBridgeViewportChangedMessage as P, MindooDBAppCapability as Q, MindooDBAppConfiguredViewCategorizationStyle as R, MindooDBAppConfiguredViewColumn as S, MindooDBAppConfiguredViewColumnRole as T, MindooDBAppConfiguredViewExpressionMode as U, MindooDBAppConfiguredViewFieldExpression as V, MindooDBAppConfiguredViewFilterDefinition as W, MindooDBAppConfiguredViewFilterMode as X, MindooDBAppConfiguredViewFilterRule as Y, MindooDBAppConfiguredViewFormulaExpression as Z, MindooDBAppConfiguredViewFormulaFilterDefinition as _, MindooDBAppBridge as a, MindooDBAppRichTextTextSpan as a$, MindooDBAppConfiguredViewRuleFilterDefinition as a0, MindooDBAppConfiguredViewRuleMatchMode as a1, MindooDBAppConfiguredViewRuleOperator as a2, MindooDBAppConfiguredViewValueExpression as a3, MindooDBAppCreateDocumentInput as a4, MindooDBAppCreateViewInput as a5, MindooDBAppCreateViewNavigatorInput as a6, MindooDBAppDatabaseInfo as a7, MindooDBAppDocumentApi as a8, MindooDBAppDocumentHeadCursorResult as a9, MindooDBAppMenuDismissedResult as aA, MindooDBAppMenuItem as aB, MindooDBAppMenuKind as aC, MindooDBAppMenuPlacement as aD, MindooDBAppMenuPointAnchor as aE, MindooDBAppMenuRect as aF, MindooDBAppMenuRectAnchor as aG, MindooDBAppMenuSelectionResult as aH, MindooDBAppMenuSeparatorItem as aI, MindooDBAppQueryCoverage as aJ, MindooDBAppQueryResult as aK, MindooDBAppQueryRow as aL, MindooDBAppQuerySortKey as aM, MindooDBAppQueryTextClause as aN, MindooDBAppReadableAttachmentStream as aO, MindooDBAppResolvedViewDefinition as aP, MindooDBAppResolvedViewSource as aQ, MindooDBAppRichTextBlockSpan as aR, MindooDBAppRichTextGetOptions as aS, MindooDBAppRichTextImmutableString as aT, MindooDBAppRichTextMarkRange as aU, MindooDBAppRichTextMaterializeValue as aV, MindooDBAppRichTextPatch as aW, MindooDBAppRichTextScalar as aX, MindooDBAppRichTextSpliceStep as aY, MindooDBAppRichTextStep as aZ, MindooDBAppRichTextStepPatch as a_, MindooDBAppDocumentHistoryEntry as aa, MindooDBAppDocumentListQuery as ab, MindooDBAppDocumentListResult as ac, MindooDBAppDocumentQuery as ad, MindooDBAppDocumentRevisionId as ae, MindooDBAppDocumentScanPreset as af, MindooDBAppDocumentSummary as ag, MindooDBAppExtractionSetup as ah, MindooDBAppFulltextSetup as ai, MindooDBAppHistoricalDocument as aj, MindooDBAppHistoryQuery as ak, MindooDBAppHostTheme as al, MindooDBAppJsonListDeletePatch as am, MindooDBAppJsonListInsertPatch as an, MindooDBAppJsonPatch as ao, MindooDBAppJsonSetPatch as ap, MindooDBAppJsonTextMarkPatch as aq, MindooDBAppJsonTextSplicePatch as ar, MindooDBAppJsonTextUnmarkPatch as as, MindooDBAppJsonUnsetPatch as at, MindooDBAppLaunchContext as au, MindooDBAppLiveQuerySubscription as av, MindooDBAppMenuAnchor as aw, MindooDBAppMenuApi as ax, MindooDBAppMenuCommandItem as ay, MindooDBAppMenuDismissReason as az, MindooDBAppDatabase as b, MindooDBAppRuntime as b0, MindooDBAppScanAttachmentOptions as b1, MindooDBAppScanAttachmentResult as b2, MindooDBAppScopedDocId as b3, MindooDBAppScopedDocumentSummary as b4, MindooDBAppSession as b5, MindooDBAppShowMenuInput as b6, MindooDBAppShowMenuResult as b7, MindooDBAppTextEdit as b8, MindooDBAppTextPatch as b9, MindooDBAppThemeMode as ba, MindooDBAppUiPreferences as bb, MindooDBAppUpdateDocumentInput as bc, MindooDBAppViewCursorDocumentListResult as bd, MindooDBAppViewCursorResult as be, MindooDBAppViewEntry as bf, MindooDBAppViewEntryKind as bg, MindooDBAppViewNavigator as bh, MindooDBAppViewNavigatorExpansionState as bi, MindooDBAppViewNavigatorOpenOptions as bj, MindooDBAppViewNavigatorPageOptions as bk, MindooDBAppViewNavigatorPageResult as bl, MindooDBAppViewNavigatorRangeQuery as bm, MindooDBAppViewNavigatorSelectionState as bn, MindooDBAppViewUpdateStats as bo, MindooDBAppViewport as bp, MindooDBAppWritableAttachmentStream as bq, MindooDBAppDocument as c, MindooDBAppRichTextSpan as d, MindooDBAppRichTextSnapshot as e, MindooDBAppAccessDecision as f, MindooDBAppAccessTier as g, MindooDBAppAttachmentApi as h, MindooDBAppAttachmentChunk as i, MindooDBAppAttachmentInfo as j, MindooDBAppAttachmentPreviewOptions as k, MindooDBAppAttachmentPreviewSession as l, MindooDBAppAutomergeChangesPatch as m, MindooDBAppAutomergeChangesSince as n, MindooDBAppAutomergeGetOptions as o, MindooDBAppAutomergePatchResult as p, MindooDBAppAutomergeSnapshot as q, MindooDBAppBridgeConnectMessage as r, MindooDBAppBridgeConnectOptions as s, MindooDBAppBridgeConnectedMessage as t, MindooDBAppBridgeErrorPayload as u, MindooDBAppBridgeHandshakeErrorMessage as v, MindooDBAppBridgeLocaleChangedMessage as w, MindooDBAppBridgePortMessage as x, MindooDBAppBridgeQueryResultMessage as y, MindooDBAppBridgeRpcError 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 MindooDBAppRichTextImmutableString as a$, type MindooDBAppConfiguredViewPreviewMode as a0, type MindooDBAppConfiguredViewRuleFilterDefinition as a1, type MindooDBAppConfiguredViewRuleMatchMode as a2, type MindooDBAppConfiguredViewRuleOperator as a3, type MindooDBAppConfiguredViewValueExpression as a4, type MindooDBAppCreateDocumentInput as a5, type MindooDBAppCreateViewInput as a6, type MindooDBAppCreateViewNavigatorInput as a7, type MindooDBAppDatabaseInfo as a8, type MindooDBAppDirectoryApi as a9, type MindooDBAppLaunchContext as aA, type MindooDBAppLiveQuerySubscription as aB, type MindooDBAppMenuAnchor as aC, type MindooDBAppMenuApi as aD, type MindooDBAppMenuCommandItem as aE, type MindooDBAppMenuDismissReason as aF, type MindooDBAppMenuDismissedResult as aG, type MindooDBAppMenuItem as aH, type MindooDBAppMenuKind as aI, type MindooDBAppMenuPlacement as aJ, type MindooDBAppMenuPointAnchor as aK, type MindooDBAppMenuRect as aL, type MindooDBAppMenuRectAnchor as aM, type MindooDBAppMenuSelectionResult as aN, type MindooDBAppMenuSeparatorItem as aO, type MindooDBAppQueryCoverage as aP, type MindooDBAppQueryResult as aQ, type MindooDBAppQueryRow as aR, type MindooDBAppQuerySortKey as aS, type MindooDBAppQueryTextClause as aT, type MindooDBAppReadableAttachmentStream as aU, type MindooDBAppResolvedViewDefinition as aV, type MindooDBAppResolvedViewSource as aW, type MindooDBAppRevisionPhase as aX, type MindooDBAppRevisionVerification as aY, type MindooDBAppRichTextBlockSpan as aZ, type MindooDBAppRichTextGetOptions as a_, type MindooDBAppDirectoryEntry as aa, type MindooDBAppDocumentApi as ab, type MindooDBAppDocumentHeadCursorResult as ac, type MindooDBAppDocumentHistoryEntry as ad, type MindooDBAppDocumentListQuery as ae, type MindooDBAppDocumentListResult as af, type MindooDBAppDocumentQuery as ag, type MindooDBAppDocumentRevisionId as ah, type MindooDBAppDocumentScanPreset as ai, type MindooDBAppDocumentSummary as aj, type MindooDBAppEntryAttachmentRef as ak, type MindooDBAppEntryProvenance as al, type MindooDBAppExtractionSetup as am, type MindooDBAppFulltextSetup as an, type MindooDBAppHistoricalDocument as ao, type MindooDBAppHistoryQuery as ap, type MindooDBAppHostTheme as aq, type MindooDBAppIdentityApi as ar, type MindooDBAppJsonListDeletePatch as as, type MindooDBAppJsonListInsertPatch as at, type MindooDBAppJsonPatch as au, type MindooDBAppJsonSetPatch as av, type MindooDBAppJsonTextMarkPatch as aw, type MindooDBAppJsonTextSplicePatch as ax, type MindooDBAppJsonTextUnmarkPatch as ay, type MindooDBAppJsonUnsetPatch as az, type MindooDBAppDatabase as b, type MindooDBAppRichTextMarkRange as b0, type MindooDBAppRichTextMaterializeValue as b1, type MindooDBAppRichTextPatch as b2, type MindooDBAppRichTextScalar as b3, type MindooDBAppRichTextSpliceStep as b4, type MindooDBAppRichTextStep as b5, type MindooDBAppRichTextStepPatch as b6, type MindooDBAppRichTextTextSpan as b7, type MindooDBAppRuntime as b8, type MindooDBAppScanAttachmentOptions as b9, type MindooDBAppViewNavigatorOpenOptions as bA, type MindooDBAppViewNavigatorPageOptions as bB, type MindooDBAppViewNavigatorPageResult as bC, type MindooDBAppViewNavigatorRangeQuery as bD, type MindooDBAppViewNavigatorSelectionState as bE, type MindooDBAppViewUpdateStats as bF, type MindooDBAppViewport as bG, type MindooDBAppWritableAttachmentStream as bH, type MindooDBAppScanAttachmentResult as ba, type MindooDBAppScopedDocId as bb, type MindooDBAppScopedDocumentSummary as bc, type MindooDBAppSealIntent as bd, type MindooDBAppSession as be, type MindooDBAppShowMenuInput as bf, type MindooDBAppShowMenuResult as bg, type MindooDBAppSignPreview as bh, type MindooDBAppSignPreviewScope as bi, type MindooDBAppSignStatementInput as bj, type MindooDBAppSignStatementResult as bk, type MindooDBAppTextEdit as bl, type MindooDBAppTextPatch as bm, type MindooDBAppThemeMode as bn, type MindooDBAppTimestampApi as bo, type MindooDBAppTimestampInput as bp, type MindooDBAppTimestampProvider as bq, type MindooDBAppTimestampResult as br, type MindooDBAppUiPreferences as bs, type MindooDBAppUpdateDocumentInput as bt, type MindooDBAppViewCursorDocumentListResult as bu, type MindooDBAppViewCursorResult as bv, type MindooDBAppViewEntry as bw, type MindooDBAppViewEntryKind as bx, type MindooDBAppViewNavigator as by, type MindooDBAppViewNavigatorExpansionState as bz, type MindooDBAppDocument as c, type MindooDBAppRichTextSpan as d, type MindooDBAppRichTextSnapshot as e, MINDOODB_APP_SEAL_SIGNING_DOMAIN as f, type MindooDBAppAccessDecision as g, type MindooDBAppAccessTier as h, type MindooDBAppAttachmentApi as i, type MindooDBAppAttachmentChunk as j, type MindooDBAppAttachmentInfo as k, type MindooDBAppAttachmentPreviewOptions as l, type MindooDBAppAttachmentPreviewSession as m, type MindooDBAppAutomergeChangesPatch as n, type MindooDBAppAutomergeChangesSince as o, type MindooDBAppAutomergeGetOptions as p, type MindooDBAppAutomergePatchResult as q, type MindooDBAppAutomergeSnapshot as r, type MindooDBAppBridgeConnectMessage as s, type MindooDBAppBridgeConnectOptions as t, type MindooDBAppBridgeConnectedMessage as u, type MindooDBAppBridgeErrorPayload as v, type MindooDBAppBridgeHandshakeErrorMessage as w, type MindooDBAppBridgeLocaleChangedMessage as x, type MindooDBAppBridgePortMessage as y, type MindooDBAppBridgeQueryResultMessage as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindoodb-app-sdk",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "engines": {
     "node": ">=22.13.0"
   },
@@ -48,7 +48,7 @@
   },
   "devDependencies": {
     "@automerge/automerge": "^3.2.1",
-    "mindoodb": "^0.0.40",
+    "mindoodb": "^0.0.47",
     "@types/node": "25.5.0",
     "tsup": "^8.5.1",
     "typescript": "^6.0.2",