@dxos/echo-pipeline 0.8.3 → 0.8.4-main.1068cf700f

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

@@ -2,9 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
-import { NetworkAdapter, type Message, type PeerId, type PeerMetadata } from '@automerge/automerge-repo';
-
-import { synchronized, Trigger } from '@dxos/async';
+import {
+  type DocumentId,
+  type Heads,
+  type Message,
+  NetworkAdapter,
+  type PeerId,
+  type PeerMetadata,
+} from '@automerge/automerge-repo';
+
+import { Event, Trigger, synchronized } from '@dxos/async';
 import { LifecycleState } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey } from '@dxos/keys';
@@ -12,20 +19,21 @@ import { log } from '@dxos/log';
 import type { AutomergeProtocolMessage } from '@dxos/protocols';
 import { isNonNullable } from '@dxos/util';
 
+import { createIdFromSpaceKey } from '../common/space-id';
+
 import {
-  type EchoReplicator,
-  type RemoteDocumentExistenceCheckParams,
-  type ReplicatorConnection,
-  type ShouldAdvertiseParams,
-  type ShouldSyncCollectionParams,
+  type AutomergeReplicator,
+  type AutomergeReplicatorConnection,
+  type RemoteDocumentExistenceCheckProps,
+  type ShouldAdvertiseProps,
+  type ShouldSyncCollectionProps,
 } from './echo-replicator';
 import {
-  isCollectionQueryMessage,
-  isCollectionStateMessage,
   type CollectionQueryMessage,
   type CollectionStateMessage,
+  isCollectionQueryMessage,
+  isCollectionStateMessage,
 } from './network-protocol';
