@dxos/echo-pipeline 0.8.2-staging.7ac8446 → 0.8.2

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

@@ -2,9 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
-
-import { asyncTimeout, sleep } from '@dxos/async';
 import {
   change,
   clone,
@@ -16,7 +13,7 @@ import {
   next as A,
   save,
   saveSince,
-} from '@dxos/automerge/automerge';
+} from '@automerge/automerge';
 import {
   type AutomergeUrl,
   type DocHandle,
@@ -28,7 +25,10 @@ import {
   type PeerId,
   Repo,
   type SharePolicy,
-} from '@dxos/automerge/automerge-repo';
+} from '@automerge/automerge-repo';
+import { onTestFinished, describe, expect, test } from 'vitest';
+
+import { asyncTimeout, sleep } from '@dxos/async';
 import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
@@ -36,6 +36,7 @@ import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/
 import { openAndClose } from '@dxos/test-utils';
 import { isNonNullable, range } from '@dxos/util';
 
+import { FIND_PARAMS } from './automerge-host';
 import { EchoNetworkAdapter } from './echo-network-adapter';
 import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
 import { MeshEchoReplicator } from './mesh-echo-replicator';
@@ -51,7 +52,7 @@ describe('AutomergeRepo', () => {
     let valueDuringChange: string | undefined;
 
     handle.addListener('change', (doc) => {
-      valueDuringChange = handle.docSync()!.field;
+      valueDuringChange = handle.doc()!.field;
     });
 
     handle.change((doc: any) => {
@@ -115,7 +116,7 @@ describe('AutomergeRepo', () => {
     const [host] = repos;
     await connectAdapters(adapters);
     const url = 'automerge:3JN8F3Z4dUWEEKKFN7WE9gEGvVUT';
-    const handle = host.find(url as AutomergeUrl);
+    const handle = await host.find(url as AutomergeUrl, FIND_PARAMS);
     await handle.whenReady(['requesting']);
   });
 
@@ -132,7 +133,7 @@ describe('AutomergeRepo', () => {
 
     {
       const repo = new Repo({ network: [], storage });
-      const handle = repo.find(url as AutomergeUrl);
+      const handle = await repo.find(url as AutomergeUrl);
 
       let requestingState = false;
       queueMicrotask(async () => {
@@ -157,8 +158,7 @@ describe('AutomergeRepo', () => {
         doc.text = text;
       });
 
-      const docOnClient = client.find<any>(handle.url);
-      expect((await asyncTimeout(docOnClient.doc(), 1000))!.text).to.equal(text);
+      expect((await asyncTimeout(client.find<any>(handle.url), 1000))!.doc().text).to.equal(text);
     });
 
     test('share policy gets enabled afterwards', async () => {
@@ -177,16 +177,13 @@ describe('AutomergeRepo', () => {
       });
 
       {
-        const docOnClient = client.find(handle.url);
-        await asyncTimeout(docOnClient.whenReady(['unavailable']), 1000);
+        await client.find(handle.url, { allowableStates: ['unavailable'] });
       }
 
       sharePolicy = true;
 
       {
-        const docOnClient = client.find(handle.url);
-        // TODO(mykola): We expect the document to be available here, but it's not.
-        await asyncTimeout(docOnClient.whenReady(['unavailable']), 1000);
+        await client.find(handle.url, { allowableStates: ['unavailable'] });
       }
     });
 
@@ -206,26 +203,26 @@ describe('AutomergeRepo', () => {
 
       const firstHandle = host.create();
       firstHandle.change((doc: any) => (doc.text = 'Hello world'));
-      await host.find(firstHandle.url).whenReady();
+      await host.find(firstHandle.url);
       allowedDocs.push(firstHandle.documentId);
 
       await connectAdapters(adapters);
 
       {
-        const firstDocOnClient = client.find<any>(firstHandle.url);
+        const firstDocOnClient = await client.find<any>(firstHandle.url);
         await asyncTimeout(firstDocOnClient.whenReady(), 1000);
-        expect(firstDocOnClient.docSync()!.text).to.equal('Hello world');
+        expect(firstDocOnClient.doc()!.text).to.equal('Hello world');
       }
 
       const secondHandle = host.create();
       secondHandle.change((doc: any) => (doc.text = 'Hello world'));
-      await host.find(secondHandle.url).whenReady();
+      await host.find(secondHandle.url);
       allowedDocs.push(secondHandle.documentId);
 
       {
-        const secondDocOnClient = client.find<any>(secondHandle.url);
+        const secondDocOnClient = await client.find<any>(secondHandle.url);
         await asyncTimeout(secondDocOnClient.whenReady(), 1000);
-        expect(secondDocOnClient.docSync()!.text).to.equal('Hello world');
+        expect(secondDocOnClient.doc()!.text).to.equal('Hello world');
       }
     });
 
@@ -239,14 +236,15 @@ describe('AutomergeRepo', () => {
       await connectAdapters(adapters);
 
       const handle = host.create();
-      const docOnClient = client.find<any>(handle.url);
+      const docOnClient = await client.find<any>(handle.url, FIND_PARAMS);
       {
         const sanityText = 'Hello world';
         handle.change((doc: any) => {
           doc.sanityText = sanityText;
         });
+        await asyncTimeout(docOnClient.whenReady(), 1000);
 
-        expect((await asyncTimeout(docOnClient.doc(), 1000))!.sanityText).to.equal(sanityText);
+        expect(docOnClient.doc().sanityText).to.equal(sanityText);
       }
 
       // Disrupt connection.
@@ -259,7 +257,8 @@ describe('AutomergeRepo', () => {
         });
 
         await sleep(100);
-        expect((await asyncTimeout(docOnClient.doc(), 1000))!.offlineText).to.be.undefined;
+        await asyncTimeout(docOnClient.whenReady(), 1000);
+        expect(docOnClient.doc().offlineText).to.be.undefined;
       }
 
       // Re-establish connection.
@@ -272,8 +271,9 @@ describe('AutomergeRepo', () => {
           doc.onlineText = onlineText;
         });
         await sleep(100);
-        expect((await asyncTimeout(docOnClient.doc(), 1000))!.onlineText).to.equal(onlineText);
-        expect((await asyncTimeout(docOnClient.doc(), 1000))!.offlineText).to.equal(offlineText);
+        await asyncTimeout(docOnClient.whenReady(), 1000);
+        expect(docOnClient.doc().onlineText).to.equal(onlineText);
+        expect(docOnClient.doc().offlineText).to.equal(offlineText);
       }
     });
 
@@ -297,9 +297,9 @@ describe('AutomergeRepo', () => {
 
       // If we wait here for replication to finish naturally, the test will pass.
 
-      const docD = repoD.find(docA.url);
+      const docD = await repoD.find(docA.url);
 
-      await docD.whenReady();
+      await asyncTimeout(docD.whenReady(), 1000);
     });
 
     test('replication though a 3 peer chain', async () => {
@@ -319,9 +319,9 @@ describe('AutomergeRepo', () => {
         doc.text = 'Hello world';
       });
 
-      const _ = repoB.find(docA.url);
-      const docC = repoC.find(docA.url);
-      await docC.whenReady();
+      const _ = repoB.find(docA.url, FIND_PARAMS);
+      const docC = await repoC.find(docA.url, FIND_PARAMS);
+      await asyncTimeout(docC.whenReady(), 1000);
     });
 
     test('replicate document after request', async () => {
@@ -338,7 +338,7 @@ describe('AutomergeRepo', () => {
         doc.text = 'Hello world';
       });
 
-      const docB = client.find(docA.url);
+      const docB = await client.find(docA.url, { allowableStates: ['unavailable'] });
 
       // Request document from repoB.
       await asyncTimeout(docB.whenReady([unavailable]), 1_000);
@@ -373,11 +373,12 @@ describe('AutomergeRepo', () => {
       await connectAdapters(adapters);
 
       // Load doc on peer1
-      const hostHandle = peer1.find<any>(url as AutomergeUrl);
+      const hostHandle = await peer1.find<any>(url as AutomergeUrl);
 
       // Doc should be pushed to peer2
-      await expect.poll(() => hostHandle.docSync()!.text).not.toBeUndefined();
-      await expect.poll(() => peer2.handles[hostHandle.documentId].docSync()).toEqual(hostHandle.docSync());
+      await hostHandle.whenReady();
+      await expect.poll(() => hostHandle.doc()!.text).not.toBeUndefined();
+      await expect.poll(() => peer2.handles[hostHandle.documentId].doc()).toEqual(hostHandle.doc());
     });
 
     test('client cold-starts and syncs doc from a Repo', async () => {
@@ -390,8 +391,8 @@ describe('AutomergeRepo', () => {
       };
 
       // Sync handshake.
-      let syncedHeads = getHeads(serverHandle.docSync()!);
-      receiveByClient(save(serverHandle.docSync()!));
+      let syncedHeads = getHeads(serverHandle.doc()!);
+      receiveByClient(save(serverHandle.doc()!));
 
       serverHandle.on('change', ({ doc }) => {
         // Note: This is mock of a sync protocol between client and server.
@@ -420,7 +421,7 @@ describe('AutomergeRepo', () => {
     test('client creates doc and syncs with a Repo', async () => {
       const repo = new Repo({ network: [] });
       const receiveByServer = async (blob: Uint8Array, docId: DocumentId) => {
-        const serverHandle = repo.find(docId);
+        const serverHandle = await repo.find(docId, FIND_PARAMS);
         serverHandle.update((doc) => {
           return A.loadIncremental(doc, blob);
         });
@@ -445,8 +446,8 @@ describe('AutomergeRepo', () => {
         });
         await sendDoc(clientDoc);
 
-        await repo.find(documentId).whenReady();
-        expect(repo.find<any>(documentId).docSync()!.field).to.deep.equal(value);
+        const serverHandle = await repo.find<any>(documentId);
+        expect(serverHandle.doc()!.field).to.deep.equal(value);
       }
     });
 
@@ -456,7 +457,7 @@ describe('AutomergeRepo', () => {
       await connectAdapters(adapters);
 
       const handleA = repoA.create<any>();
-      const handleB = repoB.find<any>(handleA.url);
+      const handleB = await repoB.find<any>(handleA.url);
 
       const text = 'Hello world';
       handleA.update((doc: any) => {
@@ -465,10 +466,11 @@ describe('AutomergeRepo', () => {
         });
       });
 
-      expect(handleA.docSync()!.text).to.equal(text);
+      expect(handleA.doc()!.text).to.equal(text);
 
+      await sleep(100);
       await asyncTimeout(handleB.whenReady(), 1000);
-      expect(handleB.docSync()!.text).to.equal(text);
+      expect(handleB.doc()!.text).to.equal(text);
     });
   });
 
@@ -493,11 +495,10 @@ describe('AutomergeRepo', () => {
         await expect
           .poll(
             async () => {
-              const docOnPeer2 = peer2.repo.find<any>(handle.url);
-              const doc = await asyncTimeout(docOnPeer2.doc(), 1000);
-              return doc!.text;
+              const docOnPeer2 = await peer2.repo.find<any>(handle.url);
+              return docOnPeer2.doc()!.text;
             },
-            { timeout: 1_000 },
+            { timeout: 5_000 },
           )
           .toEqual(text);
       }
@@ -510,17 +511,18 @@ describe('AutomergeRepo', () => {
         handle.change((doc: any) => {
           doc.offlineText = offlineText;
         });
-        const docOnPeer2 = peer2.repo.find<any>(handle.url);
+        const docOnPeer2 = await peer2.repo.find<any>(handle.url);
         await sleep(100);
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000))!.offlineText).to.be.undefined;
+        await asyncTimeout(docOnPeer2.whenReady(), 1000);
+        expect(docOnPeer2.doc()!.offlineText).to.be.undefined;
       }
 
       {
         // Wait for offline changes to be synced after reconnect.
-        const docOnPeer2 = peer2.repo.find<any>(handle.url);
+        const docOnPeer2 = await peer2.repo.find<any>(handle.url);
         await docChangeAfterAction(docOnPeer2, () => connectPeers(spaceKey, teleportBuilder, peer1, peer2));
         await docOnPeer2.whenReady();
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000))!.offlineText).to.eq(offlineText);
+        expect(docOnPeer2.doc()!.offlineText).to.eq(offlineText);
 
         // Test connection.
         const onlineText = 'This has been written after the connection was re-established';
@@ -530,7 +532,7 @@ describe('AutomergeRepo', () => {
           });
         });
         await docOnPeer2.whenReady();
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000))!.onlineText).to.eq(onlineText);
+        expect(docOnPeer2.doc()!.onlineText).to.eq(onlineText);
       }
     });
 
@@ -556,11 +558,11 @@ describe('AutomergeRepo', () => {
       });
       await connectPeers(spaceKey, teleportBuilder, peerWithDocs.peer, peer2);
 
-      const shouldNotFindDoc = peer2.repo.find(docNotInRemoteCollection.url);
-      const shouldFindDoc = peer2.repo.find(docInRemoteCollection.url);
+      const shouldNotFindDoc = await peer2.repo.find(docNotInRemoteCollection.url, FIND_PARAMS);
+      const shouldFindDoc = await peer2.repo.find(docInRemoteCollection.url, FIND_PARAMS);
       await shouldFindDoc.whenReady();
-      expect(shouldFindDoc.docSync()).to.deep.eq(docInRemoteCollection.docSync());
-      await shouldNotFindDoc.whenReady(['unavailable']);
+      expect(shouldFindDoc.doc()).to.deep.eq(docInRemoteCollection.doc());
+      await asyncTimeout(shouldNotFindDoc.whenReady(['unavailable']), 1000);
     });
 
     /**
@@ -590,12 +592,12 @@ describe('AutomergeRepo', () => {
       await connectPeers(spaceKey, teleportBuilder, peerWithDocs.peer, peer2);
       await connectPeers(anotherSpaceKey, teleportBuilder, peer2, peerFromAnotherSpace);
 
-      const loadedDocument = peer2.repo.find(document.url);
-      await loadedDocument.whenReady();
+      const loadedDocument = await peer2.repo.find(document.url, FIND_PARAMS);
+      await asyncTimeout(loadedDocument.whenReady(), 1000);
 
       await sleep(200);
-      const doc = peerFromAnotherSpace.repo.find(document.url);
-      await doc.whenReady(['unavailable']);
+      const doc = await peerFromAnotherSpace.repo.find(document.url, { allowableStates: ['unavailable'] });
+      await asyncTimeout(doc.whenReady(['unavailable']), 1000);
     });
 
     test('collection-sync with chain of peers', async () => {
@@ -624,12 +626,12 @@ describe('AutomergeRepo', () => {
       await connectPeers(spaceKey, teleportBuilder, peerWithDocs.peer, peer2);
       await connectPeers(spaceKey, teleportBuilder, peer2, peer3);
 
-      const loadedDocument = peer2.repo.find(document.url);
+      const loadedDocument = await peer2.repo.find(document.url, FIND_PARAMS);
       await loadedDocument.whenReady();
 
-      const doc = peer3.repo.find(document.url);
+      const doc = await peer3.repo.find(document.url, FIND_PARAMS);
       await doc.whenReady();
-      expect(doc.docSync()).to.deep.eq(document.docSync());
+      expect(doc.doc()).to.deep.eq(document.doc());
     });
   });
 
@@ -692,8 +694,6 @@ const createRepoTopology = async <Peers extends string[], Peer extends string =
 
 const connectAdapters = async (pairs: [TestAdapter, TestAdapter][], options?: { noEmitPeerCandidate?: boolean }) => {
   for (const pair of pairs) {
-    pair[0].ready();
-    pair[1].ready();
     await pair[0].onConnect.wait();
     await pair[1].onConnect.wait();
     if (!options?.noEmitPeerCandidate) {

package/src/automerge/collection-synchronizer.test.ts

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import type { PeerId } from '@automerge/automerge-repo';
 import { onTestFinished, describe, expect, test } from 'vitest';
 
 import { sleep } from '@dxos/async';
-import type { PeerId } from '@dxos/automerge/automerge-repo';
 
 import { CollectionSynchronizer, diffCollectionState, type CollectionState } from './collection-synchronizer';
 

package/src/automerge/collection-synchronizer.ts

@@ -2,9 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { next as am } from '@automerge/automerge';
+import type { DocumentId, PeerId } from '@automerge/automerge-repo';
+
 import { asyncReturn, Event, scheduleTask, scheduleTaskInterval } from '@dxos/async';
-import { next as am } from '@dxos/automerge/automerge';
-import type { DocumentId, PeerId } from '@dxos/automerge/automerge-repo';
 import { Resource, type Context } from '@dxos/context';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/tracing';
@@ -69,7 +70,7 @@ export class CollectionSynchronizer extends Resource {
     return this._perCollectionStates.get(collectionId)?.localState;
   }
 
-  setLocalCollectionState(collectionId: string, state: CollectionState) {
+  setLocalCollectionState(collectionId: string, state: CollectionState): void {
     this._activeCollections.add(collectionId);
 
     log('setLocalCollectionState', { collectionId, state });
@@ -83,7 +84,7 @@ export class CollectionSynchronizer extends Resource {
     });
   }
 
-  clearLocalCollectionState(collectionId: string) {
+  clearLocalCollectionState(collectionId: string): void {
     this._activeCollections.delete(collectionId);
     this._perCollectionStates.delete(collectionId);
     log('clearLocalCollectionState', { collectionId });
@@ -93,7 +94,7 @@ export class CollectionSynchronizer extends Resource {
     return this._getOrCreatePerCollectionState(collectionId).remoteStates;
   }
 
-  refreshCollection(collectionId: string) {
+  refreshCollection(collectionId: string): void {
     let scheduleAnotherRefresh = false;
     const state = this._getOrCreatePerCollectionState(collectionId);
     for (const peerId of this._connectedPeers) {
@@ -115,7 +116,7 @@ export class CollectionSynchronizer extends Resource {
   /**
    * Callback when a connection to a peer is established.
    */
