@dxos/echo-pipeline 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/automerge/heads-store.ts

@@ -4,18 +4,45 @@
 
 import type { Heads } from '@automerge/automerge';
 import type { DocumentId } from '@automerge/automerge-repo';
+import { type MixedEncoding } from 'level-transcoder';
 
-import { headsEncoding } from '@dxos/indexing';
+import type { ProtoCodec } from '@dxos/codec-protobuf';
 import type { BatchLevel, SublevelDB } from '@dxos/kv-store';
+import { log } from '@dxos/log';
+import { schema } from '@dxos/protocols/proto';
+import type { Heads as HeadsProto } from '@dxos/protocols/proto/dxos/echo/query';
 
-export type HeadsStoreParams = {
+// NOTE: Lazy so that code that doesn't use indexing doesn't need to load the codec (breaks in workerd).
+let headsCodec: ProtoCodec<HeadsProto>;
+const getHeadsCodec = () => (headsCodec ??= schema.getCodecForType('dxos.echo.query.Heads'));
+
+const headsEncoding: MixedEncoding<Heads, Uint8Array, Heads> = {
+  encode: (value: Heads): Uint8Array => getHeadsCodec().encode({ hashes: value }),
+  decode: (encodedValue: Uint8Array): Heads => {
+    try {
+      return getHeadsCodec().decode(encodedValue).hashes!;
+    } catch {
+      // Legacy encoding migration path.
+      log.warn('Detected legacy encoding of heads in storage.');
+      const concatenatedHeads = Buffer.from(encodedValue).toString('utf8').replace(/"/g, '');
+      const heads = [];
+      for (let i = 0; i < concatenatedHeads.length; i += 64) {
+        heads.push(concatenatedHeads.slice(i, i + 64));
+      }
+      return heads;
+    }
+  },
+  format: 'buffer',
+};
+
+export type HeadsStoreProps = {
   db: SublevelDB;
 };
 
 export class HeadsStore {
   private readonly _db: SublevelDB;
 
-  constructor({ db }: HeadsStoreParams) {
+  constructor({ db }: HeadsStoreProps) {
     this._db = db;
   }
 
@@ -34,4 +61,16 @@ export class HeadsStore {
       valueEncoding: headsEncoding,
     });
   }
+
+  /**
+   * Iterate over all document IDs and their heads.
+   */
+  async *iterateAll(): AsyncGenerator<{ documentId: DocumentId; heads: Heads }> {
+    for await (const [documentId, heads] of this._db.iterator<DocumentId, Heads>({
+      keyEncoding: 'utf8',
+      valueEncoding: headsEncoding,
+    })) {
+      yield { documentId, heads };
+    }
+  }
 }

package/src/automerge/index.ts

@@ -3,9 +3,11 @@
 //
 
 export * from './automerge-host';
+export * from './handle-state';
 export * from './leveldb-storage-adapter';
 export * from './mesh-echo-replicator';
 export type * from './echo-replicator';
 export { diffCollectionState } from './collection-synchronizer';
 export * from './space-collection';
 export * from './echo-data-monitor';
+export * from './errors';

package/src/automerge/leveldb-storage-adapter.ts

@@ -16,24 +16,53 @@ export interface StorageAdapterDataMonitor {
   recordStoreDuration(durationMs: number): void;
 }
 
-export type LevelDBStorageAdapterParams = {
+export type LevelDBStorageAdapterProps = {
   db: SublevelDB;
   callbacks?: StorageCallbacks;
   monitor?: StorageAdapterDataMonitor;
 };
 
-export type BeforeSaveParams = { path: StorageKey; batch: BatchLevel };
+export type BeforeSaveProps = { path: StorageKey; batch: BatchLevel };
 
 export interface StorageCallbacks {
-  beforeSave(params: BeforeSaveParams): MaybePromise<void>;
+  beforeSave(params: BeforeSaveProps): MaybePromise<void>;
   afterSave(path: StorageKey): MaybePromise<void>;
 }
 
 export class LevelDBStorageAdapter extends Resource implements StorageAdapterInterface {
-  constructor(private readonly _params: LevelDBStorageAdapterParams) {
+  /**
+   * In-flight `loadRange` / `removeRange` iterations. Awaited in `_close` so
+   * the adapter doesn't return from close while a `for await` on the sublevel
+   * is still pending — otherwise the kv owner upstream would close the
+   * sublevel and the iterator's next `.next()` would reject with
+   * `LEVEL_ITERATOR_NOT_OPEN`.
+   *
+   * Promises stored here resolve regardless of outcome (the wrapper
+   * `.catch`es) so `Promise.all` won't reject.
+   */
+  readonly #inFlightIterations = new Set<Promise<unknown>>();
+
+  constructor(private readonly _params: LevelDBStorageAdapterProps) {
     super();
   }
 
+  protected override async _close(): Promise<void> {
+    // New `loadRange`/`removeRange` calls already short-circuit on `!isOpen`
+    // (the Resource base flips state before invoking `_close`). Wait for any
+    // iterations that started while we were still open to finish before
+    // returning, so the upstream `kv` owner can safely close the sublevel.
+    if (this.#inFlightIterations.size > 0) {
+      await Promise.all(this.#inFlightIterations);
+    }
+  }
+
+  #trackIteration<T>(work: Promise<T>): Promise<T> {
+    const settled = work.catch(() => undefined);
+    this.#inFlightIterations.add(settled);
+    void settled.finally(() => this.#inFlightIterations.delete(settled));
+    return work;
+  }
+
   async load(keyArray: StorageKey): Promise<Uint8Array | undefined> {
     try {
       if (!this.isOpen) {
@@ -71,6 +100,35 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
     this._params.monitor?.recordStoreDuration(Date.now() - startMs);
   }
 
+  /**
+   * Atomically persist multiple key/value entries in a single LevelDB batch write.
+   */
+  async saveBatch(entries: Array<[StorageKey, Uint8Array]>): Promise<void> {
+    if (!this.isOpen || entries.length === 0) {
+      return undefined;
+    }
+    const startMs = Date.now();
+    const batch = this._params.db.batch();
+
+    for (const [keyArray] of entries) {
+      await this._params.callbacks?.beforeSave?.({ path: keyArray, batch });
+    }
+    for (const [keyArray, binary] of entries) {
+      batch.put<StorageKey, Uint8Array>(keyArray, Buffer.from(binary), {
+        ...encodingOptions,
+      });
+    }
+    await batch.write();
+
+    let bytesStored = 0;
+    for (const [keyArray, binary] of entries) {
+      bytesStored += binary.byteLength;
+      await this._params.callbacks?.afterSave?.(keyArray);
+    }
+    this._params.monitor?.recordBytesStored(bytesStored);
+    this._params.monitor?.recordStoreDuration(Date.now() - startMs);
+  }
+
   async remove(keyArray: StorageKey): Promise<void> {
     if (!this.isOpen) {
       return undefined;
@@ -82,6 +140,10 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
     if (!this.isOpen) {
       return [];
     }
+    return this.#trackIteration(this.#doLoadRange(keyPrefix));
+  }
+
+  async #doLoadRange(keyPrefix: StorageKey): Promise<Chunk[]> {
     const startMs = Date.now();
     const result: Chunk[] = [];
     for await (const [key, value] of this._params.db.iterator<StorageKey, Uint8Array>({
@@ -103,6 +165,10 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
     if (!this.isOpen) {
       return undefined;
     }
+    await this.#trackIteration(this.#doRemoveRange(keyPrefix));
+  }
+
+  async #doRemoveRange(keyPrefix: StorageKey): Promise<void> {
     const batch = this._params.db.batch();
 
     for await (const [key] of this._params.db.iterator<StorageKey, Uint8Array>({

package/src/automerge/mesh-echo-replicator-connection.ts

@@ -12,20 +12,20 @@ import { log } from '@dxos/log';
 import type { AutomergeProtocolMessage } from '@dxos/protocols';
 import { AutomergeReplicator, type AutomergeReplicatorFactory } from '@dxos/teleport-extension-automerge-replicator';
 
-import type { ReplicatorConnection, ShouldAdvertiseParams, ShouldSyncCollectionParams } from './echo-replicator';
+import type { AutomergeReplicatorConnection, ShouldAdvertiseProps, ShouldSyncCollectionProps } from './echo-replicator';
 
 const DEFAULT_FACTORY: AutomergeReplicatorFactory = (params) => new AutomergeReplicator(...params);
 
-export type MeshReplicatorConnectionParams = {
+export type MeshReplicatorConnectionProps = {
   ownPeerId: string;
   onRemoteConnected: () => void;
   onRemoteDisconnected: () => void;
-  shouldAdvertise: (params: ShouldAdvertiseParams) => Promise<boolean>;
-  shouldSyncCollection: (params: ShouldSyncCollectionParams) => boolean;
+  shouldAdvertise: (params: ShouldAdvertiseProps) => Promise<boolean>;
+  shouldSyncCollection: (params: ShouldSyncCollectionProps) => boolean;
   replicatorFactory?: AutomergeReplicatorFactory;
 };
 
-export class MeshReplicatorConnection extends Resource implements ReplicatorConnection {
+export class MeshReplicatorConnection extends Resource implements AutomergeReplicatorConnection {
   public readable: ReadableStream<AutomergeProtocolMessage>;
   public writable: WritableStream<AutomergeProtocolMessage>;
   public remoteDeviceKey: PublicKey | null = null;
@@ -35,7 +35,7 @@ export class MeshReplicatorConnection extends Resource implements ReplicatorConn
   private _remotePeerId: string | null = null;
   private _isEnabled = false;
 
-  constructor(private readonly _params: MeshReplicatorConnectionParams) {
+  constructor(private readonly _params: MeshReplicatorConnectionProps) {
     super();
 
     let readableStreamController!: ReadableStreamDefaultController<AutomergeProtocolMessage>;
@@ -115,11 +115,11 @@ export class MeshReplicatorConnection extends Resource implements ReplicatorConn
     return false;
   }
 
-  async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(params: ShouldAdvertiseProps): Promise<boolean> {
     return this._params.shouldAdvertise(params);
   }
 
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(params: ShouldSyncCollectionProps): boolean {
     return this._params.shouldSyncCollection(params);
   }
 

package/src/automerge/mesh-echo-replicator.ts

@@ -2,19 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
+import { type Context } from '@dxos/context';
 import type { CollectionId } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 import { PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
-import {
-  type AutomergeReplicator,
-  type AutomergeReplicatorFactory,
-} from '@dxos/teleport-extension-automerge-replicator';
+import type * as TeleportAutomergeReplicator from '@dxos/teleport-extension-automerge-replicator';
 import { ComplexSet, defaultMap } from '@dxos/util';
 
 import { createIdFromSpaceKey } from '../common/space-id';
-
-import { type EchoReplicator, type EchoReplicatorContext, type ShouldAdvertiseParams } from './echo-replicator';
+import {
+  type AutomergeReplicator,
+  type AutomergeReplicatorContext,
+  type ShouldAdvertiseProps,
+} from './echo-replicator';
 import { MeshReplicatorConnection } from './mesh-echo-replicator-connection';
 import { getSpaceIdFromCollectionId } from './space-collection';
 
@@ -23,7 +24,7 @@ import { getSpaceIdFromCollectionId } from './space-collection';
 /**
  * Used to replicate with other peers over the network.
  */
-export class MeshEchoReplicator implements EchoReplicator {
+export class MeshEchoReplicator implements AutomergeReplicator {
   /**
    * We might have multiple connections open with a peer (one per space), but there'll be only one enabled
    * connection at any given moment, because there's a single repo for all the spaces.
@@ -41,9 +42,9 @@ export class MeshEchoReplicator implements EchoReplicator {
    */
   private readonly _authorizedDevices = new Map<SpaceId, ComplexSet<PublicKey>>();
 
-  private _context: EchoReplicatorContext | null = null;
+  private _context: AutomergeReplicatorContext | null = null;
 
-  async connect(context: EchoReplicatorContext): Promise<void> {
+  async connect(_ctx: Context, context: AutomergeReplicatorContext): Promise<void> {
     this._context = context;
   }
 
@@ -64,7 +65,9 @@ export class MeshEchoReplicator implements EchoReplicator {
     this._context = null;
   }
 
-  createExtension(extensionFactory?: AutomergeReplicatorFactory): AutomergeReplicator {
+  createExtension(
+    extensionFactory?: TeleportAutomergeReplicator.AutomergeReplicatorFactory,
+  ): TeleportAutomergeReplicator.AutomergeReplicator {
     invariant(this._context);
 
     const connection: MeshReplicatorConnection = new MeshReplicatorConnection({
@@ -111,7 +114,7 @@ export class MeshEchoReplicator implements EchoReplicator {
           }
         }
       },
-      shouldAdvertise: async (params: ShouldAdvertiseParams) => {
+      shouldAdvertise: async (params: ShouldAdvertiseProps) => {
         log('shouldAdvertise', { peerId: connection.peerId, documentId: params.documentId });
         invariant(this._context);
         try {

package/src/db-host/automerge-data-source.test.ts

@@ -0,0 +1,299 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { getHeads } from '@automerge/automerge';
+import { describe, expect, onTestFinished, test } from 'vitest';
+
+import { Context } from '@dxos/context';
+import { type DatabaseDirectory, ObjectStructure, SpaceDocVersion } from '@dxos/echo-protocol';
+import { runAndForwardErrors } from '@dxos/effect';
+import { type IndexCursor } from '@dxos/index-core';
+import { DXN, SpaceId } from '@dxos/keys';
+import { type LevelDB } from '@dxos/kv-store';
+import { createTestLevel } from '@dxos/kv-store/testing';
+import { openAndClose } from '@dxos/test-utils';
+
+import { AutomergeHost } from '../automerge';
+import { AutomergeDataSource, headsCodec } from './automerge-data-source';
+
+const TEST_TYPE = DXN.parse('dxn:type:com.example.type.test:0.1.0').toString();
+const OTHER_TYPE = DXN.parse('dxn:type:com.example.type.other:0.1.0').toString();
+const PERSON_TYPE = DXN.parse('dxn:type:com.example.type.person:0.1.0').toString();
+
+/**
+ * Set up a real AutomergeHost with LevelDB storage.
+ */
+const setupAutomergeHost = async (level: LevelDB): Promise<AutomergeHost> => {
+  const host = new AutomergeHost({
+    db: level,
+  });
+  await host.open();
+  onTestFinished(async () => {
+    await host.close();
+  });
+  return host;
+};
+
+/**
+ * Create a DatabaseDirectory document with the given objects.
+ */
+const createDatabaseDirectory = async (
+  host: AutomergeHost,
+  spaceKey: string,
+  objects: Record<string, ObjectStructure>,
+): Promise<Awaited<ReturnType<typeof host.createDoc<DatabaseDirectory>>>> => {
+  const handle = await host.createDoc<DatabaseDirectory>({
+    version: SpaceDocVersion.CURRENT,
+    access: { spaceKey },
+    objects: {},
+    links: {},
+  });
+
+  handle.change((doc) => {
+    doc.objects = objects;
+  });
+
+  return handle;
+};
+
+describe('AutomergeDataSource', () => {
+  test('headsCodec encodes and decodes heads correctly', () => {
+    const heads = ['abc123', 'def456'];
+    const encoded = headsCodec.encode(heads);
+
+    expect(encoded).toBe('abc123|def456');
+    expect(headsCodec.decode(encoded)).toEqual(['abc123', 'def456']);
+  });
+
+  test('headsCodec sorts heads for consistent encoding', () => {
+    const heads1 = ['def456', 'abc123'];
+    const heads2 = ['abc123', 'def456'];
+
+    expect(headsCodec.encode(heads1)).toBe(headsCodec.encode(heads2));
+  });
+
+  test('returns empty when no documents exist', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+
+    const dataSource = new AutomergeDataSource(host);
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), []));
+
+    expect(result.objects).toHaveLength(0);
+    expect(result.cursors).toHaveLength(0);
+  });
+
+  test('returns new documents that have no cursor', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+    const spaceKey = SpaceId.random();
+
+    const handle = await createDatabaseDirectory(host, spaceKey, {
+      'obj-1': ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: 'Test Document' } }),
+    });
+    await host.flush(Context.default());
+
+    const dataSource = new AutomergeDataSource(host);
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), []));
+
+    expect(result.objects).toHaveLength(1);
+    expect(result.objects[0].documentId).toBe(handle.documentId);
+    expect(result.objects[0].data.title).toBe('Test Document');
+
+    expect(result.cursors).toHaveLength(1);
+    expect(result.cursors[0].resourceId).toBe(handle.documentId);
+    expect(result.cursors[0].cursor).toBe(headsCodec.encode(getHeads(handle.doc()!)));
+  });
+
+  test('returns documents with changed heads', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+    const spaceKey = SpaceId.random();
+
+    const handle1 = await createDatabaseDirectory(host, spaceKey, {
+      'obj-1': ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: 'Doc 1' } }),
+    });
+    const handle2 = await createDatabaseDirectory(host, spaceKey, {
+      'obj-2': ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: 'Doc 2' } }),
+    });
+    await host.flush(Context.default());
+
+    // Capture heads before mutation.
+    const doc1HeadsBefore = headsCodec.encode(getHeads(handle1.doc()!));
+    const doc2Heads = headsCodec.encode(getHeads(handle2.doc()!));
+
+    // Modify doc1 to have new heads.
+    handle1.change((doc) => {
+      doc.objects!['obj-1'].data.title = 'Doc 1 Updated';
+    });
+    await host.flush(Context.default());
+
+    const dataSource = new AutomergeDataSource(host);
+    const cursors: IndexCursor[] = [
+      {
+        indexName: 'fts',
+        spaceId: null,
+        sourceName: 'automerge',
+        resourceId: handle1.documentId,
+        cursor: doc1HeadsBefore,
+      },
+      { indexName: 'fts', spaceId: null, sourceName: 'automerge', resourceId: handle2.documentId, cursor: doc2Heads },
+    ];
+
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), cursors));
+
+    // Only doc1 changed.
+    expect(result.objects).toHaveLength(1);
+    expect(result.objects[0].documentId).toBe(handle1.documentId);
+  });
+
+  test('skips documents with unchanged heads', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+    const spaceKey = SpaceId.random();
+
+    const handle = await createDatabaseDirectory(host, spaceKey, {
+      'obj-1': ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: 'Doc 1' } }),
+    });
+    await host.flush(Context.default());
+
+    const currentHeads = headsCodec.encode(getHeads(handle.doc()!));
+
+    const dataSource = new AutomergeDataSource(host);
+    const cursors: IndexCursor[] = [
+      {
+        indexName: 'fts',
+        spaceId: null,
+        sourceName: 'automerge',
+        resourceId: handle.documentId,
+        cursor: currentHeads,
+      },
+    ];
+
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), cursors));
+
+    expect(result.objects).toHaveLength(0);
+    expect(result.cursors).toHaveLength(0);
+  });
+
+  test('respects limit option', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+    const spaceKey = SpaceId.random();
+
+    // Create 3 documents.
+    for (let i = 1; i <= 3; i++) {
+      await createDatabaseDirectory(host, spaceKey, {
+        [`obj-${i}`]: ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: `Doc ${i}` } }),
+      });
+    }
+    await host.flush(Context.default());
+
+    const dataSource = new AutomergeDataSource(host);
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), [], { limit: 2 }));
+
+    expect(result.objects).toHaveLength(2);
+    expect(result.cursors).toHaveLength(2);
+  });
+
+  test('extracts multiple objects from a document', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+    const spaceKey = SpaceId.random();
+
+    await createDatabaseDirectory(host, spaceKey, {
+      'obj-1': ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: 'Object 1' } }),
+      'obj-2': ObjectStructure.makeObject({ type: OTHER_TYPE as DXN.String, data: { title: 'Object 2' } }),
+    });
+    await host.flush(Context.default());
+
+    const dataSource = new AutomergeDataSource(host);
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), []));
+
+    expect(result.objects).toHaveLength(2);
+    expect(result.objects.map((o) => o.data.id)).toContain('obj-1');
+    expect(result.objects.map((o) => o.data.id)).toContain('obj-2');
+  });
+
+  test('skips outdated documents', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+    const spaceKey = SpaceId.random();
+
+    // Create a document with outdated version.
+    const handle = await host.createDoc<DatabaseDirectory>({
+      version: 0 as SpaceDocVersion, // Outdated version.
+      access: { spaceKey },
+      objects: {},
+      links: {},
+    });
+    handle.change((doc) => {
+      doc.objects = {
+        'obj-1': ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: 'Test' } }),
+      };
+    });
+    await host.flush(Context.default());
+
+    const dataSource = new AutomergeDataSource(host);
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), []));
+
+    expect(result.objects).toHaveLength(0);
+  });
+
+  test('extracts object attributes correctly', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+    const spaceKey = SpaceId.random();
+
+    await createDatabaseDirectory(host, spaceKey, {
+      'person-1': ObjectStructure.makeObject({
+        type: PERSON_TYPE as DXN.String,
+        data: { name: 'Alice', age: 30 },
+      }),
+    });
+    await host.flush(Context.default());
+
+    const dataSource = new AutomergeDataSource(host);
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), []));
+
+    expect(result.objects).toHaveLength(1);
+    const obj = result.objects[0];
+    expect(obj.data.id).toBe('person-1');
+    expect(obj.data['@type']).toBe(PERSON_TYPE);
+    expect(obj.data.name).toBe('Alice');
+    expect(obj.data.age).toBe(30);
+  });
+
+  test('skips documents without spaceKey', async () => {
+    const level = createTestLevel();
+    await openAndClose(level);
+    const host = await setupAutomergeHost(level);
+
+    // Create a document without access.spaceKey.
+    const handle = await host.createDoc<DatabaseDirectory>({
+      version: SpaceDocVersion.CURRENT,
+      objects: {},
+      links: {},
+    });
+    handle.change((doc) => {
+      doc.objects = {
+        'obj-1': ObjectStructure.makeObject({ type: TEST_TYPE as DXN.String, data: { title: 'No Space' } }),
+      };
+    });
+    await host.flush(Context.default());
+
+    const dataSource = new AutomergeDataSource(host);
+    const result = await runAndForwardErrors(dataSource.getChangedObjects(Context.default(), []));
+
+    expect(result.objects).toHaveLength(0);
+  });
+});