-import { createIdFromSpaceKey } from '../common/space-id';
 
 export interface NetworkDataMonitor {
   recordPeerConnected(peerId: string): void;
@@ -35,9 +43,9 @@ export interface NetworkDataMonitor {
   recordMessageSendingFailed(message: Message): void;
 }
 
-export type EchoNetworkAdapterParams = {
+export type EchoNetworkAdapterProps = {
   getContainingSpaceForDocument: (documentId: string) => Promise<PublicKey | null>;
-  isDocumentInRemoteCollection: (params: RemoteDocumentExistenceCheckParams) => Promise<boolean>;
+  isDocumentInRemoteCollection: (params: RemoteDocumentExistenceCheckProps) => Promise<boolean>;
   onCollectionStateQueried: (collectionId: string, peerId: PeerId) => void;
   onCollectionStateReceived: (collectionId: string, peerId: PeerId, state: unknown) => void;
   monitor?: NetworkDataMonitor;
@@ -45,16 +53,17 @@ export type EchoNetworkAdapterParams = {
 
 type ConnectionEntry = {
   isOpen: boolean;
-  connection: ReplicatorConnection;
+  connection: AutomergeReplicatorConnection;
   reader: ReadableStreamDefaultReader<AutomergeProtocolMessage>;
   writer: WritableStreamDefaultWriter<AutomergeProtocolMessage>;
+  requestedDocuments: Set<DocumentId>;
 };
 
 /**
- * Manages a set of {@link EchoReplicator} instances.
+ * Manages a set of {@link AutomergeReplicator} instances.
  */
 export class EchoNetworkAdapter extends NetworkAdapter {
-  private readonly _replicators = new Set<EchoReplicator>();
+  private readonly _replicators = new Set<AutomergeReplicator>();
   /**
    * Remote peer id -> connection.
    */
@@ -63,7 +72,9 @@ export class EchoNetworkAdapter extends NetworkAdapter {
   private readonly _connected = new Trigger();
   private readonly _ready = new Trigger();
 
-  constructor(private readonly _params: EchoNetworkAdapterParams) {
+  public readonly documentRequested = new Event<{ documentId: DocumentId; peerId: PeerId }>();
+
+  constructor(private readonly _params: EchoNetworkAdapterProps) {
     super();
   }
 
@@ -125,7 +136,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
   }
 
   @synchronized
-  async addReplicator(replicator: EchoReplicator): Promise<void> {
+  async addReplicator(replicator: AutomergeReplicator): Promise<void> {
     invariant(this._lifecycleState === LifecycleState.OPEN);
     invariant(this.peerId);
     invariant(!this._replicators.has(replicator));
@@ -146,14 +157,14 @@ export class EchoNetworkAdapter extends NetworkAdapter {
   }
 
   @synchronized
-  async removeReplicator(replicator: EchoReplicator): Promise<void> {
+  async removeReplicator(replicator: AutomergeReplicator): Promise<void> {
     invariant(this._lifecycleState === LifecycleState.OPEN);
     invariant(this._replicators.has(replicator));
     await replicator.disconnect();
     this._replicators.delete(replicator);
   }
 
-  async shouldAdvertise(peerId: PeerId, params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(peerId: PeerId, params: ShouldAdvertiseProps): Promise<boolean> {
     const connection = this._connections.get(peerId);
     if (!connection) {
       return false;
@@ -162,7 +173,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     return connection.connection.shouldAdvertise(params);
   }
 
-  shouldSyncCollection(peerId: PeerId, params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(peerId: PeerId, params: ShouldSyncCollectionProps): boolean {
     const connection = this._connections.get(peerId);
     if (!connection) {
       return false;
@@ -203,6 +214,30 @@ export class EchoNetworkAdapter extends NetworkAdapter {
       .filter(isNonNullable);
   }
 
+  bundleSyncEnabledForPeer(peerId: PeerId): boolean {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      return false;
+    }
+    return connection.connection.bundleSyncEnabled;
+  }
+
+  async pushBundle(peerId: PeerId, bundle: { documentId: DocumentId; data: Uint8Array; heads: Heads }[]) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      throw new Error('Connection not found.');
+    }
+    return connection.connection.pushBundle!(bundle);
+  }
+
+  async pullBundle(peerId: PeerId, docHeads: Record<DocumentId, Heads>) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      throw new Error('Connection not found.');
+    }
+    return connection.connection.pullBundle!(docHeads);
+  }
+
   private _send(message: Message): void {
     const connectionEntry = this._connections.get(message.targetId);
     if (!connectionEntry) {
@@ -225,7 +260,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
       });
   }
 
-  private _onConnectionOpen(connection: ReplicatorConnection): void {
+  private _onConnectionOpen(connection: AutomergeReplicatorConnection): void {
     log('connection opened', { peerId: connection.peerId });
     invariant(!this._connections.has(connection.peerId as PeerId));
     const connectionEntry: ConnectionEntry = {
@@ -233,6 +268,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
       connection,
       reader: connection.readable.getReader(),
       writer: connection.writable.getWriter(),
+      requestedDocuments: new Set(),
     };
 
     this._connections.set(connection.peerId as PeerId, connectionEntry);
@@ -247,7 +283,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
             break;
           }
 
-          this._onMessage(value as Message);
+          this._onMessage(connectionEntry, value as Message);
         }
       } catch (err) {
         if (connectionEntry.isOpen) {
@@ -261,7 +297,15 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this._params.monitor?.recordPeerConnected(connection.peerId);
   }
 
-  private _onMessage(message: Message): void {
+  private _onMessage(connectionEntry: ConnectionEntry, message: Message): void {
+    const amMessage = message as AutomergeProtocolMessage;
+    if (amMessage.type === 'request') {
+      this.documentRequested.emit({
+        documentId: amMessage.documentId as DocumentId,
+        peerId: connectionEntry.connection.peerId as PeerId,
+      });
+    }
+
     if (isCollectionQueryMessage(message)) {
       this._params.onCollectionStateQueried(message.collectionId, message.senderId);
     } else if (isCollectionStateMessage(message)) {
@@ -272,7 +316,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this._params.monitor?.recordMessageReceived(message);
   }
 
-  private _onConnectionClosed(connection: ReplicatorConnection): void {
+  private _onConnectionClosed(connection: AutomergeReplicatorConnection): void {
     log('connection closed', { peerId: connection.peerId });
     const entry = this._connections.get(connection.peerId as PeerId);
     invariant(entry);
@@ -281,8 +325,9 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this.emit('peer-disconnected', { peerId: connection.peerId as PeerId });
     this._params.monitor?.recordPeerDisconnected(connection.peerId);
 
-    void entry.reader.cancel().catch((err) => log.catch(err));
     void entry.writer.abort().catch((err) => log.catch(err));
+    void entry.reader.cancel().catch((err) => log.catch(err));
+
     this._connections.delete(connection.peerId as PeerId);
   }
 
@@ -290,7 +335,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
    * Trigger doc-synchronizer shared documents set recalculation. Happens on peer-candidate.
    * TODO(y): replace with a proper API call when sharePolicy update becomes supported by automerge-repo
    */
-  private _onConnectionAuthScopeChanged(connection: ReplicatorConnection): void {
+  private _onConnectionAuthScopeChanged(connection: AutomergeReplicatorConnection): void {
     log('Connection auth scope changed', { peerId: connection.peerId });
     const entry = this._connections.get(connection.peerId as PeerId);
     invariant(entry);
@@ -298,7 +343,7 @@ export class EchoNetworkAdapter extends NetworkAdapter {
     this._emitPeerCandidate(connection);
   }
 
-  private _emitPeerCandidate(connection: ReplicatorConnection): void {
+  private _emitPeerCandidate(connection: AutomergeReplicatorConnection): void {
     this.emit('peer-candidate', {
       peerId: connection.peerId as PeerId,
       peerMetadata: createEchoPeerMetadata(),

package/src/automerge/echo-replicator.ts

@@ -2,14 +2,18 @@
 // Copyright 2024 DXOS.org
 //
 
+import { type Heads } from '@automerge/automerge';
+import { type DocumentId } from '@automerge/automerge-repo';
+
 import { type PublicKey, type SpaceId } from '@dxos/keys';
-import type { AutomergeProtocolMessage } from '@dxos/protocols';
+import { type AutomergeProtocolMessage } from '@dxos/protocols';
 
-export interface EchoReplicator {
+// TODO(burdon): Rename AutomergeReplicator?
+export interface AutomergeReplicator {
   /**
    * Called on when replicator is added to EchoHost.
    */
-  connect(context: EchoReplicatorContext): Promise<void>;
+  connect(context: AutomergeReplicatorContext): Promise<void>;
 
   /**
    * Called on when replicator is removed from EchoHost.
@@ -17,7 +21,7 @@ export interface EchoReplicator {
   disconnect(): Promise<void>;
 }
 
-export interface EchoReplicatorContext {
+export interface AutomergeReplicatorContext {
   /**
    * Our own peer id.
    */
@@ -28,16 +32,20 @@ export interface EchoReplicatorContext {
    */
   getContainingSpaceForDocument(documentId: string): Promise<PublicKey | null>;
   getContainingSpaceIdForDocument(documentId: string): Promise<SpaceId | null>;
-  isDocumentInRemoteCollection(params: RemoteDocumentExistenceCheckParams): Promise<boolean>;
 
-  onConnectionOpen(connection: ReplicatorConnection): void;
-  onConnectionClosed(connection: ReplicatorConnection): void;
-  onConnectionAuthScopeChanged(connection: ReplicatorConnection): void;
+  /**
+   * Returns false if collection sync hasn't happened yet.
+   */
+  isDocumentInRemoteCollection(params: RemoteDocumentExistenceCheckProps): Promise<boolean>;
+
+  onConnectionOpen(connection: AutomergeReplicatorConnection): void;
+  onConnectionClosed(connection: AutomergeReplicatorConnection): void;
+  onConnectionAuthScopeChanged(connection: AutomergeReplicatorConnection): void;
 }
 
-export interface ReplicatorConnection {
+export interface AutomergeReplicatorConnection {
   /**
-   * Remove peer id.
+   * Remote peer id.
    */
   get peerId(): string;
 
@@ -55,23 +63,40 @@ export interface ReplicatorConnection {
    * @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.
    */
-  shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean>;
+  shouldAdvertise(params: ShouldAdvertiseProps): Promise<boolean>;
 
   /**
    * @returns true if the collection should be synced to this peer.
    */
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean;
+  shouldSyncCollection(params: ShouldSyncCollectionProps): boolean;
+
+  /**
+   * Batch syncing considered enabled if AutomergeReplicatorConnection implements `pushBatch` and `pullBatch` methods.
+   * @returns true if the batch syncing is enabled.
+   */
+  get bundleSyncEnabled(): boolean;
+
+  /**
+   * Pushes the batch of documents to the remote peer.
+   */
+  pushBundle?(bundle: { documentId: DocumentId; data: Uint8Array; heads: Heads }[]): Promise<void>;
+
+  /**
+   * Pulls the batch of documents from the remote peer.
+   */
+  // TODO(mykola): Use automerge-repo-bundles Bundle type here.
+  pullBundle?(docHeads: Record<DocumentId, Heads>): Promise<Record<DocumentId, Uint8Array>>;
 }
 
-export type ShouldAdvertiseParams = {
+export type ShouldAdvertiseProps = {
   documentId: string;
 };
 
-export type ShouldSyncCollectionParams = {
+export type ShouldSyncCollectionProps = {
   collectionId: string;
 };
 
-export type RemoteDocumentExistenceCheckParams = {
+export type RemoteDocumentExistenceCheckProps = {
   peerId: string;
   documentId: string;
 };

package/src/automerge/heads-store.ts

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

package/src/automerge/index.ts

@@ -5,7 +5,7 @@
 export * from './automerge-host';
 export * from './leveldb-storage-adapter';
 export * from './mesh-echo-replicator';
-export * from './echo-replicator';
+export type * from './echo-replicator';
 export { diffCollectionState } from './collection-synchronizer';
 export * from './space-collection';
 export * from './echo-data-monitor';

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

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 // s
 
-import { type StorageAdapterInterface, type Chunk, type StorageKey } from '@automerge/automerge-repo';
+import { type Chunk, type StorageAdapterInterface, type StorageKey } from '@automerge/automerge-repo';
 import { type MixedEncoding } from 'level-transcoder';
 
-import { LifecycleState, Resource } from '@dxos/context';
+import { Resource } from '@dxos/context';
 import { type BatchLevel, type SublevelDB } from '@dxos/kv-store';
 import { type MaybePromise } from '@dxos/util';
 
@@ -16,27 +16,27 @@ export interface StorageAdapterDataMonitor {
   recordStoreDuration(durationMs: number): void;
 }
 
-export type LevelDBStorageAdapterParams = {
+export type LevelDBStorageAdapterProps = {
   db: SublevelDB;
   callbacks?: StorageCallbacks;
   monitor?: StorageAdapterDataMonitor;
 };
 
-export type BeforeSaveParams = { path: StorageKey; batch: BatchLevel };
+export type BeforeSaveProps = { path: StorageKey; batch: BatchLevel };
 
 export interface StorageCallbacks {
-  beforeSave(params: BeforeSaveParams): MaybePromise<void>;
+  beforeSave(params: BeforeSaveProps): MaybePromise<void>;
   afterSave(path: StorageKey): MaybePromise<void>;
 }
 
 export class LevelDBStorageAdapter extends Resource implements StorageAdapterInterface {
-  constructor(private readonly _params: LevelDBStorageAdapterParams) {
+  constructor(private readonly _params: LevelDBStorageAdapterProps) {
     super();
   }
 
   async load(keyArray: StorageKey): Promise<Uint8Array | undefined> {
     try {
-      if (this._lifecycleState !== LifecycleState.OPEN) {
+      if (!this.isOpen) {
         // TODO(mykola): this should be an error.
         return undefined;
       }
@@ -54,7 +54,7 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
   }
 
   async save(keyArray: StorageKey, binary: Uint8Array): Promise<void> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return undefined;
     }
     const startMs = Date.now();
@@ -72,14 +72,14 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
   }
 
   async remove(keyArray: StorageKey): Promise<void> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return undefined;
     }
     await this._params.db.del<StorageKey>(keyArray, { ...encodingOptions });
   }
 
   async loadRange(keyPrefix: StorageKey): Promise<Chunk[]> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return [];
     }
     const startMs = Date.now();
@@ -100,7 +100,7 @@ export class LevelDBStorageAdapter extends Resource implements StorageAdapterInt
   }
 
   async removeRange(keyPrefix: StorageKey): Promise<void> {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
+    if (!this.isOpen) {
       return undefined;
     }
     const batch = this._params.db.batch();

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

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

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

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

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

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';

package/src/common/space-id.ts

@@ -18,7 +18,7 @@ export const createIdFromSpaceKey = async (spaceKey: PublicKey): Promise<SpaceId
     return cachedValue;
   }
 
-  const digest = await subtleCrypto.digest('SHA-256', spaceKey.asUint8Array());
+  const digest = await subtleCrypto.digest('SHA-256', spaceKey.asUint8Array() as Uint8Array<ArrayBuffer>);
 
   const bytes = new Uint8Array(digest).slice(0, SpaceId.byteLength);
   const spaceId = SpaceId.encode(bytes);