@dxos/echo-pipeline 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/db-host/stub.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type {
+  DeleteFromQueueRequest,
+  InsertIntoQueueRequest,
+  QueryQueueRequest,
+  QueueQueryResult,
+  QueueService,
+  SyncQueueRequest,
+} from '@dxos/protocols/proto/dxos/client/services';
+
+/**
+ * Stub implementation for when Edge is not available.
+ */
+export class QueueServiceStub implements QueueService {
+  queryQueue(request: QueryQueueRequest): Promise<QueueQueryResult> {
+    throw new Error('Not available.');
+  }
+
+  insertIntoQueue(request: InsertIntoQueueRequest): Promise<void> {
+    throw new Error('Not available.');
+  }
+
+  deleteFromQueue(request: DeleteFromQueueRequest): Promise<void> {
+    throw new Error('Not available.');
+  }
+
+  syncQueue(request: SyncQueueRequest): Promise<void> {
+    throw new Error('Not available.');
+  }
+}

package/src/edge/echo-edge-replicator.test.ts

@@ -7,6 +7,7 @@ import { getRandomPort } from 'get-port-please';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Event } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { EdgeClient, type EdgeHttpClient, MessageSchema, createEphemeralEdgeIdentity } from '@dxos/edge-client';
 import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
 import { PublicKey, SpaceId } from '@dxos/keys';
@@ -16,8 +17,7 @@ import { createBuf } from '@dxos/protocols/buf';
 import type { Peer } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { openAndClose } from '@dxos/test-utils';
 
