mindoodb-app-sdk 0.0.64 → 0.0.65

package/TESTING.md

@@ -108,6 +108,24 @@ Each database entry can provide:
 - `methods.attachments`
 - `fulltextSetup` — the initial config returned by `db.getFulltextSetup()`; `db.setFulltextSetup()` overwrites it for the lifetime of the handle. Use this to test your app's full-text bootstrap logic. Note the mock evaluates `text` query clauses regardless of this config.
 - `summarySetup` — the initial config returned by `db.getSummarySetup()`; `db.setSummarySetup()` overwrites it for the lifetime of the handle. The mock's `query()` reads seeded documents directly and ignores this config; use it to test your app's summary bootstrap logic.
+- `automerge: true` — back every document with a real Automerge document, as Haven does (off by default: plain JSON with `mock-head-N` heads). `create`/`update` then return real Automerge heads, `update` applies `set`/`unset`, `json` (with `Automerge.changeAt(json.baseHeads)` when given) and `text` patches as Automerge changes with Haven's rules (missing parents and lists are created, `unset` is idempotent, `counterIncrement` needs a counter, an empty `json` patch is rejected), and `get`/`list`/`query` return the plain projection (atomic strings as strings, counters as numbers, timestamps as ISO strings). `richText` snapshots replace the value at their path and `richTextSteps` are spliced into the text without marks. Seeds are built with a fixed actor, so two mocks from the same seed have identical heads. `mockDatabasesFromDefinition(definition, seed, { automerge: true })` and the test host URL setting `automerge=1` turn it on, too.
+
+#### Concurrent edits from another device
+
+`applyRemoteUpdate(databaseId, docId, input, { actor? })` on the controller (`createMockMindooDBAppSession`, `createFakeBridgeHost`, the browser test host and `window.__havenTestHost`) writes `input` as another device and syncs it in; live queries update as after any write. With `automerge: true` the device holds the history up to `input.json.baseHeads` (plus its own earlier changes) and writes as its own Automerge actor, so its edit truly merges with an app save at the same heads:
+
+```ts
+const doc = await database.documents.get("sheet-1");          // heads H
+await mock.applyRemoteUpdate("main", "sheet-1", {             // device B, at H
+  json: { baseHeads: doc!.heads, listInsert: [{ path: ["rows"], index: 1, values: ["remote"] }] },
+});
+const saved = await database.documents.update("sheet-1", {   // the app, also at H
+  json: { baseHeads: doc!.heads, listInsert: [{ path: ["rows"], index: 1, values: ["local"] }] },
+});
+// saved.data.rows keeps both entries; saved.heads has two heads
+```
+
+The relative order of concurrent inserts at the same index follows Automerge's op ids, as in Haven. Without `automerge`, `applyRemoteUpdate` is a plain update.
 
 ### Evaluating VirtualViews
 
@@ -364,7 +382,7 @@ mountHavenTestHost({
 });
 ```
 
-The panel keeps its settings in the page URL, so a scenario can be linked or opened by Playwright directly: `/__haven-test/?db=main:read,attachments&db=archive:none&enforce=1&users=120&locale=de-DE&theme=dark` (`db=<id>:none` unmaps a database; URL settings win over the options). The same controls are scriptable as `window.__havenTestHost`:
+The panel keeps its settings in the page URL, so a scenario can be linked or opened by Playwright directly: `/__haven-test/?db=main:read,attachments&db=archive:none&enforce=1&users=120&locale=de-DE&theme=dark` (`db=<id>:none` unmaps a database; `automerge=1` backs all databases with Automerge documents; URL settings win over the options). The same controls are scriptable as `window.__havenTestHost`:
 
 ```ts
 await page.goto("/__haven-test/?enforce=1");
@@ -376,6 +394,9 @@ await page.evaluate(() => window.__havenTestHost!.setLocale("de-DE"));
 await page.evaluate(() => window.__havenTestHost!.setNextScan({ fileName: "receipt.pdf", mimeType: "application/pdf", size: 1024 }));
 await app.getByRole("button", { name: "Scan" }).click();
 expect(await page.evaluate(() => window.__havenTestHost!.log.scans)).toHaveLength(1);
