@dxos/echo-pipeline 0.6.1-main.ff751ec → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-pipeline",
-  "version": "0.6.1-main.ff751ec",
+  "version": "0.6.1",
   "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.1-main.ff751ec",
-    "@dxos/codec-protobuf": "0.6.1-main.ff751ec",
-    "@dxos/automerge": "0.6.1-main.ff751ec",
-    "@dxos/credentials": "0.6.1-main.ff751ec",
-    "@dxos/crypto": "0.6.1-main.ff751ec",
-    "@dxos/context": "0.6.1-main.ff751ec",
-    "@dxos/debug": "0.6.1-main.ff751ec",
-    "@dxos/echo-protocol": "0.6.1-main.ff751ec",
-    "@dxos/feed-store": "0.6.1-main.ff751ec",
-    "@dxos/hypercore": "0.6.1-main.ff751ec",
-    "@dxos/indexing": "0.6.1-main.ff751ec",
-    "@dxos/echo-schema": "0.6.1-main.ff751ec",
-    "@dxos/keyring": "0.6.1-main.ff751ec",
-    "@dxos/keys": "0.6.1-main.ff751ec",
-    "@dxos/invariant": "0.6.1-main.ff751ec",
-    "@dxos/log": "0.6.1-main.ff751ec",
-    "@dxos/messaging": "0.6.1-main.ff751ec",
-    "@dxos/kv-store": "0.6.1-main.ff751ec",
-    "@dxos/network-manager": "0.6.1-main.ff751ec",
-    "@dxos/node-std": "0.6.1-main.ff751ec",
-    "@dxos/protocols": "0.6.1-main.ff751ec",
-    "@dxos/random-access-storage": "0.6.1-main.ff751ec",
-    "@dxos/rpc": "0.6.1-main.ff751ec",
-    "@dxos/teleport": "0.6.1-main.ff751ec",
-    "@dxos/teleport-extension-gossip": "0.6.1-main.ff751ec",
-    "@dxos/teleport-extension-automerge-replicator": "0.6.1-main.ff751ec",
-    "@dxos/teleport-extension-object-sync": "0.6.1-main.ff751ec",
-    "@dxos/teleport-extension-replicator": "0.6.1-main.ff751ec",
-    "@dxos/timeframe": "0.6.1-main.ff751ec",
-    "@dxos/tracing": "0.6.1-main.ff751ec",
-    "@dxos/util": "0.6.1-main.ff751ec",
-    "@dxos/typings": "0.6.1-main.ff751ec"
+    "@dxos/automerge": "0.6.1",
+    "@dxos/context": "0.6.1",
+    "@dxos/codec-protobuf": "0.6.1",
+    "@dxos/credentials": "0.6.1",
+    "@dxos/crypto": "0.6.1",
+    "@dxos/debug": "0.6.1",
+    "@dxos/echo-schema": "0.6.1",
+    "@dxos/feed-store": "0.6.1",
+    "@dxos/echo-protocol": "0.6.1",
+    "@dxos/hypercore": "0.6.1",
+    "@dxos/invariant": "0.6.1",
+    "@dxos/indexing": "0.6.1",
+    "@dxos/async": "0.6.1",
+    "@dxos/keyring": "0.6.1",
+    "@dxos/keys": "0.6.1",
+    "@dxos/kv-store": "0.6.1",
+    "@dxos/log": "0.6.1",
+    "@dxos/messaging": "0.6.1",
+    "@dxos/network-manager": "0.6.1",
+    "@dxos/node-std": "0.6.1",
+    "@dxos/protocols": "0.6.1",
+    "@dxos/random-access-storage": "0.6.1",
+    "@dxos/rpc": "0.6.1",
+    "@dxos/teleport": "0.6.1",
+    "@dxos/teleport-extension-automerge-replicator": "0.6.1",
+    "@dxos/teleport-extension-object-sync": "0.6.1",
+    "@dxos/teleport-extension-gossip": "0.6.1",
+    "@dxos/teleport-extension-replicator": "0.6.1",
+    "@dxos/timeframe": "0.6.1",
+    "@dxos/tracing": "0.6.1",
+    "@dxos/typings": "0.6.1",
+    "@dxos/util": "0.6.1"
   },
   "devDependencies": {
     "fast-check": "^3.19.0",

package/src/automerge/automerge-host.ts

@@ -9,6 +9,7 @@ import {
   getHeads,
   isAutomerge,
   save,
+  equals as headsEquals,
   type Doc,
   type Heads,
 } from '@dxos/automerge/automerge';
@@ -22,13 +23,16 @@ import {
   type StorageAdapterInterface,
 } from '@dxos/automerge/automerge-repo';
 import { type Stream } from '@dxos/codec-protobuf';
-import { type Context, Resource, cancelWithContext, type Lifecycle } from '@dxos/context';
+import { Context, Resource, cancelWithContext, type Lifecycle } from '@dxos/context';
 import { type SpaceDoc } from '@dxos/echo-protocol';
 import { type IndexMetadataStore } from '@dxos/indexing';
+import { invariant } from '@dxos/invariant';
 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,
   type HostInfo,
   type SyncRepoRequest,
@@ -68,6 +72,7 @@ export type CreateDocOptions = {
  */
 @trace.resource()
 export class AutomergeHost extends Resource {
+  private readonly _db: LevelDB;
   private readonly _indexMetadataStore: IndexMetadataStore;
   private readonly _echoNetworkAdapter = new EchoNetworkAdapter({
     getContainingSpaceForDocument: this._getContainingSpaceForDocument.bind(this),
@@ -83,6 +88,7 @@ export class AutomergeHost extends Resource {
 
   constructor({ db, indexMetadataStore }: AutomergeHostParams) {
     super();
+    this._db = db;
     this._storage = new LevelDBStorageAdapter({
       db: db.sublevel('automerge'),
       callbacks: {
@@ -134,6 +140,10 @@ export class AutomergeHost extends Resource {
     return this._repo;
   }
 
+  get loadedDocsCount(): number {
+    return Object.keys(this._repo.handles).length;
+  }
+
   async addReplicator(replicator: EchoReplicator) {
     await this._echoNetworkAdapter.addReplicator(replicator);
   }
@@ -182,14 +192,53 @@ export class AutomergeHost extends Resource {
     }
   }
 
+  async waitUntilHeadsReplicated(heads: DocHeadsList): Promise<void> {
+    await Promise.all(
+      heads.entries?.map(async ({ documentId, heads }) => {
+        if (!heads || heads.length === 0) {
+          return;
+        }
+
+        const currentHeads = this.getHeads(documentId as DocumentId);
+        if (currentHeads !== null && headsEquals(currentHeads, heads)) {
+          return;
+        }
+
+        const handle = await this.loadDoc(Context.default(), documentId as DocumentId);
+        await waitForHeads(handle, heads);
+      }) ?? [],
+    );
+
+    // Flush to disk also so that the indexer can pick up the changes.
+    await this._repo.flush((heads.entries?.map((entry) => entry.documentId) ?? []) as DocumentId[]);
+  }
+
+  async reIndexHeads(documentIds: DocumentId[]) {
+    for (const documentId of documentIds) {
+      log.info('re-indexing heads for document', { documentId });
+      const handle = this._repo.find(documentId);
+      await handle.whenReady(['ready', 'requesting']);
+      if (handle.inState(['requesting'])) {
+        log.warn('document is not available locally, skipping', { documentId });
+        continue; // Handle not available locally.
+      }
+
+      const doc = handle.docSync();
+      invariant(doc);
+
+      const heads = getHeads(doc);
+      const batch = this._db.batch();
+      this._headsStore.setHeads(documentId, heads, batch);
+      await batch.write();
+    }
+    log.info('done re-indexing heads');
+  }
+
   // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
   // Hosts, running in the worker, don't share documents unless requested by other peers.
   // NOTE: If both peers return sharePolicy=false the replication will not happen
   // https://github.com/automerge/automerge-repo/pull/292
-  private async _sharePolicy(
-    peerId: PeerId /* device key */,
-    documentId?: DocumentId /* space key */,
-  ): Promise<boolean> {
+  private async _sharePolicy(peerId: PeerId, documentId?: DocumentId): Promise<boolean> {
     if (peerId.startsWith('client-')) {
       return false; // Only send docs to clients if they are requested.
     }
@@ -200,7 +249,7 @@ export class AutomergeHost extends Resource {
 
     const peerMetadata = this.repo.peerMetadataByPeerId[peerId];
     if (isEchoPeerMetadata(peerMetadata)) {
-      return this._echoNetworkAdapter.shouldAdvertize(peerId, { documentId });
+      return this._echoNetworkAdapter.shouldAdvertise(peerId, { documentId });
     }
 
     return false;
@@ -349,9 +398,9 @@ export const getSpaceKeyFromDoc = (doc: Doc<SpaceDoc>): string | null => {
 };
 
 const waitForHeads = async (handle: DocHandle<SpaceDoc>, heads: Heads) => {
-  await handle.whenReady();
   const unavailableHeads = new Set(heads);
 
+  await handle.whenReady();
   await Event.wrap<DocHandleChangePayload<SpaceDoc>>(handle, 'change').waitForCondition(() => {
     // Check if unavailable heads became available.
     for (const changeHash of unavailableHeads.values()) {
@@ -360,10 +409,7 @@ const waitForHeads = async (handle: DocHandle<SpaceDoc>, heads: Heads) => {
       }
     }
 
-    if (unavailableHeads.size === 0) {
-      return true;
-    }
-    return false;
+    return unavailableHeads.size === 0;
   });
 };
 

package/src/automerge/automerge-repo.test.ts

@@ -7,7 +7,14 @@ import waitForExpect from 'wait-for-expect';
 
 import { asyncTimeout, sleep } from '@dxos/async';
 import { type Heads, change, clone, equals, from, getBackend, getHeads } from '@dxos/automerge/automerge';
-import { type Message, Repo, type PeerId, type DocumentId, type HandleState } from '@dxos/automerge/automerge-repo';
+import {
+  type Message,
+  Repo,
+  type PeerId,
+  type DocumentId,
+  type HandleState,
+  type AutomergeUrl,
+} from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
@@ -92,6 +99,74 @@ describe('AutomergeRepo', () => {
     expect(equals(a, c)).to.be.true;
   });
 
+  test('documents missing from local storage go to requesting state', async () => {
+    const hostAdapter: TestAdapter = new TestAdapter({
+      send: (message: Message) => {
+        console.log('hostAdapter.send', message);
+        clientAdapter.receive(message);
+      },
+    });
+    const clientAdapter: TestAdapter = new TestAdapter({
+      send: (message: Message) => {
+        console.log('clientAdapter.send', message);
+        if (message.type !== 'doc-unavailable' && message.type !== 'sync') {
+          hostAdapter.receive(message);
+        }
+      },
+    });
+
+    const host = new Repo({
+      network: [hostAdapter],
+    });
+    const _client = new Repo({
+      network: [clientAdapter],
+    });
+    hostAdapter.ready();
+    clientAdapter.ready();
+    await hostAdapter.onConnect.wait();
+    await clientAdapter.onConnect.wait();
+    hostAdapter.peerCandidate(clientAdapter.peerId!);
+    clientAdapter.peerCandidate(hostAdapter.peerId!);
+
+    const url = 'automerge:3JN8F3Z4dUWEEKKFN7WE9gEGvVUT';
+    const handle = host.find(url as AutomergeUrl);
+    await handle.whenReady(['requesting']);
+  });
+
+  test('documents on disk go to ready state', async () => {
+    const level = createTestLevel();
+    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+    await openAndClose(level, storage);
+
+    let url: AutomergeUrl | undefined;
+    {
+      const repo = new Repo({
+        network: [],
+        storage,
+      });
+      const handle = repo.create<{ field?: string }>();
+      url = handle.url;
+      await repo.flush();
+    }
+
+    {
+      const repo = new Repo({
+        network: [],
+        storage,
+      });
+      const handle = repo.find(url as AutomergeUrl);
+
+      let requestingState = false;
+      queueMicrotask(async () => {
+        await handle.whenReady(['requesting']);
+        requestingState = true;
+      });
+
+      await handle.whenReady(['ready']);
+      expect(requestingState).to.be.false;
+    }
+  });
+
   describe('network', () => {
     test('basic networking', async () => {
       const hostAdapter: TestAdapter = new TestAdapter({
@@ -514,5 +589,46 @@ describe('AutomergeRepo', () => {
         await asyncTimeout(docB.whenReady(), 1_000);
       }
     });
+
+    test('documents loaded from disk get replicated', async () => {
+      const level = createTestLevel();
+      const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+      await openAndClose(level, storage);
+
+      let url: AutomergeUrl | undefined;
+      {
+        const peer1 = new Repo({
+          storage,
+        });
+        const handle = peer1.create({ text: 'foo' });
+        await peer1.flush();
+        url = handle.url;
+      }
+
+      const [adapter1, adapter2] = TestAdapter.createPair();
+      const peer1 = new Repo({
+        network: [adapter1],
+        storage,
+        sharePolicy: async () => true,
+      });
+      const peer2 = new Repo({
+        network: [adapter2],
+        sharePolicy: async () => true,
+      });
+      adapter1.ready();
+      adapter2.ready();
+      await adapter1.onConnect.wait();
+      await adapter2.onConnect.wait();
+      adapter1.peerCandidate(adapter2.peerId!);
+      adapter2.peerCandidate(adapter1.peerId!);
+
+      // Load doc on peer1
+      const hostHandle = peer1.find(url as AutomergeUrl);
+
+      // Doc should be pushed to peer2
+      await waitForExpect(() => {
+        expect(peer2.handles[hostHandle.documentId]).to.not.be.undefined;
+      });
+    });
   });
 });

package/src/automerge/echo-network-adapter.test.ts

@@ -0,0 +1,131 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { sleep, Trigger, waitForCondition } from '@dxos/async';
+import { cbor, type PeerId } from '@dxos/automerge/automerge-repo';
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { type SyncMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/automerge';
+import {
+  type AutomergeReplicator,
+  type AutomergeReplicatorCallbacks,
+  type AutomergeReplicatorFactory,
+} from '@dxos/teleport-extension-automerge-replicator';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { EchoNetworkAdapter } from './echo-network-adapter';
+import { MeshEchoReplicator } from './mesh-echo-replicator';
+
+const PEER_ID = 'peerA' as PeerId;
+const ANOTHER_PEER_ID = 'peerB' as PeerId;
+const PAYLOAD = new Uint8Array([42]);
+
+describe('EchoNetworkAdapter', () => {
+  test('peer-candidate emitted when replication starts', async () => {
+    const controller = createReplicatorController();
+    const adapter = await createConnectedAdapter(controller.replicator);
+    const peerInfo = new Trigger<any>();
+    adapter.on('peer-candidate', (payload) => peerInfo.wake(payload));
+    await controller.connectPeer(ANOTHER_PEER_ID);
+    const emittedInfo = await peerInfo.wait();
+    expect(emittedInfo.peerId).to.eq(ANOTHER_PEER_ID);
+  });
+
+  test('message emitted when sync message is received', async () => {
+    const controller = createReplicatorController();
+    const adapter = await createConnectedAdapter(controller.replicator);
+    const messageReceived = new Trigger<any>();
+    adapter.on('message', (message) => messageReceived.wake(message));
+    const callbacks = await controller.connectPeer(ANOTHER_PEER_ID);
+    await callbacks.onSyncMessage!(encodeSyncPayload(PAYLOAD));
+    const receivedMessage = await messageReceived.wait();
+    expect(receivedMessage).to.deep.eq(PAYLOAD);
+  });
+
+  test('peer disconnects when onClose callback is invoked', async () => {
+    const controller = createReplicatorController();
+    const adapter = await createConnectedAdapter(controller.replicator);
+    const callbacks = await controller.connectPeer(ANOTHER_PEER_ID);
+    const onDisconnected = new Trigger<any>();
+    adapter.on('peer-disconnected', (payload) => onDisconnected.wake(payload));
+    await callbacks.onClose!();
+    const disconnectedPeer = await onDisconnected.wait();
+    expect(disconnectedPeer.peerId).to.eq(ANOTHER_PEER_ID);
+  });
+
+  test('peer disconnects when message sending fails', async () => {
+    let errored = false;
+    const controller = createReplicatorController(async () => {
+      errored = true;
+      throw new Error();
+    });
+    const adapter = await createConnectedAdapter(controller.replicator);
+    await controller.connectPeer(ANOTHER_PEER_ID);
+    const onDisconnected = new Trigger<any>();
+    adapter.on('peer-disconnected', (payload) => onDisconnected.wake(payload));
+    adapter.send(newSyncMessage(PEER_ID, ANOTHER_PEER_ID, PAYLOAD));
+    const disconnectedPeer = await onDisconnected.wait();
+    expect(disconnectedPeer.peerId).to.eq(ANOTHER_PEER_ID);
+    expect(errored).to.be.true;
+  });
+
+  test('message sending is queued', async () => {
+    let sentTotal = 0;
+    let sendInProgress = false;
+    const controller = createReplicatorController(async () => {
+      invariant(!sendInProgress);
+      sendInProgress = true;
+      await sleep(5);
+      sendInProgress = false;
+      sentTotal++;
+    });
+    const adapter = await createConnectedAdapter(controller.replicator);
+    await controller.connectPeer(ANOTHER_PEER_ID);
+    const totalMessages = 5;
+    for (let i = 0; i < totalMessages; i++) {
+      adapter.send(newSyncMessage(PEER_ID, ANOTHER_PEER_ID, PAYLOAD));
+    }
+    await waitForCondition({ condition: () => sentTotal === totalMessages });
+  });
+
+  const createConnectedAdapter = async (replicator: MeshEchoReplicator) => {
+    const adapter = new EchoNetworkAdapter({ getContainingSpaceForDocument: async () => null });
+    adapter.connect(PEER_ID);
+    await adapter.open();
+    afterTest(() => adapter.close());
+    await adapter.addReplicator(replicator);
+    return adapter;
+  };
+
+  const createReplicatorController = (sendSyncMessage?: (message: SyncMessage) => Promise<void>) => {
+    const replicator = new MeshEchoReplicator();
+    return {
+      replicator,
+      connectPeer: async (peerId: string) => {
+        let callbacks: AutomergeReplicatorCallbacks | undefined;
+        const extensionFactory: AutomergeReplicatorFactory = (params) => {
+          callbacks = params[1];
+          return { sendSyncMessage } as AutomergeReplicator;
+        };
+        replicator.createExtension(extensionFactory);
+        invariant(callbacks);
+        await callbacks.onStartReplication!({ id: peerId }, PublicKey.random());
+        return callbacks;
+      },
+    };
+  };
+
+  const newSyncMessage = (from: PeerId, to: PeerId, payload: Uint8Array) => ({
+    type: 'sync',
+    senderId: from,
+    targetId: to,
+    data: payload,
+  });
+
+  const encodeSyncPayload = (payload: Uint8Array): SyncMessage => ({
+    payload: cbor.encode(payload),
+  });
+});

package/src/automerge/echo-network-adapter.ts

@@ -2,14 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Trigger, synchronized } from '@dxos/async';
+import { synchronized, Trigger } from '@dxos/async';
 import { type Message, NetworkAdapter, type PeerId, type PeerMetadata } from '@dxos/automerge/automerge-repo';
 import { LifecycleState } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-import { type EchoReplicator, type ReplicatorConnection, type ShouldAdvertizeParams } from './echo-replicator';
+import { type EchoReplicator, type ReplicatorConnection, type ShouldAdvertiseParams } from './echo-replicator';
 
 export type EchoNetworkAdapterParams = {
   getContainingSpaceForDocument: (documentId: string) => Promise<PublicKey | null>;
@@ -110,13 +110,13 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this._replicators.delete(replicator);
   }
 
-  async shouldAdvertize(peerId: PeerId, params: ShouldAdvertizeParams): Promise<boolean> {
+  async shouldAdvertise(peerId: PeerId, params: ShouldAdvertiseParams): Promise<boolean> {
     const connection = this._connections.get(peerId);
     if (!connection) {
       return false;
     }
 
-    return connection.connection.shouldAdvertize(params);
+    return connection.connection.shouldAdvertise(params);
   }
 
   private _onConnectionOpen(connection: ReplicatorConnection) {

package/src/automerge/echo-replicator.ts

@@ -23,13 +23,11 @@ export interface EchoReplicatorContext {
    */
   get peerId(): string;
 
-  onConnectionOpen(connection: ReplicatorConnection): void;
+  getContainingSpaceForDocument(documentId: string): Promise<PublicKey | null>;
 
+  onConnectionOpen(connection: ReplicatorConnection): void;
   onConnectionClosed(connection: ReplicatorConnection): void;
-
   onConnectionAuthScopeChanged(connection: ReplicatorConnection): void;
-
-  getContainingSpaceForDocument(documentId: string): Promise<PublicKey | null>;
 }
 
 export interface ReplicatorConnection {
@@ -49,13 +47,12 @@ export interface ReplicatorConnection {
   writable: WritableStream<Message>;
 
   /**
-   * @returns true if the document should be advertized to this peer.
-   *
-   * The remote peer can still request the document by it's id bypassing this check.
+   * @returns true if the document should be advertised to this peer.
+   * The remote peer can still request the document by its id bypassing this check.
    */
-  shouldAdvertize(params: ShouldAdvertizeParams): Promise<boolean>;
+  shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean>;
 }
 
-export type ShouldAdvertizeParams = {
+export type ShouldAdvertiseParams = {
   documentId: string;
 };

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

@@ -0,0 +1,130 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { cbor, type Message } from '@dxos/automerge/automerge-repo';
+import { Resource } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
+import { type PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { AutomergeReplicator, type AutomergeReplicatorFactory } from '@dxos/teleport-extension-automerge-replicator';
+
+import type { ReplicatorConnection, ShouldAdvertiseParams } from './echo-replicator';
+
+const DEFAULT_FACTORY: AutomergeReplicatorFactory = (params) => new AutomergeReplicator(...params);
+
+export type MeshReplicatorConnectionParams = {
+  ownPeerId: string;
+  onRemoteConnected: () => void;
+  onRemoteDisconnected: () => void;
+  shouldAdvertise: (params: ShouldAdvertiseParams) => Promise<boolean>;
+  replicatorFactory?: AutomergeReplicatorFactory;
+};
+
+export class MeshReplicatorConnection extends Resource implements ReplicatorConnection {
+  public readable: ReadableStream<Message>;
+  public writable: WritableStream<Message>;
+  public remoteDeviceKey: PublicKey | null = null;
+
+  public readonly replicatorExtension: AutomergeReplicator;
+
+  private _remotePeerId: string | null = null;
+  private _isEnabled = false;
+
+  constructor(private readonly _params: MeshReplicatorConnectionParams) {
+    super();
+
+    let readableStreamController!: ReadableStreamDefaultController<Message>;
+    this.readable = new ReadableStream<Message>({
+      start: (controller) => {
+        readableStreamController = controller;
+        this._ctx.onDispose(() => controller.close());
+      },
+    });
+
+    this.writable = new WritableStream<Message>({
+      write: async (message: Message, controller) => {
+        invariant(this._isEnabled, 'Writing to a disabled connection');
+        try {
+          await this.replicatorExtension.sendSyncMessage({ payload: cbor.encode(message) });
+        } catch (err) {
+          controller.error(err);
+          this._disconnectIfEnabled();
+        }
+      },
+    });
+
+    const createAutomergeReplicator = this._params.replicatorFactory ?? DEFAULT_FACTORY;
+    this.replicatorExtension = createAutomergeReplicator([
+      {
+        peerId: this._params.ownPeerId,
+      },
+      {
+        onStartReplication: async (info, remotePeerId /** Teleport ID */) => {
+          // Note: We store only one extension per peer.
+          //       There can be a case where two connected peers have more than one teleport connection between them
+          //       and each of them uses different teleport connections to send messages.
+          //       It works because we receive messages from all teleport connections and Automerge Repo dedup them.
+          // TODO(mykola): Use only one teleport connection per peer.
+
+          // TODO(dmaretskyi): Critical bug.
+          // - two peers get connected via swarm 1
+          // - they get connected via swarm 2
+          // - swarm 1 gets disconnected
+          // - automerge repo thinks that peer 2 got disconnected even though swarm 2 is still active
+
+          this.remoteDeviceKey = remotePeerId;
+
+          // Set automerge id.
+          this._remotePeerId = info.id;
+
+          log('onStartReplication', { id: info.id, thisPeerId: this.peerId, remotePeerId: remotePeerId.toHex() });
+
+          this._params.onRemoteConnected();
+        },
+        onSyncMessage: async ({ payload }) => {
+          if (!this._isEnabled) {
+            return;
+          }
+          const message = cbor.decode(payload) as Message;
+          // Note: automerge Repo dedup messages.
+          readableStreamController.enqueue(message);
+        },
+        onClose: async () => {
+          this._disconnectIfEnabled();
+        },
+      },
+    ]);
+  }
+
+  private _disconnectIfEnabled() {
+    if (this._isEnabled) {
+      this._params.onRemoteDisconnected();
+    }
+  }
+
+  get peerId(): string {
+    invariant(this._remotePeerId != null, 'Remote peer has not connected yet.');
+    return this._remotePeerId;
+  }
+
+  async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
+    return this._params.shouldAdvertise(params);
+  }
+
+  /**
+   * Start exchanging messages with the remote peer.
+   * Call after the remote peer has connected.
+   */
+  enable() {
+    invariant(this._remotePeerId != null, 'Remote peer has not connected yet.');
+    this._isEnabled = true;
+  }
+
+  /**
+   * Stop exchanging messages with the remote peer.
+   */
+  disable() {
+    this._isEnabled = false;
+  }
+}