@dxos/echo-pipeline 0.5.0 → 0.5.1-main.0ba1ecb

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

@@ -6,13 +6,12 @@ import { Event } from '@dxos/async';
 import { type DocHandle, type AutomergeUrl, type DocumentId, type Repo } from '@dxos/automerge/automerge-repo';
 import { cancelWithContext, type Context } from '@dxos/context';
 import { warnAfterTimeout } from '@dxos/debug';
+import { type SpaceState, type SpaceDoc } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/tracing';
 
-import { type SpaceState, type SpaceDoc } from './types';
-
 type SpaceDocumentLinks = SpaceDoc['links'];
 
 export interface AutomergeDocumentLoader {
@@ -21,7 +20,7 @@ export interface AutomergeDocumentLoader {
   getAllHandles(): DocHandle<SpaceDoc>[];
 
   loadSpaceRootDocHandle(ctx: Context, spaceState: SpaceState): Promise<void>;
-  loadObjectDocument(objectId: string): void;
+  loadObjectDocument(objectId: string | string[]): void;
   getSpaceRootDocHandle(): DocHandle<SpaceDoc>;
   createDocumentForObject(objectId: string): DocHandle<SpaceDoc>;
   onObjectLinksUpdated(links: SpaceDocumentLinks): void;
@@ -57,7 +56,9 @@ export class AutomergeDocumentLoaderImpl implements AutomergeDocumentLoader {
   ) {}
 
   getAllHandles(): DocHandle<SpaceDoc>[] {
-    return [...new Set(this._objectDocumentHandles.values())];
+    return this._spaceRootDocHandle != null
+      ? [this._spaceRootDocHandle, ...new Set(this._objectDocumentHandles.values())]
+      : [];
   }
 
   @trace.span({ showInBrowserTimeline: true })
@@ -79,20 +80,29 @@ export class AutomergeDocumentLoaderImpl implements AutomergeDocumentLoader {
     }
   }
 
-  public loadObjectDocument(objectId: string) {
-    invariant(this._spaceRootDocHandle);
-    if (this._objectDocumentHandles.has(objectId) || this._objectsPendingDocumentLoad.has(objectId)) {
-      return;
+  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;
+      }
     }
-    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 });
-      return;
+    if (hasUrlsToLoad) {
+      this._loadLinkedObjects(urlsToLoad);
     }