+
+// with ?automerge=1: another device edits the document the app has open
+await page.evaluate(() => window.__havenTestHost!.applyRemoteUpdate("main", "sheet-1", { set: { title: "Renamed elsewhere" } }));
 ```
 
 Agent tools are scriptable through `window.__havenTestHost.agent`, the same controller the Vitest helpers expose as `createFakeBridgeHost().agent`:

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { ay as MindooDBAppComponentInfo, bq as MindooDBAppEmbedRect, I as MindooDBAppAgentToolDescriptor, f as MindooDBAppAgentToolErrorCode, V as MindooDBAppBridgeAgentResultMessage, U as MindooDBAppBridgeAgentInvokeMessage, aU as MindooDBAppCreateViewNavigatorInput, de as MindooDBAppViewNavigator, ad as MindooDBAppBridgeRpcRequest, bC as MindooDBAppHostTheme, av as MindooDBAppCapability, j as MindooDBAppDefinition, J as MindooDBAppAttachmentApi, e as MindooDBAppBridge, cQ as MindooDBAppSession, cg as MindooDBAppProposeAppInput, dm as MindooDBAppViewport, d8 as MindooDBAppUiPreferences, cm as MindooDBAppQueryResult, dl as MindooDBAppViewUpdateStats, a9 as MindooDBAppBridgePortMessage, aV as MindooDBAppDatabaseInfo, bl as MindooDBAppEmbedCloseReason, a4 as MindooDBAppBridgeErrorPayload, bX as MindooDBAppLaunchContext, b2 as MindooDBAppDocumentApi, dg as MindooDBAppViewNavigatorOpenOptions, bD as MindooDBAppIdentityApi, d4 as MindooDBAppTimestampApi, b0 as MindooDBAppDirectoryApi, l as MindooDBAppDocument, bz as MindooDBAppFulltextSetup, by as MindooDBAppExtractionSetup, cY as MindooDBAppSummarySetup, ch as MindooDBAppProposeAppResult, bN as MindooDBAppIncomingSource, c as MindooDBAppDragStartResult, bj as MindooDBAppDragProfile, bM as MindooDBAppIncomingResult } from '../types-BeRUxGKN.js';
+import { ay as MindooDBAppComponentInfo, bq as MindooDBAppEmbedRect, I as MindooDBAppAgentToolDescriptor, f as MindooDBAppAgentToolErrorCode, V as MindooDBAppBridgeAgentResultMessage, U as MindooDBAppBridgeAgentInvokeMessage, aU as MindooDBAppCreateViewNavigatorInput, de as MindooDBAppViewNavigator, ad as MindooDBAppBridgeRpcRequest, bC as MindooDBAppHostTheme, av as MindooDBAppCapability, d9 as MindooDBAppUpdateDocumentInput, l as MindooDBAppDocument, j as MindooDBAppDefinition, J as MindooDBAppAttachmentApi, e as MindooDBAppBridge, cQ as MindooDBAppSession, cg as MindooDBAppProposeAppInput, dm as MindooDBAppViewport, d8 as MindooDBAppUiPreferences, cm as MindooDBAppQueryResult, dl as MindooDBAppViewUpdateStats, a9 as MindooDBAppBridgePortMessage, aV as MindooDBAppDatabaseInfo, bl as MindooDBAppEmbedCloseReason, a4 as MindooDBAppBridgeErrorPayload, bX as MindooDBAppLaunchContext, b2 as MindooDBAppDocumentApi, dg as MindooDBAppViewNavigatorOpenOptions, bD as MindooDBAppIdentityApi, d4 as MindooDBAppTimestampApi, b0 as MindooDBAppDirectoryApi, bz as MindooDBAppFulltextSetup, by as MindooDBAppExtractionSetup, cY as MindooDBAppSummarySetup, ch as MindooDBAppProposeAppResult, bN as MindooDBAppIncomingSource, c as MindooDBAppDragStartResult, bj as MindooDBAppDragProfile, bM as MindooDBAppIncomingResult } from '../types-BeRUxGKN.js';
 import * as mindoodb from 'mindoodb';
 import 'mindoodb-view-language';
 
@@ -244,6 +244,14 @@ interface BrowserTestHost {
     setEnforceCapabilities(enforce: boolean): void;
     /** Replaces the usernames of the tenant directory (`directory.listUsers()`). */
     setDirectoryUsers(users: readonly string[]): void;
+    /**
+     * Another device edits a document and the change syncs in: the app's live queries
+     * update. With Automerge-backed databases (`automerge=1` / `automerge: true`) the
+     * edit is made at `input.json.baseHeads` by another actor and merged, so it is
+     * concurrent to app saves at the same heads. See
+     * `MockMindooDBAppSessionController.applyRemoteUpdate`.
+     */
+    applyRemoteUpdate(databaseId: string, docId: string, input: MindooDBAppUpdateDocumentInput, options?: MockRemoteUpdateOptions): Promise<MindooDBAppDocument>;
     /** Reloads the app frame. The mock data survives; the app's in-memory state does not. */
     reloadApp(): void;
     dispose(): void;
@@ -271,6 +279,8 @@ interface MockDatabasesFromDefinitionOptions {
      * `"none"`: the mock's stateless default.
      */
     attachments?: "memory" | "none";
+    /** Back documents with real Automerge documents (`MockMindooDBAppDatabaseDefinition.automerge`). */
+    automerge?: boolean;
 }
 /**
  * Mock databases for every database a `haven-app.json` declares, granted as requested
@@ -284,10 +294,13 @@ declare function mockDatabasesFromDefinition(definition: Pick<MindooDBAppDefinit
  * - `enforce=1` turns the capability checks on
  * - `users=<count>` fills the directory with generated users
  * - `locale=<tag>`, `theme=dark|light`
+ * - `automerge=1` backs every database with real Automerge documents (concurrent
+ *   `baseHeads` merges, real heads); `automerge=0` turns it off
  */
 interface TestHostUrlSettings {
     overrides: Record<string, MockDatabaseOverride>;
     enforceCapabilities?: boolean;
+    automerge?: boolean;
     directoryUserCount?: number;
     locale?: string;
     theme?: "dark" | "light";
@@ -305,7 +318,7 @@ interface MountHavenTestHostOptions extends Omit<CreateBrowserTestHostOptions, "
         label: string;
     }>;
     /**
-     * Read `db=`, `enforce=`, `users=`, `locale=` and `theme=` from the page URL (see
+     * Read `db=`, `enforce=`, `users=`, `locale=`, `theme=` and `automerge=` from the page URL (see
      * {@link readTestHostUrlSettings}) and keep the URL in sync with the panel. Default
      * true. URL settings win over the options passed here.
      */
@@ -413,6 +426,22 @@ interface MockMindooDBAppDatabaseDefinition {
      * results the same way they would in Haven.
      */
     summarySetup?: MindooDBAppSummarySetup | null;
+    /**
+     * Back every document with a real Automerge document, like Haven: `update`
+     * applies `set`/`unset`, `json` (at `json.baseHeads`) and `text` patches as
+     * Automerge changes, heads are real Automerge heads, and `applyRemoteUpdate`
+     * on the controller writes as another device so concurrent edits truly
+     * merge. Off by default (plain JSON with `mock-head-N` heads).
+     */
+    automerge?: boolean;
+}
+/** Options of `applyRemoteUpdate`. */
+interface MockRemoteUpdateOptions {
+    /**
+     * Automerge actor id (hex) of the simulated device. Defaults to one fixed
+     * "remote" actor; pass different ids to simulate several devices.
+     */
+    actor?: string;
 }
 /**
  * Stands in for the host-owned sealed channel.
@@ -497,6 +526,15 @@ interface MockMindooDBAppSessionController {
     setEnforceCapabilities(enforce: boolean): void;
     /** Replaces the directory's usernames (see `directoryUsers`). */
     setDirectoryUsers(users: readonly string[]): void;
+    /**
+     * Writes `input` to a document as another device would, then syncs it in:
+     * live queries update like after any write. With `automerge: true` on the
+     * database the edit is made by a different Automerge actor on the history
+     * up to `input.json.baseHeads` (the current state when omitted) and merged,
+     * so it is truly concurrent to app writes at the same heads. Without it, it
+     * is a plain update. Bypasses capability checks (it is not the app writing).
+     */
+    applyRemoteUpdate(databaseId: string, docId: string, input: MindooDBAppUpdateDocumentInput, options?: MockRemoteUpdateOptions): Promise<MindooDBAppDocument>;
     emitThemeChange(theme: MindooDBAppHostTheme): void;
     emitViewportChange(viewport: MindooDBAppViewport): void;
     emitUiPreferencesChange(uiPreferences: MindooDBAppUiPreferences): void;
@@ -622,6 +660,8 @@ interface FakeBridgeHostController {
     /** See {@link CreateMockMindooDBAppSessionOptions.directoryUsers}. */
     setDirectoryUsers(users: readonly string[]): void;
     getDirectoryUsers(): string[];
+    /** See {@link MockMindooDBAppSessionController.applyRemoteUpdate}. */
+    applyRemoteUpdate(databaseId: string, docId: string, input: MindooDBAppUpdateDocumentInput, options?: MockRemoteUpdateOptions): Promise<MindooDBAppDocument>;
     /** Embeds the app has open (`session.embeds.open`). */
     listEmbeds(): MockEmbedState[];
     /** Closes an embed and pushes the `embed-event` to the app. */
@@ -647,4 +687,4 @@ interface FakeBridgeHostController {
 }
 declare function createFakeBridgeHost(options?: CreateFakeBridgeHostOptions): FakeBridgeHostController;
 
-export { ALL_CAPABILITIES, type BrowserTestHost, type BrowserTestHostLog, type BrowserTestHostScan, type BrowserTestHostScanMode, type CreateBrowserTestHostOptions, type CreateFakeBridgeHostOptions, type CreateMockMindooDBAppSessionOptions, type EvaluatingViewDocument, type FakeBridgeHostController, type FakeBridgePortMessageHandler, type FakeBridgeRequestHandler, type FakeBridgeRpcResponse, type MockAgentCall, type MockAgentCallResult, type MockAgentConsent, type MockAgentFile, type MockAgentHost, type MockAgentHostController, type MockAgentHostOptions, type MockDatabaseOverride, type MockDatabasesFromDefinitionOptions, type MockEmbedState, type MockEmbeddingFinish, MockForbiddenError, type MockIncomingContentInput, type MockMindooDBAppDatabaseDefinition, type MockMindooDBAppSessionController, type MockSealedChannelOptions, type MockSeedDocument, type MountHavenTestHostOptions, TEST_HOST_LOCALES, type TestHostUrlSettings, capabilitiesForDefinitionPermissions, createBrowserTestHost, createEvaluatingViewNavigator, createFakeBridgeHost, createMemoryAttachments, createMockAgentHost, createMockMindooDBAppBridge, createMockMindooDBAppSession, generateDirectoryUsers, loadMindoodbForTesting, mockAgentToolPrefix, mockDatabasesFromDefinition, mountHavenTestHost, previewJson, readTestHostUrlSettings, validateMockAgentTools };
+export { ALL_CAPABILITIES, type BrowserTestHost, type BrowserTestHostLog, type BrowserTestHostScan, type BrowserTestHostScanMode, type CreateBrowserTestHostOptions, type CreateFakeBridgeHostOptions, type CreateMockMindooDBAppSessionOptions, type EvaluatingViewDocument, type FakeBridgeHostController, type FakeBridgePortMessageHandler, type FakeBridgeRequestHandler, type FakeBridgeRpcResponse, type MockAgentCall, type MockAgentCallResult, type MockAgentConsent, type MockAgentFile, type MockAgentHost, type MockAgentHostController, type MockAgentHostOptions, type MockDatabaseOverride, type MockDatabasesFromDefinitionOptions, type MockEmbedState, type MockEmbeddingFinish, MockForbiddenError, type MockIncomingContentInput, type MockMindooDBAppDatabaseDefinition, type MockMindooDBAppSessionController, type MockRemoteUpdateOptions, type MockSealedChannelOptions, type MockSeedDocument, type MountHavenTestHostOptions, TEST_HOST_LOCALES, type TestHostUrlSettings, capabilitiesForDefinitionPermissions, createBrowserTestHost, createEvaluatingViewNavigator, createFakeBridgeHost, createMemoryAttachments, createMockAgentHost, createMockMindooDBAppBridge, createMockMindooDBAppSession, generateDirectoryUsers, loadMindoodbForTesting, mockAgentToolPrefix, mockDatabasesFromDefinition, mountHavenTestHost, previewJson, readTestHostUrlSettings, validateMockAgentTools };

package/dist/testing/index.js

@@ -173,24 +173,24 @@ async function buildVirtualView(mindoodb, definition, documents, categorizationS
         break;
     }
   }
-  const view = await builder.build();
+  const view2 = await builder.build();
   const changes = /* @__PURE__ */ new Map();
   for (const document2 of documents) {
     if (!matchesFilter(mindoodb, definition, document2)) {
       continue;
     }
-    const change = changes.get(document2.origin) ?? new mindoodb.VirtualViewDataChange(document2.origin);
-    change.addEntry(document2.docId, computeColumnValues(definition, document2));
-    changes.set(document2.origin, change);
+    const change2 = changes.get(document2.origin) ?? new mindoodb.VirtualViewDataChange(document2.origin);
+    change2.addEntry(document2.docId, computeColumnValues(definition, document2));
+    changes.set(document2.origin, change2);
   }
-  for (const change of changes.values()) {
-    if (change.hasChanges()) view.applyChanges(change);
+  for (const change2 of changes.values()) {
+    if (change2.hasChanges()) view2.applyChanges(change2);
   }
-  view.getRoot();
-  return view;
+  view2.getRoot();
+  return view2;
 }
-function createCoreNavigator(mindoodb, view, options) {
-  const builder = mindoodb.VirtualViewFactory.createNavigator(view);
+function createCoreNavigator(mindoodb, view2, options) {
+  const builder = mindoodb.VirtualViewFactory.createNavigator(view2);
   const includeCategories = options?.includeCategories ?? true;
   const includeDocuments = options?.includeDocuments ?? true;
   if (!includeCategories && includeDocuments) builder.documentsOnly();
@@ -199,7 +199,7 @@ function createCoreNavigator(mindoodb, view, options) {
   if (Array.isArray(options?.rootCategoryPath) && options.rootCategoryPath.length > 0) {
     builder.fromCategory(options.rootCategoryPath.map((part) => String(part)).join("\\"));
   } else if (options?.rootEntryKey) {
-    const temp = mindoodb.VirtualViewFactory.createSimpleNavigator(view);
+    const temp = mindoodb.VirtualViewFactory.createSimpleNavigator(view2);
     const rootEntry = temp.getPos(options.rootEntryKey);
     if (rootEntry) builder.fromEntry(rootEntry);
   }
@@ -447,13 +447,13 @@ function collectSortedDocIds(entries) {
 async function createEvaluatingViewNavigator(input, documents) {
   const mindoodb = await loadMindoodbForTesting();
   if (!mindoodb) return null;
-  const view = await buildVirtualView(
+  const view2 = await buildVirtualView(
     mindoodb,
     input.definition,
     documents,
     input.categorizationStyle
   );
-  const navigator2 = createCoreNavigator(mindoodb, view, input.options);
+  const navigator2 = createCoreNavigator(mindoodb, view2, input.options);
   return wrapNavigator(input.definition, navigator2);
 }
 
@@ -1170,6 +1170,7 @@ function mockDatabasesFromDefinition(definition, seed = {}, options = {}) {
         capabilities: override?.capabilities ? [...new Set(override.capabilities)] : capabilitiesForDefinitionPermissions(database.permissions)
       },
       documents: seed[database.logicalDatabaseId],
+      ...options.automerge ? { automerge: true } : {},
       ...options.attachments === "none" ? {} : { methods: { attachments: createMemoryAttachments() } }
     };
   });
@@ -1190,6 +1191,8 @@ function readTestHostUrlSettings(search) {
   }
   const enforce = params.get("enforce");
   if (enforce !== null) settings.enforceCapabilities = enforce === "1" || enforce === "true";
+  const automerge = params.get("automerge");
+  if (automerge !== null) settings.automerge = automerge === "1" || automerge === "true";
   const users = Number.parseInt(params.get("users") ?? "", 10);
   if (Number.isFinite(users) && users >= 0) settings.directoryUserCount = users;
   const locale = params.get("locale");
@@ -1387,6 +1390,11 @@ function createBrowserTestHost(options) {
       host.setDirectoryUsers(users);
       onChange?.();
     },
+    async applyRemoteUpdate(databaseId, docId, input, updateOptions) {
+      const document2 = await host.applyRemoteUpdate(databaseId, docId, input, updateOptions);
+      onChange?.();
+      return document2;
+    },
     reloadApp,
     dispose() {
       window.removeEventListener("message", onMessage);
@@ -1498,7 +1506,7 @@ function mountHavenTestHost(options) {
   const databases = (hostOptions.databases ?? []).filter((database) => url.overrides[database.info.id]?.mapped !== false).map((database) => {
     const capabilities = url.overrides[database.info.id]?.capabilities;
     return capabilities ? { ...database, info: { ...database.info, capabilities } } : database;
-  });
+  }).map((database) => url.automerge === void 0 ? database : { ...database, automerge: url.automerge });
   const launchContext = {
     ...hostOptions.launchContext,
     ...url.locale ? { locale: url.locale } : {},
@@ -2343,23 +2351,23 @@ function mergeLaunchContext(current, patch) {
         ...database,
         capabilities: [...database.capabilities]
       })),
-      views: current.views.map((view) => ({
-        ...view,
-        sources: view.sources.map((source) => ({ ...source })),
-        columns: view.columns.map((column) => ({
+      views: current.views.map((view2) => ({
+        ...view2,
+        sources: view2.sources.map((source) => ({ ...source })),
+        columns: view2.columns.map((column) => ({
           ...column,
           expression: column.expression.mode === "field" ? { ...column.expression } : {
             mode: "formula",
             expression: structuredClone(column.expression.expression)
           }
         })),
-        filter: view.filter.mode === "rules" ? {
+        filter: view2.filter.mode === "rules" ? {
           mode: "rules",
-          match: view.filter.match,
-          rules: view.filter.rules.map((rule) => ({ ...rule }))
+          match: view2.filter.match,
+          rules: view2.filter.rules.map((rule) => ({ ...rule }))
         } : {
           mode: "formula",
-          expression: structuredClone(view.filter.expression)
+          expression: structuredClone(view2.filter.expression)
         }
       }))
     };
@@ -2381,41 +2389,41 @@ function mergeLaunchContext(current, patch) {
       ...database,
       capabilities: [...database.capabilities]
     })),
-    views: patch.views ? patch.views.map((view) => ({
-      ...view,
-      sources: view.sources.map((source) => ({ ...source })),
-      columns: view.columns.map((column) => ({
+    views: patch.views ? patch.views.map((view2) => ({
+      ...view2,
+      sources: view2.sources.map((source) => ({ ...source })),
+      columns: view2.columns.map((column) => ({
         ...column,
         expression: column.expression.mode === "field" ? { ...column.expression } : {
           mode: "formula",
           expression: structuredClone(column.expression.expression)
         }
       })),
-      filter: view.filter.mode === "rules" ? {
+      filter: view2.filter.mode === "rules" ? {
         mode: "rules",
-        match: view.filter.match,
-        rules: view.filter.rules.map((rule) => ({ ...rule }))
+        match: view2.filter.match,
+        rules: view2.filter.rules.map((rule) => ({ ...rule }))
       } : {
         mode: "formula",
-        expression: structuredClone(view.filter.expression)
+        expression: structuredClone(view2.filter.expression)
       }
-    })) : current.views.map((view) => ({
-      ...view,
-      sources: view.sources.map((source) => ({ ...source })),
-      columns: view.columns.map((column) => ({
+    })) : current.views.map((view2) => ({
+      ...view2,
+      sources: view2.sources.map((source) => ({ ...source })),
+      columns: view2.columns.map((column) => ({
         ...column,
         expression: column.expression.mode === "field" ? { ...column.expression } : {
           mode: "formula",
           expression: structuredClone(column.expression.expression)
         }
       })),
-      filter: view.filter.mode === "rules" ? {
+      filter: view2.filter.mode === "rules" ? {
         mode: "rules",
-        match: view.filter.match,
-        rules: view.filter.rules.map((rule) => ({ ...rule }))
+        match: view2.filter.match,
+        rules: view2.filter.rules.map((rule) => ({ ...rule }))
       } : {
         mode: "formula",
-        expression: structuredClone(view.filter.expression)
+        expression: structuredClone(view2.filter.expression)
       }
     }))
   };
@@ -2506,9 +2514,12 @@ function mockDecryptionKeyId(document2) {
   }
   return { decryptionKeyId: document2.decryptionKeyId };
 }
-function loadMockAutomergeDocument(document2) {
+function loadMockAutomergeDocument(document2, actor) {
   if (document2.automergeBinary) {
-    return Automerge.load(document2.automergeBinary);
+    return Automerge.load(
+      document2.automergeBinary,
+      actor ? { actor } : void 0
+    );
   }
   const initialDoc = Automerge.from({
     ...structuredClone(document2.data),
@@ -2519,9 +2530,401 @@ function loadMockAutomergeDocument(document2) {
 }
 function persistMockAutomergeDocument(document2, automergeDoc) {
   document2.automergeBinary = Automerge.save(automergeDoc);
-  document2.data = structuredClone(automergeDoc);
+  document2.data = projectMockAutomergeValue(
+    Automerge.load(document2.automergeBinary)
+  );
   document2.heads = Automerge.getHeads(automergeDoc);
 }
+var MOCK_AUTOMERGE_SEED_ACTOR = "5eed0000000000000000000000000000";
+var MOCK_AUTOMERGE_LOCAL_ACTOR = "10ca1000000000000000000000000000";
+var MOCK_AUTOMERGE_REMOTE_ACTOR = "2e307e00000000000000000000000000";
+function projectMockAutomergeValue(value, depth = 0) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Automerge.isCounter(value)) {
+    return value.value;
+  }
+  if (Automerge.isImmutableString(value)) {
+    return String(value);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof Uint8Array) {
+    return value.slice();
+  }
+  if (depth > 100) {
+    throw new Error("Document value is nested too deeply");
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => projectMockAutomergeValue(entry, depth + 1));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      projectMockAutomergeValue(entry, depth + 1)
+    ])
+  );
+}
+function hydrateMockAutomergeValues(value, depth = 0) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (depth > 100) {
+    throw new Error("Document value is nested too deeply");
+  }
+  if (value instanceof Uint8Array || value instanceof Date || Automerge.isCounter(value) || Automerge.isImmutableString(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => entry === void 0 ? null : hydrateMockAutomergeValues(entry, depth + 1)
+    );
+  }
+  const record = value;
+  if (Object.prototype.hasOwnProperty.call(record, MINDOODB_APP_VALUE_TAG)) {
+    switch (record[MINDOODB_APP_VALUE_TAG]) {
+      case "atomic":
+        if (typeof record.value !== "string") {
+          throw new Error('Typed value "atomic" needs a string value');
+        }
+        return new Automerge.ImmutableString(record.value);
+      case "counter":
+        assertMockCounterAmount(record.value, 'Typed value "counter"');
+        return new Automerge.Counter(record.value);
+      case "timestamp":
+        return new Date(toMockTimestamp(record.value));
+      default:
+        throw new Error(
+          `Unknown typed value ${JSON.stringify(record[MINDOODB_APP_VALUE_TAG])}; the "${MINDOODB_APP_VALUE_TAG}" key is reserved`
+        );
+    }
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(record)) {
+    if (entry !== void 0) {
+      result[key] = hydrateMockAutomergeValues(entry, depth + 1);
+    }
+  }
+  return result;
+}
+function createMockAutomergeDocument(values, actor, time) {
+  const entries = Object.entries(values).filter(([, value]) => value !== void 0);
+  const initial = Automerge.init({ actor });
+  const options = time === void 0 ? {} : { time };
+  if (entries.length === 0) {
+    return Automerge.emptyChange(initial, options);
+  }
+  return Automerge.change(initial, options, (doc) => {
+    for (const [key, value] of entries) {
+      doc[key] = hydrateMockAutomergeValues(value);
+    }
+  });
+}
+function validateMockJsonPath(path, label) {
+  if (!Array.isArray(path) || path.length === 0) {
+    throw new Error(`${label} path must contain at least one segment`);
+  }
+  for (const segment of path) {
+    if (typeof segment !== "string" && typeof segment !== "number") {
+      throw new Error(`${label} path segments must be strings or numbers`);
+    }
+  }
+}
+function assertMockNonNegativeInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+}
+function validateMockJsonPatch(patch) {
+  const operationCount = (patch.set?.length ?? 0) + (patch.unset?.length ?? 0) + (patch.listDelete?.length ?? 0) + (patch.listInsert?.length ?? 0) + (patch.textSplice?.length ?? 0) + (patch.textMark?.length ?? 0) + (patch.textUnmark?.length ?? 0) + (patch.counterIncrement?.length ?? 0);
+  if (operationCount === 0) {
+    throw new Error("JSON patch must include at least one operation");
+  }
+  for (const operation of patch.set ?? []) {
+    validateMockJsonPath(operation.path, "JSON set");
+    hydrateMockAutomergeValues(operation.value);
+  }
+  for (const operation of patch.unset ?? []) {
+    validateMockJsonPath(operation.path, "JSON unset");
+  }
+  for (const operation of patch.listDelete ?? []) {
+    validateMockJsonPath(operation.path, "JSON listDelete");
+    assertMockNonNegativeInteger(operation.index, "JSON listDelete index");
+    assertMockNonNegativeInteger(operation.deleteCount, "JSON listDelete deleteCount");
+  }
+  for (const operation of patch.listInsert ?? []) {
+    validateMockJsonPath(operation.path, "JSON listInsert");
+    assertMockNonNegativeInteger(operation.index, "JSON listInsert index");
+    if (!Array.isArray(operation.values)) {
+      throw new Error("JSON listInsert values must be an array");
+    }
+    hydrateMockAutomergeValues(operation.values);
+  }
+  for (const operation of patch.textSplice ?? []) {
+    validateMockJsonPath(operation.path, "JSON textSplice");
+    assertMockNonNegativeInteger(operation.index, "JSON textSplice index");
+    assertMockNonNegativeInteger(operation.deleteCount, "JSON textSplice deleteCount");
+    if (operation.insert !== void 0 && typeof operation.insert !== "string") {
+      throw new Error("JSON textSplice insert must be a string");
+    }
+  }
+  for (const operation of [...patch.textMark ?? [], ...patch.textUnmark ?? []]) {
+    validateMockJsonPath(operation.path, "JSON text mark");
+    assertMockNonNegativeInteger(operation.index, "JSON text mark index");
+    if (!Number.isInteger(operation.length) || operation.length <= 0) {
+      throw new Error("JSON text mark length must be a positive integer");
+    }
+  }
+  for (const operation of patch.counterIncrement ?? []) {
+    validateMockJsonPath(operation.path, "JSON counterIncrement");
+    assertMockCounterAmount(operation.delta, "JSON counterIncrement delta");
+  }
+}
+function ensureMockAutomergeParent(target, path) {
+  let parent = target;
+  for (let index = 0; index < path.length - 1; index += 1) {
+    const segment = path[index];
+    const nextSegment = path[index + 1];
+    if (parent[segment] === void 0 || parent[segment] === null) {
+      parent[segment] = typeof nextSegment === "number" ? [] : {};
+    }
+    parent = parent[segment];
+    if (parent === null || typeof parent !== "object") {
+      throw new Error(
+        `Cannot apply JSON patch through non-object path segment '${String(segment)}'`
+      );
+    }
+  }
+  return parent;
+}
+function readMockAutomergeValue(target, path) {
+  let value = target;
+  for (const segment of path) {
+    value = value?.[segment];
+  }
+  return value;
+}
+function setMockAutomergeValue(target, path, value) {
+  const parent = ensureMockAutomergeParent(target, path);
+  parent[path[path.length - 1]] = value;
+}
+function unsetMockAutomergeValue(target, path) {
+  let parent = target;
+  for (let index = 0; index < path.length - 1; index += 1) {
+    parent = parent?.[path[index]];
+    if (parent === null || typeof parent !== "object") {
+      return;
+    }
+  }
+  delete parent[path[path.length - 1]];
+}
+function readMockAutomergeList(target, path) {
+  const value = readMockAutomergeValue(target, path);
+  if (!Array.isArray(value)) {
+    throw new Error(
+      `Cannot apply JSON list operation to non-array value at '${path.map(String).join(".")}'`
+    );
+  }
+  return value;
+}
+function ensureMockAutomergeList(target, path) {
+  const parent = ensureMockAutomergeParent(target, path);
+  const leaf = path[path.length - 1];
+  if (parent[leaf] === void 0 || parent[leaf] === null) {
+    parent[leaf] = [];
+  }
+  return readMockAutomergeList(target, path);
+}
+function clampMockIndex(index, length) {
+  if (!Number.isFinite(index)) {
+    return length;
+  }
+  return Math.max(0, Math.min(Math.trunc(index), length));
+}
+function ensureMockAutomergeText(target, path, label) {
+  const value = readMockAutomergeValue(target, path);
+  if (value === void 0 || value === null) {
+    setMockAutomergeValue(target, path, "");
+  } else if (typeof value !== "string") {
+    throw new Error(
+      `Cannot apply ${label} to non-string value at '${path.map(String).join(".")}'`
+    );
+  }
+}
+function spliceMockAutomergeText(target, path, index, deleteCount, insert) {
+  const text = readMockAutomergeValue(target, path);
+  const length = typeof text === "string" ? text.length : 0;
+  const start = clampMockIndex(index, length);
+  Automerge.splice(
+    target,
+    path,
+    start,
+    Math.max(0, Math.min(deleteCount, length - start)),
+    insert
+  );
+}
+function reviveMockRichTextValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => reviveMockRichTextValue(entry));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const record = value;
+  if (record.type === "immutableString" && typeof record.value === "string") {
+    return new Automerge.ImmutableString(record.value);
+  }
+  return Object.fromEntries(
+    Object.entries(record).map(([key, entry]) => [key, reviveMockRichTextValue(entry)])
+  );
+}
+function applyMockAutomergeJsonOperations(target, patch) {
+  for (const operation of patch.set ?? []) {
+    setMockAutomergeValue(target, operation.path, hydrateMockAutomergeValues(operation.value));
+  }
+  for (const operation of patch.unset ?? []) {
+    unsetMockAutomergeValue(target, operation.path);
+  }
+  for (const operation of patch.listDelete ?? []) {
+    readMockAutomergeList(target, operation.path).splice(operation.index, operation.deleteCount);
+  }
+  for (const operation of patch.listInsert ?? []) {
+    ensureMockAutomergeList(target, operation.path).splice(
+      operation.index,
+      0,
+      ...hydrateMockAutomergeValues(operation.values)
+    );
+  }
+  for (const operation of patch.textSplice ?? []) {
+    ensureMockAutomergeText(target, operation.path, "JSON textSplice");
+    spliceMockAutomergeText(
+      target,
+      operation.path,
+      operation.index,
+      operation.deleteCount,
+      operation.insert ?? ""
+    );
+  }
+  for (const operation of patch.textMark ?? []) {
+    for (const [name, value] of Object.entries(operation.marks)) {
+      Automerge.mark(
+        target,
+        operation.path,
+        { start: operation.index, end: operation.index + operation.length, expand: "none" },
+        name,
+        reviveMockRichTextValue(value)
+      );
+    }
+  }
+  for (const operation of patch.textUnmark ?? []) {
+    for (const name of operation.names) {
+      Automerge.unmark(
+        target,
+        operation.path,
+        { start: operation.index, end: operation.index + operation.length, expand: "none" },
+        name
+      );
+    }
+  }
+  for (const operation of patch.counterIncrement ?? []) {
+    const parent = ensureMockAutomergeParent(target, operation.path);
+    const leaf = operation.path[operation.path.length - 1];
+    const existing = parent[leaf];
+    if (existing === void 0 || existing === null) {
+      parent[leaf] = new Automerge.Counter(operation.delta);
+    } else if (Automerge.isCounter(existing)) {
+      existing.increment(operation.delta);
+    } else {
+      throw new Error(
+        `Cannot increment non-counter value at '${operation.path.map(String).join(".")}'; create it with MindooValue.counter() first`
+      );
+    }
+  }
+}
+function changeMockAutomergeDocument(doc, baseHeads, apply) {
+  if (baseHeads && baseHeads.length > 0) {
+    const { newDoc } = Automerge.changeAt(doc, baseHeads, apply);
+    return Automerge.load(Automerge.save(newDoc), { actor: Automerge.getActorId(doc) });
+  }
+  return Automerge.change(doc, apply);
+}
+function applyMockAutomergeUpdate(doc, patch) {
+  let next = doc;
+  if (patch.set || (patch.unset?.length ?? 0) > 0) {
+    next = Automerge.change(next, (target) => {
+      for (const [key, value] of Object.entries(patch.set ?? {})) {
+        if (value !== void 0) {
+          target[key] = hydrateMockAutomergeValues(value);
+        }
+      }
+      for (const key of patch.unset ?? []) {
+        delete target[key];
+      }
+    });
+  }
+  if (patch.json) {
+    const json = patch.json;
+    validateMockJsonPatch(json);
+    next = changeMockAutomergeDocument(
+      next,
+      json.baseHeads,
+      (target) => applyMockAutomergeJsonOperations(target, json)
+    );
+  }
+  for (const textPatch of patch.text ?? []) {
+    validateMockJsonPath(textPatch.path, "Text patch");
+    next = changeMockAutomergeDocument(next, textPatch.baseHeads, (target) => {
+      ensureMockAutomergeText(target, textPatch.path, "text patch");
+      for (const edit of textPatch.edits) {
+        spliceMockAutomergeText(target, textPatch.path, edit.index, edit.deleteCount, edit.insert ?? "");
+      }
+    });
+  }
+  for (const richTextPatch of patch.richText ?? []) {
+    validateMockJsonPath(richTextPatch.path, "Rich-text patch");
+    const spans = richTextPatch.spansSequence?.at(-1) ?? richTextPatch.spans ?? [];
+    next = Automerge.change(next, (target) => {
+      setMockAutomergeValue(target, richTextPatch.path, hydrateMockAutomergeValues(structuredClone(spans)));
+    });
+  }
+  for (const stepPatch of patch.richTextSteps ?? []) {
+    validateMockJsonPath(stepPatch.path, "Rich-text steps patch");
+    next = changeMockAutomergeDocument(next, stepPatch.baseHeads, (target) => {
+      const current = readMockAutomergeValue(target, stepPatch.path);
+      if (current !== void 0 && current !== null && typeof current !== "string") {
+        setMockAutomergeValue(
+          target,
+          stepPatch.path,
+          materializeMockRichTextValue(projectMockAutomergeValue(current))
+        );
+      }
+      ensureMockAutomergeText(target, stepPatch.path, "rich-text steps");
+      for (const step of stepPatch.steps) {
+        spliceMockAutomergeText(target, stepPatch.path, step.index, step.deleteCount, step.insert ?? "");
+      }
+    });
+  }
+  return next;
+}
+function forkMockAutomergeDocument(doc, baseHeads, actor) {
+  if (!baseHeads || baseHeads.length === 0) {
+    return Automerge.clone(doc, { actor });
+  }
+  const heads = new Set(baseHeads);
+  let ownLatest;
+  for (const change2 of Automerge.getAllChanges(doc)) {
+    const decoded = Automerge.decodeChange(change2);
+    if (decoded.actor === actor) {
+      ownLatest = decoded.hash;
+    }
+  }
+  if (ownLatest) {
+    heads.add(ownLatest);
+  }
+  return Automerge.clone(Automerge.view(doc, [...heads]), { actor });
+}
 function getFieldValue2(source, field) {
   return field.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
@@ -3374,9 +3777,17 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
   let createCounter = 0;
   let changeCounter = 0;
   const defaultViewFactory = async () => createDefaultViewNavigator();
-  const storedDocuments = /* @__PURE__ */ new Map();
+  const automergeMode = definition.automerge === true;
+  let changeSequence = 0;
+  const changedAt = /* @__PURE__ */ new Map();
+  const storedDocuments = new class extends Map {
+    set(id, document2) {
+      changedAt.set(id, ++changeSequence);
+      return super.set(id, document2);
+    }
+  }();
   for (const seed of definition.documents ?? []) {
-    storedDocuments.set(seed.id, {
+    const stored = {
       id: seed.id,
       data: structuredClone(seed.data),
       heads: seed.heads ? [...seed.heads] : void 0,
@@ -3387,7 +3798,14 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       decryptionKeyId: seed.decryptionKeyId,
       authorLabel: seed.authorLabel,
       createdAt: seed.createdAt
-    });
+    };
+    if (automergeMode) {
+      persistMockAutomergeDocument(
+        stored,
+        createMockAutomergeDocument(seed.data, MOCK_AUTOMERGE_SEED_ACTOR, 0)
+      );
+    }
+    storedDocuments.set(seed.id, stored);
   }
   const liveQuerySubscriptions = /* @__PURE__ */ new Set();
   const refreshLiveQueries = () => {
@@ -3430,6 +3848,15 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       throw new Error("Recipient mutators require a document created with `recipients`");
     }
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (automergeMode) {
+      return writeAutomergeDocument(
+        docId,
+        existing,
+        Automerge.change(loadMockAutomergeDocument(existing, MOCK_AUTOMERGE_LOCAL_ACTOR), (target) => {
+          target._encryptFor = hydrateMockAutomergeValues(nextEncryptFor);
+        })
+      );
+    }
     const updated = {
       id: docId,
       data: { ...existing.data, _encryptFor: nextEncryptFor },
@@ -3448,6 +3875,28 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     notifyLiveQueries();
     return updated;
   }
+  function writeAutomergeDocument(docId, existing, automergeDoc) {
+    const stored = {
+      ...existing ?? {},
+      id: docId,
+      data: {},
+      attachments: existing?.attachments ? structuredClone(existing.attachments) : [],
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isDeleted: false,
+      decryptionKeyId: existing?.decryptionKeyId ?? "default"
+    };
+    persistMockAutomergeDocument(stored, automergeDoc);
+    storedDocuments.set(docId, stored);
+    notifyLiveQueries();
+    return {
+      id: docId,
+      data: structuredClone(stored.data),
+      heads: [...stored.heads ?? []],
+      attachments: structuredClone(stored.attachments ?? []),
+      updatedAt: stored.updatedAt,
+      ...mockDecryptionKeyId(stored)
+    };
+  }
   const defaultDocuments = {
     async query(query) {
       return runMockDocumentQuery(
@@ -3500,12 +3949,17 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       const offset = decodeMockListCursor(query?.cursor) + skip;
       const metadataOnly = query?.metadataOnly ?? false;
       const idPrefix = query?.idPrefix;
-      const items = Array.from(storedDocuments.values()).filter((document2) => !document2.inaccessible).filter(
+      const after = automergeMode ? decodeMockListCursor(query?.cursor) : 0;
+      const items = Array.from(storedDocuments.values()).filter((document2) => !automergeMode || (changedAt.get(document2.id) ?? 0) > after).filter((document2) => !document2.inaccessible).filter(
         (document2) => status === "all" ? true : status === "deleted" ? document2.isDeleted : !document2.isDeleted
       ).filter((document2) => matchesMockIdPrefix(document2.id, idPrefix)).filter(
         (document2) => metadataOnly ? true : matchesDocumentFilter(document2, query?.filter)
-      ).sort((left, right) => left.id.localeCompare(right.id));
-      const page = items.slice(offset, offset + limit).map((document2) => {
+      ).sort(
+        (left, right) => automergeMode ? (changedAt.get(left.id) ?? 0) - (changedAt.get(right.id) ?? 0) : left.id.localeCompare(right.id)
+      );
+      const pageStart = automergeMode ? skip : offset;
+      const pageDocuments = items.slice(pageStart, pageStart + limit);
+      const page = pageDocuments.map((document2) => {
         if (metadataOnly) {
           return {
             id: document2.id,
@@ -3526,6 +3980,13 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           isDeleted: status !== "existing" ? document2.isDeleted : void 0
         };
       });
+      if (automergeMode) {
+        const last = pageDocuments[pageDocuments.length - 1];
+        return {
+          items: page,
+          nextCursor: last ? String(changedAt.get(last.id) ?? after) : null
+        };
+      }
       const nextCursor = offset + page.length < items.length ? String(offset + page.length) : null;
       return {
         items: page,
@@ -3534,7 +3995,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     },
     async getHeadCursor() {
       return {
-        cursor: String(storedDocuments.size)
+        cursor: String(automergeMode ? changeSequence : storedDocuments.size)
       };
     },
     async listInaccessible(query) {
@@ -3630,7 +4091,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       const currentDoc = loadMockAutomergeDocument(document2);
       const [mergedDoc] = Automerge.applyChanges(
         currentDoc,
-        patch.changes.map((change) => new Uint8Array(change))
+        patch.changes.map((change2) => new Uint8Array(change2))
       );
       persistMockAutomergeDocument(document2, mergedDoc);
       document2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -3643,7 +4104,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
         );
         changesSince = {
           sinceHeads: [...patch.replicaHeads],
-          changes: missingChanges.map((change) => cloneBytes(new Uint8Array(change)))
+          changes: missingChanges.map((change2) => cloneBytes(new Uint8Array(change2)))
         };
       }
       return {
@@ -3680,7 +4141,10 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           if (existing.isDeleted) {
             existing.isDeleted = false;
             existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            existing.heads = [`mock-head-${++changeCounter}`];
+            if (!automergeMode) {
+              existing.heads = [`mock-head-${++changeCounter}`];
+            }
+            storedDocuments.set(callerId, existing);
             notifyLiveQueries();
           }
           return {
@@ -3709,11 +4173,39 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
           "recipients: [] with includeSelf: false would produce a document nobody can read"
         );
       }
+      const encryptFor = Array.isArray(input.recipients) ? { _encryptFor: mockEncryptForMap(input.recipients) } : {};
+      if (automergeMode) {
+        const stored2 = {
+          id,
+          data: {},
+          attachments: [],
+          updatedAt: createdAt,
+          isDeleted: false,
+          decryptionKeyId: input.decryptionKeyId ?? "default"
+        };
+        persistMockAutomergeDocument(
+          stored2,
+          createMockAutomergeDocument(
+            { ...input.set ?? {}, ...encryptFor },
+            MOCK_AUTOMERGE_LOCAL_ACTOR
+          )
+        );
+        storedDocuments.set(id, stored2);
+        notifyLiveQueries();
+        return {
+          id,
+          data: structuredClone(stored2.data),
+          heads: [...stored2.heads ?? []],
+          attachments: [],
+          updatedAt: createdAt,
+          ...mockDecryptionKeyId(stored2)
+        };
+      }
       const created = {
         id,
         data: {
           ...readMockTypedValues(input.set ?? {}),
-          ...Array.isArray(input.recipients) ? { _encryptFor: mockEncryptForMap(input.recipients) } : {}
+          ...encryptFor
         },
         heads: [`mock-head-${++changeCounter}`],
         attachments: [],
@@ -3744,6 +4236,10 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
     async update(docId, patch) {
       const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       const existing = storedDocuments.get(docId);
+      if (automergeMode) {
+        const current = existing?.automergeBinary ? loadMockAutomergeDocument(existing, MOCK_AUTOMERGE_LOCAL_ACTOR) : createMockAutomergeDocument(existing?.data ?? {}, MOCK_AUTOMERGE_LOCAL_ACTOR);
+        return writeAutomergeDocument(docId, existing, applyMockAutomergeUpdate(current, patch));
+      }
       const updated = {
         id: docId,
         data: applyDocumentUpdatePatch(existing?.data ?? {}, patch),
@@ -3830,7 +4326,7 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
         storedDocuments.set(_docId, {
           ...existing,
           isDeleted: false,
-          heads: [`mock-head-${++changeCounter}`],
+          heads: automergeMode ? existing.heads : [`mock-head-${++changeCounter}`],
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         notifyLiveQueries();
@@ -4054,7 +4550,26 @@ function createDatabaseHandle(definition, peers, directoryUsers = () => []) {
       createdAt: document2.updatedAt ?? null
     })),
     documents: storedDocuments,
-    notifyLiveQueries: refreshLiveQueries
+    notifyLiveQueries: refreshLiveQueries,
+    async applyRemoteUpdate(docId, input, options) {
+      const existing = storedDocuments.get(docId);
+      if (!existing || existing.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      if (!automergeMode || !existing.automergeBinary) {
+        return await defaultDocuments.update(docId, input);
+      }
+      const current = loadMockAutomergeDocument(existing, MOCK_AUTOMERGE_LOCAL_ACTOR);
+      const remote = applyMockAutomergeUpdate(
+        forkMockAutomergeDocument(
+          current,
+          input.json?.baseHeads,
+          options?.actor ?? MOCK_AUTOMERGE_REMOTE_ACTOR
+        ),
+        input.json ? { ...input, json: { ...input.json, baseHeads: void 0 } } : input
+      );
+      return writeAutomergeDocument(docId, existing, Automerge.merge(current, remote));
+    }
   };
 }
 function createMockSessionState(options = {}) {
@@ -4080,6 +4595,7 @@ function createMockSessionState(options = {}) {
   const databaseViewDocumentLists = /* @__PURE__ */ new Map();
   const databaseDocumentStores = /* @__PURE__ */ new Map();
   const databaseLiveQueryRefreshers = /* @__PURE__ */ new Map();
+  const databaseRemoteUpdaters = /* @__PURE__ */ new Map();
   const databasePeers = {
     getDocuments: (databaseId) => databaseDocumentStores.get(databaseId),
     refreshAllLiveQueries: () => {
@@ -4170,6 +4686,7 @@ function createMockSessionState(options = {}) {
     databaseViewApis.clear();
     databaseDocumentStores.clear();
     databaseLiveQueryRefreshers.clear();
+    databaseRemoteUpdaters.clear();
     databaseInfos = definitions.map((definition) => ({
       ...definition.info,
       capabilities: [...definition.info.capabilities]
@@ -4188,6 +4705,7 @@ function createMockSessionState(options = {}) {
       databaseViewDocumentLists.set(definition.info.id, created.listViewDocuments);
       databaseDocumentStores.set(definition.info.id, created.documents);
       databaseLiveQueryRefreshers.set(definition.info.id, created.notifyLiveQueries);
+      databaseRemoteUpdaters.set(definition.info.id, created.applyRemoteUpdate);
       databaseViewApis.set(definition.info.id, {
         async create(input) {
           const build = () => createEvaluatingViewNavigator(
@@ -4310,10 +4828,10 @@ function createMockSessionState(options = {}) {
           `Unknown test database for view creation: ${firstDatabaseId}`
         );
       }
-      const view = await api.create(input);
+      const view2 = await api.create(input);
       const viewId = input.definition.id || crypto.randomUUID();
-      sessionViews.set(viewId, view);
-      return view;
+      sessionViews.set(viewId, view2);
+      return view2;
     },
     async openViewNavigator(viewId, options2) {
       const existing = sessionViews.get(viewId);
@@ -4321,7 +4839,7 @@ function createMockSessionState(options = {}) {
         return existing;
       }
       const sourceDatabaseId = launchContext.views.find(
-        (view2) => view2.id === viewId
+        (view3) => view3.id === viewId
       )?.sources[0]?.databaseId;
       if (!sourceDatabaseId) {
         throw new Error(`Unknown test view: ${viewId}`);
@@ -4332,9 +4850,9 @@ function createMockSessionState(options = {}) {
           `Unknown test database for view ${viewId}: ${sourceDatabaseId}`
         );
       }
-      const view = await api.open(viewId, options2);
-      sessionViews.set(viewId, view);
-      return view;
+      const view2 = await api.open(viewId, options2);
+      sessionViews.set(viewId, view2);
+      return view2;
     },
     menus,
     drag,
@@ -4471,6 +4989,13 @@ function createMockSessionState(options = {}) {
       }
       return database;
     },
+    async applyRemoteUpdate(databaseId, docId, input, updateOptions) {
+      const applyRemoteUpdate = databaseRemoteUpdaters.get(databaseId);
+      if (!applyRemoteUpdate) {
+        throw new Error(`Unknown test database: ${databaseId}`);
+      }
+      return await applyRemoteUpdate(docId, input, updateOptions);
+    },
     getLicensedProducts() {
       return [...launchContext.licensedProducts ?? []];
     },
@@ -4587,6 +5112,7 @@ function createMockMindooDBAppSession(options = {}) {
     setCapabilities: state.setCapabilities,
     setEnforceCapabilities: state.setEnforceCapabilities,
     setDirectoryUsers: state.setDirectoryUsers,
+    applyRemoteUpdate: state.applyRemoteUpdate,
     emitThemeChange: state.emitThemeChange,
     emitViewportChange: state.emitViewportChange,
     emitUiPreferencesChange: state.emitUiPreferencesChange,
@@ -5529,6 +6055,7 @@ function createFakeBridgeHost(options = {}) {
     getEnforceCapabilities: state.getEnforceCapabilities,
     setDirectoryUsers: state.setDirectoryUsers,
     getDirectoryUsers: state.getDirectoryUsers,
+    applyRemoteUpdate: state.applyRemoteUpdate,
     listEmbeds: () => state.embedHost.listEmbeds(),
     closeEmbed: (embedId, reason, result) => state.embedHost.closeEmbed(embedId, reason, result),
     getEmbeddingFinish: () => state.embedHost.getEmbeddingFinish(),

package/package.json

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