@dxos/client-services 0.6.5 → 0.6.6-main.e1a6e1f

package/src/packlets/spaces/data-space-manager.ts

@@ -6,24 +6,25 @@ import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { type Doc } from '@dxos/automerge/automerge';
 import { type AutomergeUrl, type DocHandle } from '@dxos/automerge/automerge-repo';
 import { PropertiesType } from '@dxos/client-protocol';
-import { Context, cancelWithContext } from '@dxos/context';
+import { LifecycleState, Resource, cancelWithContext } from '@dxos/context';
 import {
+  createAdmissionCredentials,
   getCredentialAssertion,
   type CredentialSigner,
   type DelegateInvitationCredential,
-  createAdmissionCredentials,
   type MemberInfo,
 } from '@dxos/credentials';
-import { convertLegacyReferences, findInlineObjectOfType, type EchoHost } from '@dxos/echo-db';
+import { convertLegacyReferences, findInlineObjectOfType, type EchoEdgeReplicator, type EchoHost } from '@dxos/echo-db';
 import {
   AuthStatus,
+  CredentialServerExtension,
+  type MeshEchoReplicator,
   type MetadataStore,
   type Space,
   type SpaceManager,
   type SpaceProtocol,
   type SpaceProtocolSession,
 } from '@dxos/echo-pipeline';