-import type { EchoReplicatorContext, ReplicatorConnection } from '../automerge';
-
+import type { AutomergeReplicatorConnection, AutomergeReplicatorContext } from '../automerge';
 import { EchoEdgeReplicator } from './echo-edge-replicator';
 
 describe('EchoEdgeReplicator', () => {
@@ -28,7 +28,7 @@ describe('EchoEdgeReplicator', () => {
 
     const { context, connectionOpen } = createMockContext();
     const replicator = await connectReplicator(client, context);
-    await replicator.connectToSpace(spaceId);
+    await replicator.connectToSpace(Context.default(), spaceId);
 
     client.setIdentity(await createEphemeralEdgeIdentity());
     await connectionOpen.waitForCount(1);
@@ -55,7 +55,7 @@ describe('EchoEdgeReplicator', () => {
         documentSpaceId: { [documentId]: spaceId },
       });
       const replicator = await connectReplicator(client, context);
-      await replicator.connectToSpace(spaceId);
+      await replicator.connectToSpace(Context.default(), spaceId);
 
       await expect.poll(() => openConnections.length === 1).toBeTruthy();
       expect(openConnections[0].shouldAdvertise({ documentId })).toBeTruthy();
@@ -69,7 +69,7 @@ describe('EchoEdgeReplicator', () => {
       const remoteCollections: { [peerId: string]: { [documentId: string]: boolean } } = {};
       const { context, openConnections } = createMockContext({ remoteCollections });
       const replicator = await connectReplicator(client, context);
-      await replicator.connectToSpace(spaceId);
+      await replicator.connectToSpace(Context.default(), spaceId);
 
       await expect.poll(() => openConnections.length === 1).toBeTruthy();
       const connection = openConnections[0];
@@ -79,10 +79,10 @@ describe('EchoEdgeReplicator', () => {
     });
   });
 
-  const connectReplicator = async (client: EdgeClient, context: EchoReplicatorContext) => {
+  const connectReplicator = async (client: EdgeClient, context: AutomergeReplicatorContext) => {
     // EdgeHttpClient functionality is not tested here.
     const replicator = new EchoEdgeReplicator({ edgeConnection: client, edgeHttpClient: {} as EdgeHttpClient });
-    await replicator.connect(context);
+    await replicator.connect(Context.default(), context);
     onTestFinished(() => replicator.disconnect());
     return replicator;
   };
@@ -101,7 +101,7 @@ const createMockContext = (args?: {
   documentSpaceId?: { [documentId: string]: SpaceId };
 }) => {
   const connectionOpen = new Event();
-  const openConnections: ReplicatorConnection[] = [];
+  const openConnections: AutomergeReplicatorConnection[] = [];
   return {
     context: {
       getContainingSpaceIdForDocument: async (documentId) => args?.documentSpaceId?.[documentId] ?? null,
@@ -121,7 +121,7 @@ const createMockContext = (args?: {
       },
 
       peerId: PublicKey.random().toHex(),
-    } satisfies EchoReplicatorContext,
+    } satisfies AutomergeReplicatorContext,
 
     openConnections,
     connectionOpen,

package/src/edge/echo-edge-replicator.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Automerge from '@automerge/automerge';
+import * as A from '@automerge/automerge';
 import { type DocumentId, type Heads, cbor } from '@automerge/automerge-repo';
 
 import { Mutex, scheduleMicroTask, scheduleTask } from '@dxos/async';
@@ -17,6 +17,7 @@ import {
   type AutomergeProtocolMessage,
   DocumentCodec,
   EdgeService,
+  type ErrorProtocolMessage,
   type ExportBundleRequest,
   type ImportBundleRequest,
   type PeerId,
@@ -26,17 +27,17 @@ import {
   type Message as RouterMessage,
   MessageSchema as RouterMessageSchema,
 } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-import { bufferToArray, setDeep } from '@dxos/util';
+import { trace } from '@dxos/tracing';
+import { bufferToArray, compositeKey, setDeep } from '@dxos/util';
 
 import {
-  type EchoReplicator,
-  type EchoReplicatorContext,
-  type ReplicatorConnection,
-  type ShouldAdvertiseParams,
-  type ShouldSyncCollectionParams,
+  type AutomergeReplicatorConnection,
+  type AutomergeReplicatorContext,
+  type EdgeAutomergeReplicator,
+  type ShouldAdvertiseProps,
+  type ShouldSyncCollectionProps,
   getSpaceIdFromCollectionId,
 } from '../automerge';
-
 import { InflightRequestLimiter } from './inflight-request-limiter';
 
 /**
@@ -46,33 +47,34 @@ const INITIAL_RESTART_DELAY = 500;
 const RESTART_DELAY_JITTER = 250;
 const MAX_RESTART_DELAY = 5000;
 
-export type EchoEdgeReplicatorParams = {
+export type EchoEdgeReplicatorProps = {
   edgeConnection: EdgeConnection;
   edgeHttpClient: EdgeHttpClient;
   disableSharePolicy?: boolean;
 };
 
-export class EchoEdgeReplicator implements EchoReplicator {
+@trace.resource()
+export class EchoEdgeReplicator implements EdgeAutomergeReplicator {
   private readonly _edgeConnection: EdgeConnection;
   private readonly _edgeHttpClient: EdgeHttpClient;
   private readonly _mutex = new Mutex();
 
   private _ctx?: Context = undefined;
-  private _context: EchoReplicatorContext | null = null;
+  private _context: AutomergeReplicatorContext | null = null;
   private _connectedSpaces = new Set<SpaceId>();
   private _connections = new Map<SpaceId, EdgeReplicatorConnection>();
   private _sharePolicyEnabled = true;
 
-  constructor({ edgeConnection, edgeHttpClient, disableSharePolicy }: EchoEdgeReplicatorParams) {
+  constructor({ edgeConnection, edgeHttpClient, disableSharePolicy }: EchoEdgeReplicatorProps) {
     this._edgeConnection = edgeConnection;
     this._edgeHttpClient = edgeHttpClient;
     this._sharePolicyEnabled = !disableSharePolicy;
   }
 
-  async connect(context: EchoReplicatorContext): Promise<void> {
+  async connect(ctx: Context, context: AutomergeReplicatorContext): Promise<void> {
     log('connecting...', { peerId: context.peerId, connectedSpaces: this._connectedSpaces.size });
     this._context = context;
-    this._ctx = Context.default();
+    this._ctx = ctx.derive();
     this._ctx.onDispose(
       this._edgeConnection.onReconnected(() => {
         this._ctx && scheduleMicroTask(this._ctx, () => this._handleReconnect());
@@ -91,7 +93,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
 
     if (this._context !== null) {
       for (const spaceId of spaces) {
-        await this._openConnection(spaceId);
+        await this._openConnection(this._ctx!, spaceId);
       }
     }
   }
@@ -106,7 +108,9 @@ export class EchoEdgeReplicator implements EchoReplicator {
     this._connections.clear();
   }
 
-  async connectToSpace(spaceId: SpaceId): Promise<void> {
+  @trace.span({ showInBrowserTimeline: true, op: 'replication' })
+  async connectToSpace(ctx: Context, spaceId: SpaceId): Promise<void> {
+    log('connectToSpace', { spaceId });
     using _guard = await this._mutex.acquire();
 
     if (this._connectedSpaces.has(spaceId)) {
@@ -114,9 +118,8 @@ export class EchoEdgeReplicator implements EchoReplicator {
     }
     this._connectedSpaces.add(spaceId);
 
-    // Check if AM-repo requested that we connect to remote peers.
     if (this._context !== null) {
-      await this._openConnection(spaceId);
+      await this._openConnection(ctx, spaceId);
     }
   }
 
@@ -132,7 +135,8 @@ export class EchoEdgeReplicator implements EchoReplicator {
     }
   }
 
-  private async _openConnection(spaceId: SpaceId, reconnects: number = 0): Promise<void> {
+  @trace.span({ showInBrowserTimeline: true, op: 'replication' })
+  private async _openConnection(ctx: Context, spaceId: SpaceId, reconnects: number = 0): Promise<void> {
     invariant(this._context);
     invariant(!this._connections.has(spaceId));
 
@@ -164,21 +168,21 @@ export class EchoEdgeReplicator implements EchoReplicator {
 
         restartScheduled = true;
         scheduleTask(
-          this._ctx,
+          this._ctx!,
           async () => {
             using _guard = await this._mutex.acquire();
             if (this._connections.get(spaceId) !== connection) {
               return;
             }
 
-            const ctx = this._ctx;
-            await connection.close(); // Will call onRemoteDisconnected
+            const replicatorCtx = this._ctx;
+            await connection.close();
             this._connections.delete(spaceId);
-            if (ctx?.disposed) {
+            if (replicatorCtx?.disposed) {
               return;
             }
             log.trace('dxos.echo.edge.replicator.restart', { spaceId, reconnects, restartDelay });
-            await this._openConnection(spaceId, reconnects + 1);
+            await this._openConnection(replicatorCtx!, spaceId, reconnects + 1);
           },
           restartDelay,
         );
@@ -186,15 +190,15 @@ export class EchoEdgeReplicator implements EchoReplicator {
     });
     this._connections.set(spaceId, connection);
 
-    await connection.open();
+    await connection.open(ctx);
   }
 }
 
-type EdgeReplicatorConnectionsParams = {
+type EdgeReplicatorConnectionsProps = {
   edgeConnection: EdgeConnection;
   edgeHttpClient: EdgeHttpClient;
   spaceId: SpaceId;
-  context: EchoReplicatorContext;
+  context: AutomergeReplicatorContext;
   sharedPolicyEnabled: boolean;
   onRemoteConnected: () => Promise<void>;
   onRemoteDisconnected: () => Promise<void>;
@@ -204,14 +208,14 @@ type EdgeReplicatorConnectionsParams = {
 const MAX_INFLIGHT_REQUESTS = 5;
 const MAX_RATE_LIMIT_WAIT_TIME_MS = 3000;
 
-class EdgeReplicatorConnection extends Resource implements ReplicatorConnection {
+class EdgeReplicatorConnection extends Resource implements AutomergeReplicatorConnection {
   private readonly _connectionId = randomUUID();
   private readonly _edgeConnection: EdgeConnection;
   private readonly _edgeHttpClient: EdgeHttpClient;
   private readonly _remotePeerId: string | null = null;
   private readonly _targetServiceId: string;
   private readonly _spaceId: SpaceId;
-  private readonly _context: EchoReplicatorContext;
+  private readonly _context: AutomergeReplicatorContext;
   private readonly _sharedPolicyEnabled: boolean;
   private readonly _onRemoteConnected: () => Promise<void>;
   private readonly _onRemoteDisconnected: () => Promise<void>;
@@ -237,7 +241,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     onRemoteConnected,
     onRemoteDisconnected,
     onRestartRequested,
-  }: EdgeReplicatorConnectionsParams) {
+  }: EdgeReplicatorConnectionsProps) {
     super();
     this._edgeConnection = edgeConnection;
     this._edgeHttpClient = edgeHttpClient;
@@ -247,8 +251,9 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     // This way automerge-repo will have separate sync states for every connection.
     // This is important because the previous connection might have had some messages that failed to deliver
     // abd if we don't clear the sync-state, automerge will not attempt to deliver them again.
-    this._remotePeerId = `${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}-${this._connectionId}`;
-    this._targetServiceId = `${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}`;
+    this._targetServiceId = compositeKey(EdgeService.AUTOMERGE_REPLICATOR, spaceId);
+    // TODO(wittjosiah): Use compositeKey.
+    this._remotePeerId = `${this._targetServiceId}-${this._connectionId}`;
     this._sharedPolicyEnabled = sharedPolicyEnabled;
     this._onRemoteConnected = onRemoteConnected;
     this._onRemoteDisconnected = onRemoteDisconnected;
@@ -264,7 +269,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
       write: async (message: AutomergeProtocolMessage, controller) => {
         await this._requestLimiter.rateLimit(message);
 
-        await this._sendMessage(message);
+        await this._sendMessage(this._ctx, message);
       },
     });
   }
@@ -297,7 +302,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     await this._onRemoteConnected();
   }
 
-  protected override async _close(): Promise<void> {
+  protected override async _close(ctx: Context): Promise<void> {
     log('closing...');
     this._readableStreamController.close();
 
@@ -311,7 +316,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return this._remotePeerId;
   }
 
-  async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(params: ShouldAdvertiseProps): Promise<boolean> {
     if (!this._sharedPolicyEnabled) {
       return true;
     }
@@ -336,7 +341,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return spaceId === this._spaceId;
   }
 
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(params: ShouldSyncCollectionProps): boolean {
     if (!this._sharedPolicyEnabled) {
       return true;
     }
@@ -365,7 +370,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return true;
   }
 
-  async pushBundle(bundle: { documentId: DocumentId; data: Uint8Array; heads: Heads }[]) {
+  async pushBundle(ctx: Context, bundle: { documentId: DocumentId; data: Uint8Array; heads: Heads }[]) {
     const request: ImportBundleRequest = {
       bundle: bundle.map(({ documentId, data, heads }) => ({
         documentId,
@@ -373,12 +378,12 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
         heads,
       })),
     };
-    await this._edgeHttpClient.importBundle(this._spaceId, request);
+    await this._edgeHttpClient.importBundle(ctx, this._spaceId, request);
   }
 
-  async pullBundle(docHeads: Record<DocumentId, Heads>): Promise<Record<DocumentId, Uint8Array>> {
+  async pullBundle(ctx: Context, docHeads: Record<DocumentId, Heads>): Promise<Record<DocumentId, Uint8Array>> {
     const request: ExportBundleRequest = { docHeads };
-    const response = await this._edgeHttpClient.exportBundle(this._spaceId, request);
+    const response = await this._edgeHttpClient.exportBundle(ctx, this._spaceId, request);
     return Object.fromEntries(response.bundle.map((doc) => [doc.documentId, DocumentCodec.decode(doc.mutation)]));
   }
 
@@ -387,6 +392,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     // AutomergeReplicator might return a Forbidden error if the credentials are not yet replicated.
     // We restart the connection with some delay to account for that.
     if (isErrorMessage(message)) {
+      log.verbose('stream error', { error: (message as ErrorProtocolMessage).message });
       this._onRestartRequested();
       return;
     }
@@ -396,7 +402,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     this._readableStreamController.enqueue(message);
   }
 
-  private async _sendMessage(message: AutomergeProtocolMessage): Promise<void> {
+  private async _sendMessage(ctx: Context, message: AutomergeProtocolMessage): Promise<void> {
     // Fix the peer id.
     (message as any).targetId = this._targetServiceId as PeerId;
 
@@ -413,6 +419,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
 
     try {
       await this._edgeConnection.send(
+        ctx,
         buf.create(RouterMessageSchema, {
           serviceId: this._targetServiceId,
           source: {
@@ -438,10 +445,11 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
 const isErrorMessage = (message: AutomergeProtocolMessage) => message.type === 'error';
 
 const getMessageInfo = (msg: AutomergeProtocolMessage) => {
-  const { have, heads, need, changes } = msg.type === 'sync' ? Automerge.decodeSyncMessage(msg.data) : {};
+  const { have, heads, need, changes } = msg.type === 'sync' ? A.decodeSyncMessage(msg.data) : {};
   return {
     type: msg.type,
     documentId: 'documentId' in msg ? msg.documentId : undefined,
+    collectionId: 'collectionId' in msg ? msg.collectionId : undefined,
     have,
     heads,
     need,

package/src/edge/echo-edge-subduction-replicator.test.ts

@@ -0,0 +1,158 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { cbor } from '@automerge/automerge-repo';
+import { getRandomPort } from 'get-port-please';
+import { describe, expect, onTestFinished, test } from 'vitest';
+
+import { Event } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { EdgeClient, type EdgeHttpClient, MessageSchema, createEphemeralEdgeIdentity } from '@dxos/edge-client';
+import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
+import { PublicKey, SpaceId } from '@dxos/keys';
+import { EdgeService } from '@dxos/protocols';
+import { createBuf } from '@dxos/protocols/buf';
+import type { Peer } from '@dxos/protocols/proto/dxos/edge/messenger';
+import { openAndClose } from '@dxos/test-utils';
+import { compositeKey } from '@dxos/util';
+
+import type { AutomergeReplicatorConnection, AutomergeReplicatorContext } from '../automerge';
+import { EchoEdgeSubductionReplicator } from './echo-edge-subduction-replicator';
+
+describe('EchoEdgeSubductionReplicator', () => {
+  test('opens a subduction connection when connectToSpace is called', async () => {
+    const { client } = await createClientServer();
+
+    const spaceId = SpaceId.random();
+    const { context, connectionOpen, openConnections } = createMockContext();
+    const replicator = await connectReplicator(client, context);
+
+    await replicator.connectToSpace(Context.default(), spaceId);
+    await connectionOpen.waitForCount(1);
+
+    expect(openConnections.length).toBe(1);
+
+    await replicator.disconnect();
+  });
+
+  test('reconnects', async () => {
+    const { client, server } = await createClientServer();
+
+    const spaceId = SpaceId.random();
+
+    const { context, connectionOpen } = createMockContext();
+    const replicator = await connectReplicator(client, context);
+    await replicator.connectToSpace(Context.default(), spaceId);
+
+    client.setIdentity(await createEphemeralEdgeIdentity());
+    await connectionOpen.waitForCount(1);
+
+    // Subduction-era restart: edge emits a `subduction-reconnect` frame on the same
+    // SUBDUCTION_REPLICATOR service id; the connection tears down and the replicator
+    // opens a fresh connection on the next mutex pass.
+    const reconnectFrame = createSubductionReconnectMessage(
+      { identityKey: client.identityKey, peerKey: client.peerKey },
+      spaceId,
+    );
+    await server.sendMessage(reconnectFrame);
+    await connectionOpen.waitForCount(1);
+
+    // Double restart to check for race conditions.
+    client.setIdentity(await createEphemeralEdgeIdentity());
+    await server.sendMessage(reconnectFrame);
+    await connectionOpen.waitForCount(1);
+
+    await replicator.disconnect();
+  });
+
+  describe('shouldAdvertise', () => {
+    test('true if space document belongs to connection space', async () => {
+      const { client } = await createClientServer();
+
+      const spaceId = SpaceId.random();
+      const documentId = PublicKey.random().toHex();
+      const { context, openConnections, connectionOpen } = createMockContext({
+        documentSpaceId: { [documentId]: spaceId },
+      });
+      const replicator = await connectReplicator(client, context);
+      await replicator.connectToSpace(Context.default(), spaceId);
+
+      await connectionOpen.waitForCount(1);
+      expect(openConnections.length).toBe(1);
+      expect(await openConnections[0].shouldAdvertise({ documentId })).toBeTruthy();
+    });
+
+    test('checks remote collection if space id can not be resolved', async () => {
+      const { client } = await createClientServer();
+
+      const spaceId = SpaceId.random();
+      const documentId = PublicKey.random().toHex();
+      const remoteCollections: { [peerId: string]: { [documentId: string]: boolean } } = {};
+      const { context, openConnections, connectionOpen } = createMockContext({ remoteCollections });
+      const replicator = await connectReplicator(client, context);
+      await replicator.connectToSpace(Context.default(), spaceId);
+
+      await connectionOpen.waitForCount(1);
+      const connection = openConnections[0];
+      expect(await connection.shouldAdvertise({ documentId })).toBeFalsy();
+      remoteCollections[connection.peerId] = { [documentId]: true };
+      expect(await connection.shouldAdvertise({ documentId })).toBeTruthy();
+    });
+  });
+
+  const connectReplicator = async (client: EdgeClient, context: AutomergeReplicatorContext) => {
+    // EdgeHttpClient functionality is not used by the subduction replicator.
+    const replicator = new EchoEdgeSubductionReplicator({
+      edgeConnection: client,
+      edgeHttpClient: {} as EdgeHttpClient,
+    });
+    await replicator.connect(Context.default(), context);
+    onTestFinished(() => replicator.disconnect());
+    return replicator;
+  };
+
+  const createClientServer = async () => {
+    const server = await createTestEdgeWsServer(await getRandomPort());
+    onTestFinished(server.cleanup);
+    const client = new EdgeClient(await createEphemeralEdgeIdentity(), { socketEndpoint: server.endpoint });
+    await openAndClose(client);
+    return { client, server };
+  };
+});
+
+const createMockContext = (args?: {
+  remoteCollections?: { [peerId: string]: { [documentId: string]: boolean } };
+  documentSpaceId?: { [documentId: string]: SpaceId };
+}) => {
+  const connectionOpen = new Event();
+  const openConnections: AutomergeReplicatorConnection[] = [];
+  const context: AutomergeReplicatorContext = {
+    getContainingSpaceIdForDocument: async (documentId) => args?.documentSpaceId?.[documentId] ?? null,
+    getContainingSpaceForDocument: async () => null,
+    isDocumentInRemoteCollection: async (params) =>
+      args?.remoteCollections?.[params.peerId]?.[params.documentId] ?? false,
+    onConnectionAuthScopeChanged: () => {},
+    onConnectionClosed: (connection) => {
+      const idx = openConnections.indexOf(connection);
+      if (idx >= 0) {
+        openConnections.splice(idx, 1);
+      }
+    },
+    onConnectionOpen: (connection) => {
+      openConnections.push(connection);
+      connectionOpen.emit();
+    },
+    peerId: PublicKey.random().toHex(),
+  };
+  return { context, openConnections, connectionOpen };
+};
+
+const createSubductionReconnectMessage = (target: Peer, spaceId: SpaceId) =>
+  createBuf(MessageSchema, {
+    target: [target],
+    serviceId: compositeKey(EdgeService.SUBDUCTION_REPLICATOR, spaceId),
+    payload: {
+      value: cbor.encode({ type: 'subduction-reconnect' }),
+    },
+  });