-    this._loadLinkedObjects({ [objectId]: documentUrl });
   }
 
   public onObjectLinksUpdated(links: SpaceDocumentLinks) {

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

@@ -15,17 +15,17 @@ import {
   type HandleState,
   type DocumentId,
 } from '@dxos/automerge/automerge-repo';
+import { IndexMetadataStore } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
+import { createTestLevel } from '@dxos/kv-store/testing';
 import { log } from '@dxos/log';
-import { StorageType, createStorage } from '@dxos/random-access-storage';
 import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
-import { afterTest, describe, test } from '@dxos/test';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
 import { arrayToBuffer, bufferToArray } from '@dxos/util';
 
 import { AutomergeHost } from './automerge-host';
-import { AutomergeStorageAdapter } from './automerge-storage-adapter';
+import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
 import { MeshNetworkAdapter } from './mesh-network-adapter';
-import { createTestLevel } from '../testing';
 
 describe('AutomergeHost', () => {
   test('can create documents', async () => {
@@ -34,6 +34,7 @@ describe('AutomergeHost', () => {
     afterTest(() => level.close());
     const host = new AutomergeHost({
       db: level.sublevel('automerge'),
+      indexMetadataStore: new IndexMetadataStore({ db: level.sublevel('index-metadata') }),
     });
     await host.open();
     afterTest(() => host.close());
@@ -51,7 +52,10 @@ describe('AutomergeHost', () => {
     await level.open();
     afterTest(() => level.close());
 
-    const host = new AutomergeHost({ db: level.sublevel('automerge') });
+    const host = new AutomergeHost({
+      db: level.sublevel('automerge'),
+      indexMetadataStore: new IndexMetadataStore({ db: level.sublevel('index-metadata') }),
+    });
     await host.open();
     const handle = host.repo.create();
     handle.change((doc: any) => {
@@ -62,7 +66,10 @@ describe('AutomergeHost', () => {
     await host.repo.flush();
     await host.close();
 
-    const host2 = new AutomergeHost({ db: level.sublevel('automerge') });
+    const host2 = new AutomergeHost({
+      db: level.sublevel('automerge'),
+      indexMetadataStore: new IndexMetadataStore({ db: level.sublevel('index-metadata') }),
+    });
     await host2.open();
     afterTest(() => host2.close());
     const handle2 = host2.repo.find(url);
@@ -332,20 +339,25 @@ describe('AutomergeHost', () => {
   });
 
   describe('storage', () => {
-    test('load range on node', async () => {
+    test('loadRange', async () => {
       const root = `/tmp/${randomBytes(16).toString('hex')}`;
       {
-        const storage = createStorage({ type: StorageType.NODE, root });
-        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        const level = createTestLevel(root);
+        const adapter = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+        await level.open();
+        await adapter.open();
 
         await adapter.save(['test', '1'], bufferToArray(Buffer.from('one')));
         await adapter.save(['test', '2'], bufferToArray(Buffer.from('two')));
         await adapter.save(['bar', '1'], bufferToArray(Buffer.from('bar')));
+        await adapter.close();
+        await level.close();
       }
 
       {
-        const storage = createStorage({ type: StorageType.NODE, root });
-        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        const level = createTestLevel(root);
+        const adapter = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+        await openAndClose(level, adapter);
 
         const range = await adapter.loadRange(['test']);
         expect(range.map((chunk) => arrayToBuffer(chunk.data!).toString())).toEqual(['one', 'two']);
@@ -356,19 +368,24 @@ describe('AutomergeHost', () => {
       }
     });
 
-    test('removeRange on node', async () => {
+    test('removeRange', async () => {
       const root = `/tmp/${randomBytes(16).toString('hex')}`;
       {
-        const storage = createStorage({ type: StorageType.NODE, root });
-        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        const level = createTestLevel(root);
+        const adapter = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+        await level.open();
+        await adapter.open();
         await adapter.save(['test', '1'], bufferToArray(Buffer.from('one')));
         await adapter.save(['test', '2'], bufferToArray(Buffer.from('two')));
         await adapter.save(['bar', '1'], bufferToArray(Buffer.from('bar')));
+        await adapter.close();
+        await level.close();
       }
 
       {
-        const storage = createStorage({ type: StorageType.NODE, root });
-        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        const level = createTestLevel(root);
+        const adapter = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+        await openAndClose(level, adapter);
         await adapter.removeRange(['test']);
         const range = await adapter.loadRange(['test']);
         expect(range.map((chunk) => arrayToBuffer(chunk.data!).toString())).toEqual([]);

package/src/automerge/automerge-host.ts

@@ -2,13 +2,25 @@
 // Copyright 2023 DXOS.org
 //
 
-import { asyncTimeout } from '@dxos/async';
-import { next as automerge } from '@dxos/automerge/automerge';
-import { Repo, type DocumentId, type PeerId, type StorageAdapterInterface } from '@dxos/automerge/automerge-repo';
+import { Event } from '@dxos/async';
+import { type Doc, next as automerge, getBackend, type Heads, getHeads } from '@dxos/automerge/automerge';
+import {
+  type DocHandle,
+  Repo,
+  type DocumentId,
+  type PeerId,
+  type StorageAdapterInterface,
+  type DocHandleChangePayload,
+} from '@dxos/automerge/automerge-repo';
 import { type Stream } from '@dxos/codec-protobuf';
 import { Context, 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 SubLevelDB } from '@dxos/kv-store';
 import { log } from '@dxos/log';
+import { idCodec } from '@dxos/protocols';
 import {
   type FlushRequest,
   type HostInfo,
@@ -20,11 +32,12 @@ import { type AutomergeReplicator } from '@dxos/teleport-extension-automerge-rep
 import { trace } from '@dxos/tracing';
 import { ComplexMap, ComplexSet, defaultMap, mapValues } from '@dxos/util';
 
-import { LevelDBStorageAdapter, type StorageCallbacks } from './leveldb-storage-adapter';
+import { EchoNetworkAdapter } from './echo-network-adapter';
+import { type EchoReplicator } from './echo-replicator';
+import { type BeforeSaveParams, LevelDBStorageAdapter } from './leveldb-storage-adapter';
 import { LocalHostNetworkAdapter } from './local-host-network-adapter';
 import { MeshNetworkAdapter } from './mesh-network-adapter';
 import { levelMigration } from './migrations';
-import { type SubLevelDB } from './types';
 
 // TODO: Remove
 export type { DocumentId };
@@ -35,15 +48,17 @@ export type AutomergeHostParams = {
    * For migration purposes.
    */
   directory?: Directory;
-  storageCallbacks?: StorageCallbacks;
+
+  indexMetadataStore: IndexMetadataStore;
 };
 
 @trace.resource()
 export class AutomergeHost {
+  private readonly _indexMetadataStore: IndexMetadataStore;
   private readonly _ctx = new Context();
   private readonly _directory?: Directory;
   private readonly _db: SubLevelDB;
-  private readonly _storageCallbacks?: StorageCallbacks;
+  private readonly _echoNetworkAdapter = new EchoNetworkAdapter();
 
   private _repo!: Repo;
   private _meshNetwork!: MeshNetworkAdapter;
@@ -60,10 +75,10 @@ export class AutomergeHost {
 
   public _requestedDocs = new Set<string>();
 
-  constructor({ directory, db, storageCallbacks }: AutomergeHostParams) {
+  constructor({ directory, db, indexMetadataStore }: AutomergeHostParams) {
     this._directory = directory;
     this._db = db;
-    this._storageCallbacks = storageCallbacks;
+    this._indexMetadataStore = indexMetadataStore;
   }
 
   async open() {
@@ -71,16 +86,20 @@ export class AutomergeHost {
     this._directory && (await levelMigration({ db: this._db, directory: this._directory }));
     this._storage = new LevelDBStorageAdapter({
       db: this._db,
-      callbacks: this._storageCallbacks,
+      callbacks: {
+        beforeSave: async (params) => this._beforeSave(params),
+        afterSave: async () => this._afterSave(),
+      },
     });
     await this._storage.open?.();
     this._peerId = `host-${PublicKey.random().toHex()}` as PeerId;
 
     this._meshNetwork = new MeshNetworkAdapter();
     this._clientNetwork = new LocalHostNetworkAdapter();
+
     this._repo = new Repo({
       peerId: this._peerId as PeerId,
-      network: [this._clientNetwork, this._meshNetwork],
+      network: [this._clientNetwork, this._meshNetwork, this._echoNetworkAdapter],
       storage: this._storage,
 
       // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
@@ -94,6 +113,11 @@ export class AutomergeHost {
           return false;
         }
 
+        const peerMetadata = this.repo.peerMetadataByPeerId[peerId];
+        if ((peerMetadata as any)?.dxos_peerSource === 'EchoNetworkAdapter') {
+          return this._echoNetworkAdapter.shouldAdvertize(peerId, { documentId });
+        }
+
         const doc = this._repo.handles[documentId]?.docSync();
         if (!doc) {
           const isRequested = this._requestedDocs.has(`automerge:${documentId}`);
@@ -111,7 +135,7 @@ export class AutomergeHost {
           const authorizedDevices = this._authorizedDevices.get(PublicKey.from(spaceKey));
 
           // TODO(mykola): Hack, stop abusing `peerMetadata` field.
-          const deviceKeyHex = (this.repo.peerMetadataByPeerId[peerId] as any)?.dxos_deviceKey;
+          const deviceKeyHex = (peerMetadata as any)?.dxos_deviceKey;
           if (!deviceKeyHex) {
             log('device key not found for share policy check', { peerId, documentId });
             return false;
@@ -136,13 +160,16 @@ export class AutomergeHost {
     });
     this._clientNetwork.ready();
     this._meshNetwork.ready();
+    await this._echoNetworkAdapter.open();
 
     await this._clientNetwork.whenConnected();
+    await this._echoNetworkAdapter.whenConnected();
   }
 
   async close() {
     await this._storage.close?.();
     await this._clientNetwork.close();
+    await this._echoNetworkAdapter.close();
     await this._ctx.dispose();
   }
 
@@ -150,6 +177,39 @@ export class AutomergeHost {
     return this._repo;
   }
 
+  async addReplicator(replicator: EchoReplicator) {
+    await this._echoNetworkAdapter.addReplicator(replicator);
+  }
+
+  async removeReplicator(replicator: EchoReplicator) {
+    await this._echoNetworkAdapter.removeReplicator(replicator);
+  }
+
+  private async _beforeSave({ path, batch }: BeforeSaveParams) {
+    const handle = this._repo.handles[path[0] as DocumentId];
+    if (!handle) {
+      return;
+    }
+    const doc = handle.docSync();
+    if (!doc) {
+      return;
+    }
+
+    const lastAvailableHash = getHeads(doc);
+
+    const objectIds = Object.keys(doc.objects ?? {});
+    const encodedIds = objectIds.map((objectId) => idCodec.encode({ documentId: handle.documentId, objectId }));
+    const idToLastHash = new Map(encodedIds.map((id) => [id, lastAvailableHash]));
+    this._indexMetadataStore.markDirty(idToLastHash, batch);
+  }
+
+  /**
+   * Called by AutomergeStorageAdapter after levelDB batch commit.
+   */
+  private async _afterSave() {
+    this._indexMetadataStore.notifyMarkedDirty();
+  }
+
   @trace.info({ depth: null })
   private _automergeDocs() {
     return mapValues(this._repo.handles, (handle) => ({
@@ -185,16 +245,17 @@ export class AutomergeHost {
   // Methods for client-services.
   //
   @trace.span({ showInBrowserTimeline: true })
-  async flush({ documentIds }: FlushRequest): Promise<void> {
+  async flush({ states }: FlushRequest): Promise<void> {
     // Note: Wait for all requested documents to be loaded/synced from thin-client.
-    await Promise.all(documentIds?.map((id) => this._repo.find(id as DocumentId).whenReady()) ?? []);
-
-    // TODO(dmaretskyi): Workaround until the flush issue gets resolved.
-    try {
-      await asyncTimeout(this._repo.flush(documentIds as DocumentId[]), 500);
-    } catch (err) {
-      log.warn('flush error', { documentIds, err });
-    }
+    await Promise.all(
+      states?.map(async ({ heads, documentId }) => {
+        invariant(heads, 'heads are required for flush');
+        const handle = this.repo.handles[documentId as DocumentId] ?? this._repo.find(documentId as DocumentId);
+        await waitForHeads(handle, heads);
+      }) ?? [],
+    );
+
+    await this._repo.flush(states?.map(({ documentId }) => documentId as DocumentId));
   }
 
   syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
@@ -232,3 +293,26 @@ export const getSpaceKeyFromDoc = (doc: any): string | null => {
 
   return String(rawSpaceKey);
 };
+
+const waitForHeads = async (handle: DocHandle<SpaceDoc>, heads: Heads) => {
+  await handle.whenReady();
+  const unavailableHeads = new Set(heads);
+
+  await Event.wrap<DocHandleChangePayload<SpaceDoc>>(handle, 'change').waitForCondition(() => {
+    // Check if unavailable heads became available.
+    for (const changeHash of unavailableHeads.values()) {
+      if (changeIsPresentInDoc(handle.docSync(), changeHash)) {
+        unavailableHeads.delete(changeHash);
+      }
+    }
+
+    if (unavailableHeads.size === 0) {
+      return true;
+    }
+    return false;
+  });
+};
+
+const changeIsPresentInDoc = (doc: Doc<any>, changeHash: string): boolean => {
+  return !!getBackend(doc).getChangeByHash(changeHash);
+};

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

@@ -2,19 +2,25 @@
 // Copyright 2024 DXOS.org
 //
 
+import { expect } from 'chai';
+
+import { change, clone, from, getBackend, getHeads } from '@dxos/automerge/automerge';
 import { Repo } from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
-import { StorageType, createStorage } from '@dxos/random-access-storage';
-import { describe, test } from '@dxos/test';
+import { createTestLevel } from '@dxos/kv-store/testing';
+import { describe, openAndClose, test } from '@dxos/test';
 
-import { AutomergeStorageAdapter } from './automerge-storage-adapter';
+import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
 
 describe('AutomergeRepo', () => {
-  // Currently failing
-  test.skip('flush', async () => {
+  test('flush', async () => {
+    const level = createTestLevel();
+    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+    await openAndClose(level, storage);
+
     const repo = new Repo({
       network: [],
-      storage: new AutomergeStorageAdapter(createStorage({ type: StorageType.NODE }).createDirectory()),
+      storage,
     });
     const handle = repo.create<{ field?: string }>();
 
@@ -26,4 +32,30 @@ describe('AutomergeRepo', () => {
       await p;
     }
   });
+
+  test('getChangeByHash', async () => {
+    const level = createTestLevel();
+    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+    await openAndClose(level, storage);
+
+    const doc = from({ foo: 'bar' });
+    const copy = clone(doc);
+    const newDoc = change(copy, 'change', (doc: any) => {
+      doc.foo = 'baz';
+    });
+
+    {
+      const heads = getHeads(newDoc);
+      const changes = heads.map((hash) => getBackend(newDoc).getChangeByHash(hash));
+      expect(changes.length).to.equal(1);
+      expect(changes[0]).to.not.be.null;
+    }
+
+    {
+      const heads = getHeads(newDoc);
+      const changes = heads.map((hash) => getBackend(doc).getChangeByHash(hash));
+      expect(changes.length).to.equal(1);
+      expect(changes[0]).to.be.null;
+    }
+  });
 });

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

@@ -0,0 +1,155 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Trigger, synchronized } 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 { log } from '@dxos/log';
+
+import { type EchoReplicator, type ReplicatorConnection, type ShouldAdvertizeParams } from './echo-replicator';
+
+/**
+ * Manages a set of {@link EchoReplicator} instances.
+ */
+export class EchoNetworkAdapter extends NetworkAdapter {
+  private readonly _replicators = new Set<EchoReplicator>();
+  /**
+   * Remote peer id -> connection.
+   */
+  private readonly _connections = new Map<PeerId, ConnectionEntry>();
+  private _lifecycleState: LifecycleState = LifecycleState.CLOSED;
+  private readonly _connected = new Trigger();
+
+  override connect(peerId: PeerId, peerMetadata?: PeerMetadata | undefined): void {
+    this.peerId = peerId;
+    this.peerMetadata = peerMetadata;
+    this._connected.wake();
+  }
+
+  override send(message: Message): void {
+    const connectionEntry = this._connections.get(message.targetId);
+    if (!connectionEntry) {
+      throw new Error('Connection not found.');
+    }
+
+    // TODO(dmaretskyi): Find a way to enforce backpressure on AM-repo.
+    connectionEntry.writer.write(message).catch((err) => {
+      if (connectionEntry.isOpen) {
+        log.catch(err);
+      }
+    });
+  }
+
+  override disconnect(): void {
+    // No-op
+  }
+
+  @synchronized
+  async open() {
+    invariant(this._lifecycleState === LifecycleState.CLOSED);
+    this._lifecycleState = LifecycleState.OPEN;
+
+    this.emit('ready', {
+      network: this,
+    });
+  }
+
+  @synchronized
+  async close() {
+    invariant(this._lifecycleState === LifecycleState.OPEN);
+
+    for (const replicator of this._replicators) {
+      await replicator.disconnect();
+    }
+    this._replicators.clear();
+
+    this._lifecycleState = LifecycleState.CLOSED;
+  }
+
+  async whenConnected() {
+    await this._connected.wait({ timeout: 10_000 });
+  }
+
+  @synchronized
+  async addReplicator(replicator: EchoReplicator) {
+    invariant(this.peerId);
+    invariant(!this._replicators.has(replicator));
+
+    await replicator.connect({
+      peerId: this.peerId,
+      onConnectionOpen: this._onConnectionOpen.bind(this),
+      onConnectionClosed: this._onConnectionClosed.bind(this),
+    });
+  }
+
+  @synchronized
+  async removeReplicator(replicator: EchoReplicator) {
+    invariant(this._replicators.has(replicator));
+    await replicator.disconnect();
+  }
+
+  async shouldAdvertize(peerId: PeerId, params: ShouldAdvertizeParams): Promise<boolean> {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      return false;
+    }
+
+    return connection.connection.shouldAdvertize(params);
+  }
+
+  private _onConnectionOpen(connection: ReplicatorConnection) {
+    invariant(!this._connections.has(connection.peerId as PeerId));
+    const reader = connection.readable.getReader();
+    const writer = connection.writable.getWriter();
+    const connectionEntry: ConnectionEntry = { connection, reader, writer, isOpen: true };
+    this._connections.set(connection.peerId as PeerId, connectionEntry);
+
+    queueMicrotask(async () => {
+      try {
+        while (true) {
+          // TODO(dmaretskyi): Find a way to enforce backpressure on AM-repo.
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+
+          this.emit('message', value);
+        }
+      } catch (err) {
+        if (connectionEntry.isOpen) {
+          log.catch(err);
+        }
+      }
+    });
+
+    this.emit('peer-candidate', {
+      peerId: connection.peerId as PeerId,
+      peerMetadata: {
+        // TODO(dmaretskyi): Refactor this.
+        dxos_peerSource: 'EchoNetworkAdapter',
+      } as any,
+    });
+  }
+
+  private _onConnectionClosed(connection: ReplicatorConnection) {
+    const entry = this._connections.get(connection.peerId as PeerId);
+    invariant(entry);
+
+    entry.isOpen = false;
+    this.emit('peer-disconnected', { peerId: connection.peerId as PeerId });
+
+    void entry.reader.cancel().catch((err) => log.catch(err));
+    void entry.writer.abort().catch((err) => log.catch(err));
+
+    this._connections.delete(connection.peerId as PeerId);
+  }
+}
+
+type ConnectionEntry = {
+  connection: ReplicatorConnection;
+  reader: ReadableStreamDefaultReader<Message>;
+  writer: WritableStreamDefaultWriter<Message>;
+  isOpen: boolean;
+};