-import { CredentialServerExtension } from '@dxos/echo-pipeline';
 import {
   LEGACY_TYPE_PROPERTIES,
   SpaceDocVersion,
@@ -32,18 +33,20 @@ import {
   type SpaceDoc,
 } from '@dxos/echo-protocol';
 import { TYPE_PROPERTIES, generateEchoId, getTypeReference } from '@dxos/echo-schema';
-import { type FeedStore, writeMessages } from '@dxos/feed-store';
+import type { EdgeConnection } from '@dxos/edge-client';
+import { writeMessages, type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { trace as Trace, AlreadyJoinedError } from '@dxos/protocols';
+import { AlreadyJoinedError, trace as Trace } from '@dxos/protocols';
 import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { SpaceMember, type Credential, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type DelegateSpaceInvitation } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type PeerState } from '@dxos/protocols/proto/dxos/mesh/presence';
+import { type Teleport } from '@dxos/teleport';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { type Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
@@ -94,32 +97,60 @@ export type AdmitMemberOptions = {
   delegationCredentialId?: PublicKey;
 };
 
+export type DataSpaceManagerParams = {
+  spaceManager: SpaceManager;
+  metadataStore: MetadataStore;
+  keyring: Keyring;
+  signingContext: SigningContext;
+  feedStore: FeedStore<FeedMessage>;
+  echoHost: EchoHost;
+  invitationsManager: InvitationsManager;
+  edgeConnection?: EdgeConnection;
+  meshReplicator?: MeshEchoReplicator;
+  echoEdgeReplicator?: EchoEdgeReplicator;
+  runtimeParams?: DataSpaceManagerRuntimeParams;
+};
+
 export type DataSpaceManagerRuntimeParams = {
   spaceMemberPresenceAnnounceInterval?: number;
   spaceMemberPresenceOfflineTimeout?: number;
 };
 
 @trackLeaks('open', 'close')
-export class DataSpaceManager {
-  private readonly _ctx = new Context();
-
+export class DataSpaceManager extends Resource {
   public readonly updated = new Event();
 
   private readonly _spaces = new ComplexMap<PublicKey, DataSpace>(PublicKey.hash);
 
-  private _isOpen = false;
   private readonly _instanceId = PublicKey.random().toHex();
 
-  constructor(
-    private readonly _spaceManager: SpaceManager,
-    private readonly _metadataStore: MetadataStore,
-    private readonly _keyring: Keyring,
-    private readonly _signingContext: SigningContext,
-    private readonly _feedStore: FeedStore<FeedMessage>,
-    private readonly _echoHost: EchoHost,
-    private readonly _invitationsManager: InvitationsManager,
-    private readonly _params?: DataSpaceManagerRuntimeParams,
-  ) {
+  private readonly _spaceManager: SpaceManager;
+  private readonly _metadataStore: MetadataStore;
+  private readonly _keyring: Keyring;
+  private readonly _signingContext: SigningContext;
+  private readonly _feedStore: FeedStore<FeedMessage>;
+  private readonly _echoHost: EchoHost;
+  private readonly _invitationsManager: InvitationsManager;
+  private readonly _edgeConnection?: EdgeConnection = undefined;
+  private readonly _meshReplicator?: MeshEchoReplicator = undefined;
+  private readonly _echoEdgeReplicator?: EchoEdgeReplicator = undefined;
+  private readonly _runtimeParams?: DataSpaceManagerRuntimeParams = undefined;
+
+  constructor(params: DataSpaceManagerParams) {
+    super();
+
+    this._spaceManager = params.spaceManager;
+    this._metadataStore = params.metadataStore;
+    this._keyring = params.keyring;
+    this._signingContext = params.signingContext;
+    this._feedStore = params.feedStore;
+    this._echoHost = params.echoHost;
+    this._meshReplicator = params.meshReplicator;
+    this._invitationsManager = params.invitationsManager;
+    this._edgeConnection = params.edgeConnection;
+    this._echoEdgeReplicator = params.echoEdgeReplicator;
+    this._runtimeParams = params.runtimeParams;
+
     trace.diagnostic({
       id: 'spaces',
       name: 'Spaces',
@@ -152,7 +183,7 @@ export class DataSpaceManager {
   }
 
   @synchronized
-  async open() {
+  protected override async _open() {
     log('open');
     log.trace('dxos.echo.data-space-manager.open', Trace.begin({ id: this._instanceId }));
     log('metadata loaded', { spaces: this._metadataStore.spaces.length });
@@ -166,17 +197,14 @@ export class DataSpaceManager {
       }
     });
 
-    this._isOpen = true;
     this.updated.emit();
 
     log.trace('dxos.echo.data-space-manager.open', Trace.end({ id: this._instanceId }));
   }
 
   @synchronized
-  async close() {
+  protected override async _close() {
     log('close');
-    this._isOpen = false;
-    await this._ctx.dispose();
     for (const space of this._spaces.values()) {
       await space.close();
     }
@@ -188,7 +216,7 @@ export class DataSpaceManager {
    */
   @synchronized
   async createSpace() {
-    invariant(this._isOpen, 'Not open.');
+    invariant(this._lifecycleState === LifecycleState.OPEN, 'Not open.');
     const spaceKey = await this._keyring.createKey();
     const controlFeedKey = await this._keyring.createKey();
     const dataFeedKey = await this._keyring.createKey();
@@ -278,7 +306,7 @@ export class DataSpaceManager {
   @synchronized
   async acceptSpace(opts: AcceptSpaceOptions): Promise<DataSpace> {
     log('accept space', { opts });
-    invariant(this._isOpen, 'Not open.');
+    invariant(this._lifecycleState === LifecycleState.OPEN, 'Not open.');
     invariant(!this._spaces.has(opts.spaceKey), 'Space already exists.');
 
     const metadata: SpaceMetadata = {
@@ -360,8 +388,8 @@ export class DataSpaceManager {
       localPeerId: this._signingContext.deviceKey,
     });
     const presence = new Presence({
-      announceInterval: this._params?.spaceMemberPresenceAnnounceInterval ?? PRESENCE_ANNOUNCE_INTERVAL,
-      offlineTimeout: this._params?.spaceMemberPresenceOfflineTimeout ?? PRESENCE_OFFLINE_TIMEOUT,
+      announceInterval: this._runtimeParams?.spaceMemberPresenceAnnounceInterval ?? PRESENCE_ANNOUNCE_INTERVAL,
+      offlineTimeout: this._runtimeParams?.spaceMemberPresenceOfflineTimeout ?? PRESENCE_OFFLINE_TIMEOUT,
       identityKey: this._signingContext.identityKey,
       gossip,
     });
@@ -394,11 +422,7 @@ export class DataSpaceManager {
               gossip.createExtension({ remotePeerId: session.remotePeerId }),
             );
             session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
-            await this._echoHost.authorizeDevice(space.key, session.remotePeerId);
-            if (!session.isOpen) {
-              return;
-            }
-            session.addExtension('dxos.mesh.teleport.automerge', this._echoHost.createReplicationExtension());
+            await this._connectEchoMeshReplicator(space, session);
           } catch (err: any) {
             log.warn('error on authorized connection', { err });
             await session.close(err);
@@ -435,8 +459,8 @@ export class DataSpaceManager {
           log('before space ready', { space: space.key });
         },
         afterReady: async () => {
-          log('after space ready', { space: space.key, open: this._isOpen });
-          if (this._isOpen) {
+          log('after space ready', { space: space.key, open: this._lifecycleState === LifecycleState.OPEN });
+          if (this._lifecycleState === LifecycleState.OPEN) {
             await this._createDelegatedInvitations(dataSpace, [...space.spaceState.invitations.entries()]);
             this._handleMemberRoleChanges(presence, space.protocol, [...space.spaceState.members.values()]);
             this.updated.emit();
@@ -447,6 +471,13 @@ export class DataSpaceManager {
         },
       },
       cache: metadata.cache,
+      edgeConnection: this._edgeConnection,
+    });
+    dataSpace.postOpen.append(async () => {
+      await this._echoEdgeReplicator?.connectToSpace(dataSpace.id);
+    });
+    dataSpace.preClose.append(async () => {
+      await this._echoEdgeReplicator?.disconnectFromSpace(dataSpace.id);
     });
 
     presence.newPeer.on((peerState) => {
@@ -463,6 +494,19 @@ export class DataSpaceManager {
     return dataSpace;
   }
 
+  private async _connectEchoMeshReplicator(space: Space, session: Teleport) {
+    const replicator = this._meshReplicator;
+    if (!replicator) {
+      log.warn('p2p automerge replication disabled', { space: space.key });
+      return;
+    }
+    await replicator.authorizeDevice(space.key, session.remotePeerId);
+    // session ended during device authorization
+    if (session.isOpen) {
+      session.addExtension('dxos.mesh.teleport.automerge', replicator.createExtension());
+    }
+  }
+
   private _handleMemberRoleChanges(presence: Presence, spaceProtocol: SpaceProtocol, memberInfo: MemberInfo[]): void {
     let closedSessions = 0;
     for (const member of memberInfo) {

package/src/packlets/spaces/data-space.ts

@@ -10,7 +10,8 @@ import { timed, warnAfterTimeout } from '@dxos/debug';
 import { type EchoHost, type DatabaseRoot } from '@dxos/echo-db';
 import { createMappedFeedWriter, type MetadataStore, type Space } from '@dxos/echo-pipeline';
 import { SpaceDocVersion } from '@dxos/echo-protocol';
-import { type FeedStore } from '@dxos/feed-store';
+import type { EdgeConnection } from '@dxos/edge-client';
+import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { failedInvariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -34,10 +35,11 @@ import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gos
 import { type Gossip, type Presence } from '@dxos/teleport-extension-gossip';
 import { Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
-import { ComplexSet } from '@dxos/util';
+import { CallbackCollection, ComplexSet, type AsyncCallback } from '@dxos/util';
 
 import { AutomergeSpaceState } from './automerge-space-state';
 import { type SigningContext } from './data-space-manager';
+import { EdgeFeedReplicator } from './edge-feed-replicator';
 import { runEpochMigration } from './epoch-migrations';
 import { NotarizationPlugin } from './notarization-plugin';
 import { TrustedKeySetAuthVerifier } from '../identity';
@@ -71,6 +73,7 @@ export type DataSpaceParams = {
   signingContext: SigningContext;
   callbacks?: DataSpaceCallbacks;
   cache?: SpaceCache;
+  edgeConnection?: EdgeConnection;
 };
 
 export type CreateEpochOptions = {
@@ -95,6 +98,7 @@ export class DataSpace {
   private readonly _callbacks: DataSpaceCallbacks;
   private readonly _cache?: SpaceCache = undefined;
   private readonly _echoHost: EchoHost;
+  private readonly _edgeFeedReplicator?: EdgeFeedReplicator = undefined;
 
   // TODO(dmaretskyi): Move into Space?
   private readonly _automergeSpaceState = new AutomergeSpaceState((rootUrl) => this._onNewAutomergeRoot(rootUrl));
@@ -113,6 +117,9 @@ export class DataSpace {
   public readonly authVerifier: TrustedKeySetAuthVerifier;
   public readonly stateUpdate = new Event();
 
+  public readonly postOpen = new CallbackCollection<AsyncCallback<void>>();
+  public readonly preClose = new CallbackCollection<AsyncCallback<void>>();
+
   public metrics: SpaceProto.Metrics = {};
 
   constructor(params: DataSpaceParams) {
@@ -142,6 +149,10 @@ export class DataSpace {
 
     this._cache = params.cache;
 
+    if (params.edgeConnection) {
+      this._edgeFeedReplicator = new EdgeFeedReplicator({ messenger: params.edgeConnection, spaceId: this.id });
+    }
+
     this._state = params.initialState;
     log('new state', { state: SpaceState[this._state] });
   }
@@ -212,12 +223,22 @@ export class DataSpace {
     await this._inner.spaceState.addCredentialProcessor(this._notarizationPlugin);
     await this._automergeSpaceState.open();
     await this._inner.spaceState.addCredentialProcessor(this._automergeSpaceState);
+
+    if (this._edgeFeedReplicator) {
+      this.inner.protocol.feedAdded.append(this._onFeedAdded);
+    }
+
     await this._inner.open(new Context());
+
+    await this._edgeFeedReplicator?.open();
+
     this._state = SpaceState.SPACE_CONTROL_ONLY;
     log('new state', { state: SpaceState[this._state] });
     this.stateUpdate.emit();
     this.metrics = {};
     this.metrics.open = new Date();
+
+    await this.postOpen.callSerial();
   }
 
   @synchronized
@@ -227,11 +248,20 @@ export class DataSpace {
 
   private async _close() {
     await this._callbacks.beforeClose?.();
+
+    await this.preClose.callSerial();
+
     this._state = SpaceState.SPACE_CLOSED;
     log('new state', { state: SpaceState[this._state] });
     await this._ctx.dispose();
     this._ctx = new Context();
 
+    if (this._edgeFeedReplicator) {
+      this.inner.protocol.feedAdded.remove(this._onFeedAdded);
+    }
+
+    await this._edgeFeedReplicator?.close();
+
     await this.authVerifier.close();
 
     await this._inner.close();
@@ -513,6 +543,10 @@ export class DataSpace {
     log('new state', { state: SpaceState[this._state] });
     this.stateUpdate.emit();
   }
+
+  private _onFeedAdded = async (feed: FeedWrapper<any>) => {
+    await this._edgeFeedReplicator!.addFeed(feed);
+  };
 }
 
 type CreateEpochResult = {

package/src/packlets/spaces/edge-feed-replicator.ts

@@ -0,0 +1,249 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { decode as decodeCbor, encode as encodeCbor } from 'cbor-x';
+
+import { Event, Mutex, scheduleMicroTask } from '@dxos/async';
+import { Resource, type Context } from '@dxos/context';
+import { type EdgeConnection } from '@dxos/edge-client';
+import { type FeedWrapper } from '@dxos/feed-store';
+import { invariant } from '@dxos/invariant';
+import { PublicKey, type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { EdgeService } from '@dxos/protocols';
+import { buf } from '@dxos/protocols/buf';
+import { MessageSchema as RouterMessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import type { FeedBlock, ProtocolMessage } from '@dxos/protocols/feed-replication';
+import { ComplexMap, arrayToBuffer, bufferToArray, defaultMap, rangeFromTo } from '@dxos/util';
+
+export type EdgeFeedReplicatorParams = {
+  messenger: EdgeConnection;
+  spaceId: SpaceId;
+};
+
+export class EdgeFeedReplicator extends Resource {
+  private readonly _messenger: EdgeConnection;
+  private readonly _spaceId: SpaceId;
+  private readonly _feeds = new ComplexMap<PublicKey, FeedWrapper<any>>(PublicKey.hash);
+
+  private _connectionCtx?: Context = undefined;
+  private _connected = false;
+  /**
+   * Feed length at service.
+   */
+  private _remoteLength = new ComplexMap<PublicKey, number>(PublicKey.hash);
+
+  /**
+   * Protects against concurrent pushes so that remote length is updated consistently.
+   */
+  private _pushMutex = new ComplexMap<PublicKey, Mutex>(PublicKey.hash);
+
+  constructor({ messenger, spaceId }: EdgeFeedReplicatorParams) {
+    super();
+    this._messenger = messenger;
+    this._spaceId = spaceId;
+  }
+
+  protected override async _open(): Promise<void> {
+    // TODO: handle reconnects
+    this._ctx.onDispose(
+      this._messenger.addListener(async (message) => {
+        if (!message.serviceId) {
+          return;
+        }
+        const [service, ...rest] = message.serviceId.split(':');
+        if (service !== 'hypercore-replicator') {
+          return;
+        }
+
+        const [spaceId] = rest;
+        if (spaceId !== this._spaceId) {
+          log('spaceID mismatch', { spaceId, _spaceId: this._spaceId });
+          return;
+        }
+
+        const payload = decodeCbor(message.payload!.value) as ProtocolMessage;
+        log.info('recv', { from: message.source, payload });
+        this._onMessage(payload);
+      }),
+    );
+
+    this._connected = true;
+    this._connectionCtx = this._ctx.derive();
+    for (const feed of this._feeds.values()) {
+      await this._replicateFeed(feed);
+    }
+  }
+
+  protected override async _close(): Promise<void> {
+    this._connected = false;
+
+    this._connected = false;
+    await this._connectionCtx?.dispose();
+    this._connectionCtx = undefined;
+    this._remoteLength.clear();
+  }
+
+  async addFeed(feed: FeedWrapper<any>) {
+    log.info('addFeed', { key: feed.key });
+    this._feeds.set(feed.key, feed);
+
+    if (this._connected) {
+      await this._replicateFeed(feed);
+    }
+  }
+
+  private _getPushMutex(key: PublicKey) {
+    return defaultMap(this._pushMutex, key, () => new Mutex());
+  }
+
+  private async _replicateFeed(feed: FeedWrapper<any>) {
+    invariant(this._connectionCtx);
+
+    await this._sendMessage({
+      type: 'get-metadata',
+      feedKey: feed.key.toHex(),
+    });
+
+    Event.wrap(feed.core as any, 'append').on(this._connectionCtx, async () => {
+      await this._pushBlocksIfNeeded(feed);
+    });
+  }
+
+  private async _sendMessage(message: ProtocolMessage) {
+    log.info('sending message', { message });
+
+    invariant(message.feedKey);
+    const payloadValue = bufferToArray(encodeCbor(message));
+
+    await this._messenger.send(
+      buf.create(RouterMessageSchema, {
+        source: {
+          identityKey: this._messenger.identityKey.toHex(),
+          peerKey: this._messenger.deviceKey.toHex(),
+        },
+        serviceId: `${EdgeService.FEED_REPLICATOR}:${this._spaceId}`,
+        payload: { value: payloadValue },
+      }),
+    );
+  }
+
+  private _onMessage(message: ProtocolMessage) {
+    log.info('received message', { message });
+
+    scheduleMicroTask(this._ctx, async () => {
+      switch (message.type) {
+        case 'metadata': {
+          const feedKey = PublicKey.fromHex(message.feedKey);
+          const feed = this._feeds.get(feedKey);
+          if (!feed) {
+            log.warn('Feed not found', { feedKey });
+            return;
+          }
+
+          using _guard = await this._getPushMutex(feed.key).acquire();
+
+          this._remoteLength.set(feedKey, message.length);
+
+          if (message.length > feed.length) {
+            await this._sendMessage({
+              type: 'request',
+              feedKey: feedKey.toHex(),
+              range: { from: feed.length, to: message.length },
+            });
+          } else if (message.length < feed.length) {
+            await this._pushBlocks(feed, message.length, feed.length);
+          }
+
+          break;
+        }
+
+        case 'data': {
+          const feedKey = PublicKey.fromHex(message.feedKey);
+          const feed = this._feeds.get(feedKey);
+          if (!feed) {
+            log.warn('Feed not found', { feedKey });
+            return;
+          }
+
+          await this._integrateBlocks(feed, message.blocks);
+          break;
+        }
+
+        default: {
+          log.warn('Unknown message', { ...message });
+        }
+      }
+    });
+  }
+
+  private async _pushBlocks(feed: FeedWrapper<any>, from: number, to: number) {
+    log.info('pushing blocks', { feed: feed.key.toHex(), from, to });
+
+    const blocks: FeedBlock[] = await Promise.all(
+      rangeFromTo(from, to).map(async (index) => {
+        const data = await feed.get(index, { valueEncoding: 'binary' });
+        invariant(data instanceof Uint8Array);
+        const proof = await feed.proof(index);
+
+        return {
+          index,
+          data,
+          nodes: proof.nodes,
+          signature: proof.signature,
+        } satisfies FeedBlock;
+      }),
+    );
+
+    await this._sendMessage({
+      type: 'data',
+      feedKey: feed.key.toHex(),
+      blocks,
+    });
+    this._remoteLength.set(feed.key, to);
+  }
+
+  private async _integrateBlocks(feed: FeedWrapper<any>, blocks: FeedBlock[]) {
+    log.info('integrating blocks', { feed: feed.key.toHex(), blocks: blocks.length });
+
+    for (const block of blocks) {
+      if (feed.has(block.index)) {
+        continue;
+      }
+      const blockBuffer = bufferizeBlock(block);
+
+      await feed.putBuffer(
+        block.index,
+        blockBuffer.data,
+        { nodes: blockBuffer.nodes, signature: blockBuffer.signature },
+        null,
+      );
+    }
+  }
+
+  private async _pushBlocksIfNeeded(feed: FeedWrapper<any>) {
+    using _guard = await this._getPushMutex(feed.key).acquire();
+
+    if (!this._remoteLength.has(feed.key)) {
+      return;
+    }
+
+    const remoteLength = this._remoteLength.get(feed.key)!;
+    if (remoteLength < feed.length) {
+      await this._pushBlocks(feed, remoteLength, feed.length);
+    }
+  }
+}
+
+// hypercore requires buffers
+const bufferizeBlock = (block: FeedBlock) => ({
+  index: block.index,
+  data: arrayToBuffer(block.data),
+  nodes: block.nodes.map((node) => ({
+    index: node.index,
+    hash: arrayToBuffer(node.hash),
+    size: node.size,
+  })),
+  signature: arrayToBuffer(block.signature),
+});

package/src/packlets/spaces/index.ts

@@ -5,3 +5,4 @@
 export * from './data-space-manager';
 export * from './data-space';
 export * from './spaces-service';
+export * from './edge-feed-replicator';

package/src/packlets/testing/invitation-utils.ts

@@ -207,7 +207,7 @@ export const performInvitation = ({
   return [hostComplete.wait(), guestComplete.wait()];
 };
 
-const createInvitation = async (
+export const createInvitation = async (
   host: ServiceContext | InvitationHost,
   options?: Partial<Invitation>,
 ): Promise<CancellableInvitation> => {
@@ -226,7 +226,7 @@ const createInvitation = async (
   return host.share(options);
 };
 
-const acceptInvitation = (
+export const acceptInvitation = (
   guest: ServiceContext | InvitationGuest,
   invitation: Invitation,
   guestDeviceProfile?: DeviceProfileDocument,

package/src/packlets/testing/test-builder.ts

@@ -7,7 +7,7 @@ import { Context } from '@dxos/context';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import { EchoHost } from '@dxos/echo-db';
-import { MetadataStore, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
+import { MetadataStore, SnapshotStore, SpaceManager, valueEncoding, MeshEchoReplicator } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { type LevelDB } from '@dxos/kv-store';
@@ -51,7 +51,7 @@ export const createServiceContext = async ({
   const level = createTestLevel();
   await level.open();
 
-  return new ServiceContext(storage, level, networkManager, signalManager, {
+  return new ServiceContext(storage, level, networkManager, signalManager, undefined, {
     invitationConnectionDefaultParams: { controlHeartbeatInterval: 200 },
     ...runtimeParams,
   });
@@ -107,6 +107,7 @@ export type TestPeerProps = {
   signingContext?: SigningContext;
   blobStore?: BlobStore;
   echoHost?: EchoHost;
+  meshEchoReplicator?: MeshEchoReplicator;
   invitationsManager?: InvitationsManager;
 };
 
@@ -183,17 +184,24 @@ export class TestPeer {
     return (this._props.echoHost ??= new EchoHost({ kv: this.level }));
   }
 
+  get meshEchoReplicator() {
+    return (this._props.meshEchoReplicator ??= new MeshEchoReplicator());
+  }
+
   get dataSpaceManager(): DataSpaceManager {
-    return (this._props.dataSpaceManager ??= new DataSpaceManager(
-      this.spaceManager,
-      this.metadataStore,
-      this.keyring,
-      this.identity,
-      this.feedStore,
-      this.echoHost,
-      this.invitationsManager,
-      this._opts.dataSpaceParams,
-    ));
+    return (this._props.dataSpaceManager ??= new DataSpaceManager({
+      spaceManager: this.spaceManager,
+      metadataStore: this.metadataStore,
+      keyring: this.keyring,
+      signingContext: this.identity,
+      feedStore: this.feedStore,
+      echoHost: this.echoHost,
+      invitationsManager: this.invitationsManager,
+      edgeConnection: undefined,
+      meshReplicator: this.meshEchoReplicator,
+      echoEdgeReplicator: undefined,
+      runtimeParams: this._opts.dataSpaceParams,
+    }));
   }
 
   get invitationsManager() {