-  onConnectionOpen(peerId: PeerId) {
+  onConnectionOpen(peerId: PeerId): void {
     const spanId = getSpanName(peerId);
     trace.spanStart({
       id: spanId,
@@ -144,7 +145,7 @@ export class CollectionSynchronizer extends Resource {
   /**
    * Callback when a connection to a peer is closed.
    */
-  onConnectionClosed(peerId: PeerId) {
+  onConnectionClosed(peerId: PeerId): void {
     this._connectedPeers.delete(peerId);
 
     for (const perCollectionState of this._perCollectionStates.values()) {
@@ -155,7 +156,7 @@ export class CollectionSynchronizer extends Resource {
   /**
    * Callback when a peer queries the state of a collection.
    */
-  onCollectionStateQueried(collectionId: string, peerId: PeerId) {
+  onCollectionStateQueried(collectionId: string, peerId: PeerId): void {
     const perCollectionState = this._getOrCreatePerCollectionState(collectionId);
 
     if (perCollectionState.localState) {
@@ -166,7 +167,7 @@ export class CollectionSynchronizer extends Resource {
   /**
    * Callback when a peer sends the state of a collection.
    */
-  onRemoteStateReceived(collectionId: string, peerId: PeerId, state: CollectionState) {
+  onRemoteStateReceived(collectionId: string, peerId: PeerId, state: CollectionState): void {
     log('onRemoteStateReceived', { collectionId, peerId, state });
     validateCollectionState(state);
     const perCollectionState = this._getOrCreatePerCollectionState(collectionId);
@@ -200,7 +201,7 @@ export class CollectionSynchronizer extends Resource {
     }));
   }
 
-  private _refreshInterestedPeers(collectionId: string) {
+  private _refreshInterestedPeers(collectionId: string): void {
     for (const peerId of this._connectedPeers) {
       if (this._shouldSyncCollection(collectionId, peerId)) {
         this._getOrCreatePerCollectionState(collectionId).interestedPeers.add(peerId);

package/src/automerge/echo-data-monitor.ts

@@ -2,7 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Message } from '@dxos/automerge/automerge-repo';
+import { type Message } from '@automerge/automerge-repo';
+
 import { type TimeAware, trace } from '@dxos/tracing';
 import { CircularBuffer, mapValues, SlidingWindowSummary, type SlidingWindowSummaryConfig } from '@dxos/util';
 
@@ -26,7 +27,7 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
   private readonly _localTimeSeries = createLocalTimeSeries();
   private readonly _storageAverages = createStorageAverages();
   private readonly _replicationAverages = createNetworkAverages();
-  private readonly _sizeByMessageType: { [type: string]: SlidingWindowSummary } = {};
+  private readonly _sizeByMessage: { [type: string]: SlidingWindowSummary } = {};
   private readonly _lastReceivedMessages = new CircularBuffer<StoredMessage>(100);
   private readonly _lastSentMessages = new CircularBuffer<StoredMessage>(100);
 
@@ -34,7 +35,7 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
 
   constructor(private readonly _params: EchoDataMonitorOptions = { timeSeriesLength: 30 }) {}
 
-  public tick(timeMs: number) {
+  public tick(timeMs: number): void {
     this._advanceTimeWindow(timeMs - this._lastTick);
     this._lastTick = timeMs;
   }
@@ -68,8 +69,8 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
           countPerSecond: this._replicationAverages.sentPerSecond.average(),
           failedPerSecond: this._replicationAverages.sendsFailedPerSecond.average(),
         },
-        countByMessageType: this._computeMessageHistogram('type'),
-        avgSizeByMessageType: mapValues(this._sizeByMessageType, (summary) => summary.average()),
+        countByMessage: this._computeMessageHistogram('type'),
+        avgSizeByMessage: mapValues(this._sizeByMessage, (summary) => summary.average()),
       },
     };
   }
@@ -99,7 +100,7 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     return this._computeMessageHistogram('peerId');
   }
 
-  private _advanceTimeWindow(millisPassed: number) {
+  private _advanceTimeWindow(millisPassed: number): void {
     const oldMetrics = Object.freeze(this._activeCounters);
     this._activeCounters = createLocalCounters();
     this._lastCompleteCounters = oldMetrics;
@@ -114,7 +115,7 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     }
   }
 
-  private _addToTimeSeries<T extends object>(values: T, timeSeries: TimeSeries<T>) {
+  private _addToTimeSeries<T extends object>(values: T, timeSeries: TimeSeries<T>): void {
     for (const [key, value] of Object.entries(values)) {
       const values: (typeof value)[] = (timeSeries as any)[key];
       values.push(value);
@@ -124,7 +125,7 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     }
   }
 
-  private _reportPerSecondRate(metrics: LocalCounters) {
+  private _reportPerSecondRate(metrics: LocalCounters): void {
     const toReport: [string, number, SlidingWindowSummary][] = [
       ['storage.load', metrics.storage.loadedChunks, this._storageAverages.loadsPerSecond],
       ['storage.store', metrics.storage.storedChunks, this._storageAverages.storesPerSecond],
@@ -143,17 +144,17 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     this._replicationAverages.sendsFailedPerSecond.record(metrics.replication.failed);
   }
 
-  public recordPeerConnected(peerId: string) {
+  public recordPeerConnected(peerId: string): void {
     this._activeCounters.byPeerId[peerId] = createMessageCounter();
     this._connectionsCount++;
   }
 
-  public recordPeerDisconnected(peerId: string) {
+  public recordPeerDisconnected(peerId: string): void {
     this._connectionsCount--;
     delete this._activeCounters.byPeerId[peerId];
   }
 
-  public recordBytesStored(count: number) {
+  public recordBytesStored(count: number): void {
     this._activeCounters.storage.storedChunks++;
     this._activeCounters.storage.storedBytes += count;
     this._storageAverages.storedChunkSize.record(count);
@@ -168,14 +169,14 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     this._storageAverages.storeDuration.record(durationMs);
   }
 
-  public recordBytesLoaded(count: number) {
+  public recordBytesLoaded(count: number): void {
     this._activeCounters.storage.loadedChunks++;
     this._activeCounters.storage.loadedBytes += count;
     this._storageAverages.loadedChunkSize.record(count);
     trace.metrics.distribution('dxos.echo.storage.bytes-loaded', count, { unit: 'bytes' });
   }
 
-  public recordMessageSent(message: Message, duration: number) {
+  public recordMessageSent(message: Message, duration: number): void {
     let metricsGroupName;
     const bytes = getByteCount(message);
     const tags = { type: message.type };
@@ -196,7 +197,7 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     this._lastSentMessages.push({ type: message.type, peerId: message.targetId });
   }
 
-  public recordMessageReceived(message: Message) {
+  public recordMessageReceived(message: Message): void {
     const bytes = getByteCount(message);
     const tags = { type: message.type };
     if (isAutomergeProtocolMessage(message)) {
@@ -212,7 +213,7 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     this._lastReceivedMessages.push({ type: message.type, peerId: message.senderId });
   }
 
-  public recordMessageSendingFailed(message: Message) {
+  public recordMessageSendingFailed(message: Message): void {
     const tags = { type: message.type, success: false };
     if (isAutomergeProtocolMessage(message)) {
       this._activeCounters.replication.failed++;
@@ -224,8 +225,8 @@ export class EchoDataMonitor implements StorageAdapterDataMonitor, NetworkDataMo
     messageCounts.failed++;
   }
 
-  private _getStatsForType(message: Message) {
-    const messageSize = (this._sizeByMessageType[message.type] ??= createSlidingWindow());
+  private _getStatsForType(message: Message): { messageCounts: MessageCounts; messageSize: SlidingWindowSummary } {
+    const messageSize = (this._sizeByMessage[message.type] ??= createSlidingWindow());
     const messageCounts = (this._activeCounters.byType[message.type] ??= createMessageCounter());
     return { messageCounts, messageSize };
   }
@@ -269,7 +270,7 @@ type MessageCounts = {
 type MessageCountTimeSeries = TimeSeries<MessageCounts>;
 
 type MessageAttributeHistogram = {
-  [messageType: string]: {
+  [Message: string]: {
     received: number;
     sent: number;
   };
@@ -287,8 +288,8 @@ export type EchoDataStats = {
     connections: number;
     receivedMessages: BaseDataOpStats;
     sentMessages: TimedDataOpStats & { failedPerSecond: number };
-    avgSizeByMessageType: { [messageType: string]: number };
-    countByMessageType: MessageAttributeHistogram;
+    avgSizeByMessage: { [Message: string]: number };
+    countByMessage: MessageAttributeHistogram;
   };
 };
 

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

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { cbor, type PeerId } from '@automerge/automerge-repo';
 import { onTestFinished, describe, expect, test } from 'vitest';
 
 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';