@dxos/echo-pipeline 0.6.2-main.8a232a5 → 0.6.2-main.d41f0d2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-pipeline",
-  "version": "0.6.2-main.8a232a5",
+  "version": "0.6.2-main.d41f0d2",
   "description": "ECHO database.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -39,38 +39,38 @@
     "crc-32": "^1.2.2",
     "level": "^8.0.1",
     "level-transcoder": "^1.0.1",
-    "@dxos/async": "0.6.2-main.8a232a5",
-    "@dxos/codec-protobuf": "0.6.2-main.8a232a5",
-    "@dxos/automerge": "0.6.2-main.8a232a5",
-    "@dxos/context": "0.6.2-main.8a232a5",
-    "@dxos/credentials": "0.6.2-main.8a232a5",
-    "@dxos/crypto": "0.6.2-main.8a232a5",
-    "@dxos/echo-protocol": "0.6.2-main.8a232a5",
-    "@dxos/debug": "0.6.2-main.8a232a5",
-    "@dxos/echo-schema": "0.6.2-main.8a232a5",
-    "@dxos/feed-store": "0.6.2-main.8a232a5",
-    "@dxos/hypercore": "0.6.2-main.8a232a5",
-    "@dxos/indexing": "0.6.2-main.8a232a5",
-    "@dxos/invariant": "0.6.2-main.8a232a5",
-    "@dxos/keyring": "0.6.2-main.8a232a5",
-    "@dxos/keys": "0.6.2-main.8a232a5",
-    "@dxos/kv-store": "0.6.2-main.8a232a5",
-    "@dxos/messaging": "0.6.2-main.8a232a5",
-    "@dxos/log": "0.6.2-main.8a232a5",
-    "@dxos/network-manager": "0.6.2-main.8a232a5",
-    "@dxos/protocols": "0.6.2-main.8a232a5",
-    "@dxos/node-std": "0.6.2-main.8a232a5",
-    "@dxos/rpc": "0.6.2-main.8a232a5",
-    "@dxos/random-access-storage": "0.6.2-main.8a232a5",
-    "@dxos/teleport": "0.6.2-main.8a232a5",
-    "@dxos/teleport-extension-gossip": "0.6.2-main.8a232a5",
-    "@dxos/teleport-extension-automerge-replicator": "0.6.2-main.8a232a5",
-    "@dxos/teleport-extension-replicator": "0.6.2-main.8a232a5",
-    "@dxos/teleport-extension-object-sync": "0.6.2-main.8a232a5",
-    "@dxos/timeframe": "0.6.2-main.8a232a5",
-    "@dxos/tracing": "0.6.2-main.8a232a5",
-    "@dxos/typings": "0.6.2-main.8a232a5",
-    "@dxos/util": "0.6.2-main.8a232a5"
+    "@dxos/automerge": "0.6.2-main.d41f0d2",
+    "@dxos/async": "0.6.2-main.d41f0d2",
+    "@dxos/codec-protobuf": "0.6.2-main.d41f0d2",
+    "@dxos/context": "0.6.2-main.d41f0d2",
+    "@dxos/debug": "0.6.2-main.d41f0d2",
+    "@dxos/credentials": "0.6.2-main.d41f0d2",
+    "@dxos/echo-protocol": "0.6.2-main.d41f0d2",
+    "@dxos/crypto": "0.6.2-main.d41f0d2",
+    "@dxos/echo-schema": "0.6.2-main.d41f0d2",
+    "@dxos/feed-store": "0.6.2-main.d41f0d2",
+    "@dxos/hypercore": "0.6.2-main.d41f0d2",
+    "@dxos/keyring": "0.6.2-main.d41f0d2",
+    "@dxos/indexing": "0.6.2-main.d41f0d2",
+    "@dxos/invariant": "0.6.2-main.d41f0d2",
+    "@dxos/keys": "0.6.2-main.d41f0d2",
+    "@dxos/log": "0.6.2-main.d41f0d2",
+    "@dxos/kv-store": "0.6.2-main.d41f0d2",
+    "@dxos/messaging": "0.6.2-main.d41f0d2",
+    "@dxos/network-manager": "0.6.2-main.d41f0d2",
+    "@dxos/node-std": "0.6.2-main.d41f0d2",
+    "@dxos/random-access-storage": "0.6.2-main.d41f0d2",
+    "@dxos/protocols": "0.6.2-main.d41f0d2",
+    "@dxos/rpc": "0.6.2-main.d41f0d2",
+    "@dxos/teleport": "0.6.2-main.d41f0d2",
+    "@dxos/teleport-extension-automerge-replicator": "0.6.2-main.d41f0d2",
+    "@dxos/teleport-extension-gossip": "0.6.2-main.d41f0d2",
+    "@dxos/teleport-extension-replicator": "0.6.2-main.d41f0d2",
+    "@dxos/teleport-extension-object-sync": "0.6.2-main.d41f0d2",
+    "@dxos/timeframe": "0.6.2-main.d41f0d2",
+    "@dxos/tracing": "0.6.2-main.d41f0d2",
+    "@dxos/util": "0.6.2-main.d41f0d2",
+    "@dxos/typings": "0.6.2-main.d41f0d2"
   },
   "devDependencies": {
     "fast-check": "^3.19.0",

package/src/automerge/automerge-doc-loader.test.ts

@@ -0,0 +1,103 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { sleep } from '@dxos/async';
+import { Repo } from '@dxos/automerge/automerge-repo';
+import { Context } from '@dxos/context';
+import { type SpaceDoc, SpaceDocVersion } from '@dxos/echo-protocol';
+import { generateEchoId } from '@dxos/echo-schema';
+import { PublicKey } from '@dxos/keys';
+import { describe, test } from '@dxos/test';
+
+import {
+  type AutomergeDocumentLoader,
+  AutomergeDocumentLoaderImpl,
+  type ObjectDocumentLoaded,
+} from './automerge-doc-loader';
+import { createIdFromSpaceKey } from '../space';
+
+const ctx = new Context();
+const SPACE_KEY = PublicKey.random();
+const randomId = () => generateEchoId();
+
+describe('AutomergeDocumentLoader', () => {
+  test('space access is set on root doc handle and it is accessible', async () => {
+    const { loader, spaceRootDocHandle } = await setupTest();
+    expect(loader.getSpaceRootDocHandle()).not.to.throw;
+    expect(spaceRootDocHandle.docSync()?.access?.spaceKey).to.eq(SPACE_KEY.toHex());
+  });
+
+  test('new object document is linked with space and root document', async () => {
+    const objectId = randomId();
+    const { loader, spaceRootDocHandle } = await setupTest();
+    const objectDocHandle = loader.createDocumentForObject(objectId);
+    const handle = spaceRootDocHandle.docSync();
+    expect(objectDocHandle.docSync()?.access?.spaceKey).to.eq(SPACE_KEY.toHex());
+    expect(handle?.links[objectId]).to.eq(objectDocHandle.url);
+  });
+
+  test('listener is invoked after a document is loaded', async () => {
+    const objectId = randomId();
+    const { loader, repo } = await setupTest();
+    const handle = repo.create<SpaceDoc>();
+    const docLoadInfo = waitForDocumentLoad(loader, { objectId, handle });
+    loadLinkedObjects(loader, { [objectId]: handle.url });
+    await sleep(10);
+    expect(docLoadInfo.loaded).to.be.true;
+  });
+
+  test('listener is not invoked if an object was rebound during document loading', async () => {
+    const objectId = randomId();
+    const { loader, repo } = await setupTest();
+    const oldDocHandle = repo.create<SpaceDoc>();
+    const newDocHandle = repo.create<SpaceDoc>();
+    const docLoadInfo = waitForDocumentLoad(loader, { objectId, handle: oldDocHandle });
+    loadLinkedObjects(loader, { [objectId]: oldDocHandle.url });
+    loader.onObjectBoundToDocument(newDocHandle, objectId);
+    await sleep(10);
+    expect(docLoadInfo.loaded).to.be.false;
+  });
+
+  test('document link is not loaded if object exists as inline object', async () => {
+    const objectId = randomId();
+    const { loader, repo } = await setupTest();
+    const existingHandle = repo.create<SpaceDoc>();
+    loader.onObjectBoundToDocument(existingHandle, objectId);
+    const newDocHandle = repo.create<SpaceDoc>();
+    const docLoadInfo = waitForDocumentLoad(loader, { objectId, handle: newDocHandle });
+    loadLinkedObjects(loader, { [objectId]: existingHandle.url });
+    await sleep(10);
+    expect(docLoadInfo.loaded).to.be.false;
+  });
+
+  const setupTest = async () => {
+    const spaceId = await createIdFromSpaceKey(SPACE_KEY);
+    const repo = new Repo({ network: [] });
+    const loader = new AutomergeDocumentLoaderImpl(spaceId, repo, SPACE_KEY);
+    const spaceRootDocHandle = createRootDoc(repo);
+    await loader.loadSpaceRootDocHandle(ctx, { rootUrl: spaceRootDocHandle.url });
+    return { loader, spaceRootDocHandle, repo };
+  };
+
+  const createRootDoc = (repo: Repo) => {
+    return repo.create<SpaceDoc>({ version: SpaceDocVersion.CURRENT });
+  };
+
+  const loadLinkedObjects = (loader: AutomergeDocumentLoader, links: SpaceDoc['links']) => {
+    Object.keys(links ?? {}).forEach((objectId) => loader.loadObjectDocument(objectId));
+    loader.onObjectLinksUpdated(links);
+  };
+
+  const waitForDocumentLoad = (loader: AutomergeDocumentLoader, expected: ObjectDocumentLoaded) => {
+    const docLoadInfo = { loaded: false };
+    loader.onObjectDocumentLoaded.on((data) => {
+      expect(data.objectId).to.eq(expected.objectId);
+      expect(data.handle.url).to.eq(expected.handle.url);
+      docLoadInfo.loaded = true;
+    });
+    return docLoadInfo;
+  };
+});

package/src/automerge/automerge-doc-loader.ts

@@ -0,0 +1,267 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import {
+  type DocHandle,
+  type AutomergeUrl,
+  type DocumentId,
+  type Repo,
+  interpretAsDocumentId,
+} from '@dxos/automerge/automerge-repo';
+import { cancelWithContext, type Context } from '@dxos/context';
+import { warnAfterTimeout } from '@dxos/debug';
+import { type SpaceState, type SpaceDoc, SpaceDocVersion } from '@dxos/echo-protocol';
+import { invariant } from '@dxos/invariant';
+import { type PublicKey, type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { trace } from '@dxos/tracing';
+
+type SpaceDocumentLinks = SpaceDoc['links'];
+
+export interface AutomergeDocumentLoader {
+  onObjectDocumentLoaded: Event<ObjectDocumentLoaded>;
+
+  getAllHandles(): DocHandle<SpaceDoc>[];
+
+  loadSpaceRootDocHandle(ctx: Context, spaceState: SpaceState): Promise<void>;
+  loadObjectDocument(objectId: string | string[]): void;
+  getObjectDocumentId(objectId: string): string | undefined;
+  getSpaceRootDocHandle(): DocHandle<SpaceDoc>;
+  createDocumentForObject(objectId: string): DocHandle<SpaceDoc>;
+  onObjectLinksUpdated(links: SpaceDocumentLinks): void;
+  onObjectBoundToDocument(handle: DocHandle<SpaceDoc>, objectId: string): void;
+
+  /**
+   * @returns objectIds for which we had document handles or were loading one.
+   */
+  clearHandleReferences(): string[];
+}
+
+/**
+ * Manages object <-> docHandle binding and automerge document loading.
+ */
+@trace.resource()
+export class AutomergeDocumentLoaderImpl implements AutomergeDocumentLoader {
+  private _spaceRootDocHandle: DocHandle<SpaceDoc> | null = null;
+  /**
+   * An object id pointer to a handle of the document where the object is stored inline.
+   */
+  private readonly _objectDocumentHandles = new Map<string, DocHandle<SpaceDoc>>();
+  /**
+   * If object was requested via loadObjectDocument but root document links weren't updated yet
+   * loading will be triggered in onObjectLinksUpdated callback.
+   */
+  private readonly _objectsPendingDocumentLoad = new Set<string>();
+
+  public readonly onObjectDocumentLoaded = new Event<ObjectDocumentLoaded>();
+
+  constructor(
+    private readonly _spaceId: SpaceId,
+    private readonly _repo: Repo,
+    /** Legacy Id */
+    private readonly _spaceKey: PublicKey,
+  ) {}
+
+  getAllHandles(): DocHandle<SpaceDoc>[] {
+    return this._spaceRootDocHandle != null
+      ? [this._spaceRootDocHandle, ...new Set(this._objectDocumentHandles.values())]
+      : [];
+  }
+
+  @trace.span({ showInBrowserTimeline: true })
+  public async loadSpaceRootDocHandle(ctx: Context, spaceState: SpaceState): Promise<void> {
+    if (this._spaceRootDocHandle != null) {
+      return;
+    }
+    if (!spaceState.rootUrl) {
+      throw new Error('Database opened with no rootUrl');
+    }
+
+    const existingDocHandle = await this._initDocHandle(ctx, spaceState.rootUrl);
+    const doc = existingDocHandle.docSync();
+    invariant(doc);
+    invariant(doc.version === SpaceDocVersion.CURRENT);
+    if (doc.access == null) {
+      this._initDocAccess(existingDocHandle);
+    }
+    this._spaceRootDocHandle = existingDocHandle;
+  }
+
+  public loadObjectDocument(objectIdOrMany: string | string[]) {
+    const objectIds = Array.isArray(objectIdOrMany) ? objectIdOrMany : [objectIdOrMany];
+    let hasUrlsToLoad = false;
+    const urlsToLoad: SpaceDoc['links'] = {};
+    for (const objectId of objectIds) {
+      invariant(this._spaceRootDocHandle);
+      if (this._objectDocumentHandles.has(objectId) || this._objectsPendingDocumentLoad.has(objectId)) {
+        continue;
+      }
+      const spaceRootDoc = this._spaceRootDocHandle.docSync();
+      invariant(spaceRootDoc);
+      const documentUrl = (spaceRootDoc.links ?? {})[objectId];
+      if (documentUrl == null) {
+        this._objectsPendingDocumentLoad.add(objectId);
+        log.info('loading delayed until object links are initialized', { objectId });
+      } else {
+        urlsToLoad[objectId] = documentUrl;
+        hasUrlsToLoad = true;
+      }
+    }
+    if (hasUrlsToLoad) {
+      this._loadLinkedObjects(urlsToLoad);
+    }
+  }
+
+  public getObjectDocumentId(objectId: string): string | undefined {
+    invariant(this._spaceRootDocHandle);
+    const spaceRootDoc = this._spaceRootDocHandle.docSync();
+    invariant(spaceRootDoc);
+    if (spaceRootDoc.objects?.[objectId]) {
+      return this._spaceRootDocHandle.documentId;
+    }
+    const documentUrl = (spaceRootDoc.links ?? {})[objectId];
+    return documentUrl && interpretAsDocumentId(documentUrl);
+  }
+
+  public onObjectLinksUpdated(links: SpaceDocumentLinks) {
+    if (!links) {
+      return;
+    }
+    const linksAwaitingLoad = Object.entries(links).filter(([objectId]) =>
+      this._objectsPendingDocumentLoad.has(objectId),
+    );
+    this._loadLinkedObjects(Object.fromEntries(linksAwaitingLoad));
+    linksAwaitingLoad.forEach(([objectId]) => this._objectsPendingDocumentLoad.delete(objectId));
+  }
+
+  public getSpaceRootDocHandle(): DocHandle<SpaceDoc> {
+    invariant(this._spaceRootDocHandle);
+    return this._spaceRootDocHandle;
+  }
+
+  public createDocumentForObject(objectId: string): DocHandle<SpaceDoc> {
+    invariant(this._spaceRootDocHandle);
+    const spaceDocHandle = this._repo.create<SpaceDoc>({
+      version: SpaceDocVersion.CURRENT,
+    });
+    this._initDocAccess(spaceDocHandle);
+    this.onObjectBoundToDocument(spaceDocHandle, objectId);
+    this._spaceRootDocHandle.change((newDoc: SpaceDoc) => {
+      newDoc.links ??= {};
+      newDoc.links[objectId] = spaceDocHandle.url;
+    });
+    return spaceDocHandle;
+  }
+
+  public onObjectBoundToDocument(handle: DocHandle<SpaceDoc>, objectId: string) {
+    this._objectDocumentHandles.set(objectId, handle);
+  }
+
+  public clearHandleReferences(): string[] {
+    const objectsWithHandles = [...this._objectDocumentHandles.keys()];
+    this._objectDocumentHandles.clear();
+    this._spaceRootDocHandle = null;
+    return objectsWithHandles;
+  }
+
+  private _loadLinkedObjects(links: SpaceDocumentLinks) {
+    if (!links) {
+      return;
+    }
+    for (const [objectId, automergeUrl] of Object.entries(links)) {
+      const logMeta = { objectId, automergeUrl };
+      const objectDocumentHandle = this._objectDocumentHandles.get(objectId);
+      if (objectDocumentHandle != null && objectDocumentHandle.url !== automergeUrl) {
+        log.warn('object already inlined in a different document, ignoring the link', {
+          ...logMeta,
+          actualDocumentUrl: objectDocumentHandle.url,
+        });
+        continue;
+      }
+      if (objectDocumentHandle?.url === automergeUrl) {
+        log.warn('object document was already loaded', logMeta);
+        continue;
+      }
+      const handle = this._repo.find<SpaceDoc>(automergeUrl as DocumentId);
+      log.debug('document loading triggered', logMeta);
+      this._objectDocumentHandles.set(objectId, handle);
+      void this._createObjectOnDocumentLoad(handle, objectId);
+    }
+  }
+
+  private async _initDocHandle(ctx: Context, url: string) {
+    const docHandle = this._repo.find<SpaceDoc>(url as DocumentId);
+    while (true) {
+      try {
+        await warnAfterTimeout(5_000, 'Automerge root doc load timeout (CoreDatabase)', async () => {
+          await cancelWithContext(ctx, docHandle.whenReady()); // TODO(dmaretskyi): Temporary 5s timeout for debugging.
+        });
+        break;
+      } catch (err) {
+        if (`${err}`.includes('Timeout')) {
+          log.info('wraparound', { id: docHandle.documentId, state: docHandle.state });
+          continue;
+        }
+
+        throw err;
+      }
+    }
+
+    if (docHandle.state === 'unavailable') {
+      throw new Error('Automerge document is unavailable');
+    }
+
+    return docHandle;
+  }
+
+  private _initDocAccess(handle: DocHandle<SpaceDoc>) {
+    handle.change((newDoc: SpaceDoc) => {
+      newDoc.access ??= { spaceKey: this._spaceKey.toHex() };
+      newDoc.access.spaceKey = this._spaceKey.toHex();
+    });
+  }
+
+  private async _createObjectOnDocumentLoad(handle: DocHandle<SpaceDoc>, objectId: string) {
+    try {
+      await handle.whenReady();
+      const logMeta = { objectId, docUrl: handle.url };
+      if (this.onObjectDocumentLoaded.listenerCount() === 0) {
+        log.info('document loaded after all listeners were removed', logMeta);
+        return;
+      }
+      const objectDocHandle = this._objectDocumentHandles.get(objectId);
+      if (objectDocHandle?.url !== handle.url) {
+        log.warn('object was rebound while a document was loading, discarding handle', logMeta);
+        return;
+      }
+      this.onObjectDocumentLoaded.emit({ handle, objectId });
+    } catch (err) {
+      const shouldRetryLoading = this.onObjectDocumentLoaded.listenerCount() > 0;
+      log.warn('failed to load a document', {
+        objectId,
+        automergeUrl: handle.url,
+        retryLoading: shouldRetryLoading,
+        err,
+      });
+      if (shouldRetryLoading) {
+        await this._createObjectOnDocumentLoad(handle, objectId);
+      }
+    }
+  }
+}
+
+export interface ObjectDocumentLoaded {
+  handle: DocHandle<SpaceDoc>;
+  objectId: string;
+}
+
+export interface DocumentChanges {
+  createdObjectIds: string[];
+  updatedObjectIds: string[];
+  objectsToRebind: string[];
+  linkedDocuments: {
+    [echoId: string]: AutomergeUrl;
+  };
+}

package/src/automerge/automerge-host.ts

@@ -8,20 +8,21 @@ import {
   getBackend,
   getHeads,
   isAutomerge,
-  equals as headsEquals,
   save,
+  equals as headsEquals,
   type Doc,
   type Heads,
 } from '@dxos/automerge/automerge';
 import {
-  type DocHandleChangePayload,
   Repo,
   type AnyDocumentId,
   type DocHandle,
+  type DocHandleChangePayload,
   type DocumentId,
   type PeerId,
   type StorageAdapterInterface,
 } from '@dxos/automerge/automerge-repo';
+import { type Stream } from '@dxos/codec-protobuf';
 import { Context, Resource, cancelWithContext, type Lifecycle } from '@dxos/context';
 import { type SpaceDoc } from '@dxos/echo-protocol';
 import { type IndexMetadataStore } from '@dxos/indexing';
@@ -30,7 +31,13 @@ import { PublicKey } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
 import { log } from '@dxos/log';
 import { objectPointerCodec } from '@dxos/protocols';
-import { type DocHeadsList, type FlushRequest } from '@dxos/protocols/proto/dxos/echo/service';
+import {
+  type DocHeadsList,
+  type FlushRequest,
+  type HostInfo,
+  type SyncRepoRequest,
+  type SyncRepoResponse,
+} from '@dxos/protocols/proto/dxos/echo/service';
 import { trace } from '@dxos/tracing';
 import { mapValues } from '@dxos/util';
 
@@ -38,6 +45,10 @@ import { EchoNetworkAdapter, isEchoPeerMetadata } from './echo-network-adapter';
 import { type EchoReplicator } from './echo-replicator';
 import { HeadsStore } from './heads-store';
 import { LevelDBStorageAdapter, type BeforeSaveParams } from './leveldb-storage-adapter';
+import { LocalHostNetworkAdapter } from './local-host-network-adapter';
+
+// TODO: Remove
+export type { DocumentId };
 
 export type AutomergeHostParams = {
   db: LevelDB;
@@ -68,6 +79,7 @@ export class AutomergeHost extends Resource {
   });
 
   private _repo!: Repo;
+  private _clientNetwork!: LocalHostNetworkAdapter;
   private _storage!: StorageAdapterInterface & Lifecycle;
   private readonly _headsStore: HeadsStore;
 
@@ -93,6 +105,7 @@ export class AutomergeHost extends Resource {
     this._peerId = `host-${PublicKey.random().toHex()}` as PeerId;
 
     await this._storage.open?.();
+    this._clientNetwork = new LocalHostNetworkAdapter();
 
     // Construct the automerge repo.
     this._repo = new Repo({
@@ -100,17 +113,22 @@ export class AutomergeHost extends Resource {
       sharePolicy: this._sharePolicy.bind(this),
       storage: this._storage,
       network: [
+        // Downstream client.
+        this._clientNetwork,
         // Upstream swarm.
         this._echoNetworkAdapter,
       ],
     });
 
+    this._clientNetwork.ready();
     await this._echoNetworkAdapter.open();
+    await this._clientNetwork.whenConnected();
     await this._echoNetworkAdapter.whenConnected();
   }
 
   protected override async _close() {
     await this._storage.close?.();
+    await this._clientNetwork.close();
     await this._echoNetworkAdapter.close();
     await this._ctx.dispose();
   }
@@ -317,10 +335,21 @@ export class AutomergeHost extends Resource {
    * Flush documents to disk.
    */
   @trace.span({ showInBrowserTimeline: true })
-  async flush({ documentIds }: FlushRequest = {}): Promise<void> {
-    // Note: Sync protocol for client and services ensures that all handles should have all changes.
+  async flush({ states }: FlushRequest = {}): Promise<void> {
+    // Note: Wait for all requested documents to be loaded/synced from thin-client.
+    if (states) {
+      await Promise.all(
+        states.map(async ({ heads, documentId }) => {
+          if (!heads) {
+            return;
+          }
+          const handle = this._repo.handles[documentId as DocumentId] ?? this._repo.find(documentId as DocumentId);
+          await waitForHeads(handle, heads);
+        }) ?? [],
+      );
+    }
 
-    await this._repo.flush(documentIds as DocumentId[] | undefined);
+    await this._repo.flush(states?.map(({ documentId }) => documentId as DocumentId));
   }
 
   async getHeads(documentId: DocumentId): Promise<Heads | undefined> {
@@ -335,6 +364,27 @@ export class AutomergeHost extends Resource {
       return this._headsStore.getHeads(documentId);
     }
   }
+
+  /**
+   * Host <-> Client sync.
+   */
+  syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
+    return this._clientNetwork.syncRepo(request);
+  }
+
+  /**
+   * Host <-> Client sync.
+   */
+  sendSyncMessage(request: SyncRepoRequest): Promise<void> {
+    return this._clientNetwork.sendSyncMessage(request);
+  }
+
+  /**
+   * Host <-> Client sync.
+   */
+  async getHostInfo(): Promise<HostInfo> {
+    return this._clientNetwork.getHostInfo();
+  }
 }
 
 export const getSpaceKeyFromDoc = (doc: Doc<SpaceDoc>): string | null => {