@dxos/network-manager 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/src/signal/swarm-messenger.ts

@@ -20,9 +20,9 @@ interface OfferRecord {
 }
 
 export type SwarmMessengerOptions = {
-  sendMessage: (params: Message) => Promise<void>;
-  onOffer: (message: OfferMessage) => Promise<Answer>;
-  onSignal: (message: SignalMessage) => Promise<void>;
+  sendMessage: (ctx: Context, params: Message) => Promise<void>;
+  onOffer: (ctx: Context, message: OfferMessage) => Promise<Answer>;
+  onSignal: (ctx: Context, message: SignalMessage) => Promise<void>;
   topic: PublicKey;
 };
 
@@ -32,11 +32,9 @@ const SwarmMessage = schema.getCodecForType('dxos.mesh.swarm.SwarmMessage');
  * Adds offer/answer and signal interfaces.
  */
 export class SwarmMessenger implements SignalMessenger {
-  private readonly _ctx = new Context();
-
-  private readonly _sendMessage: (msg: Message) => Promise<void>;
-  private readonly _onSignal: (message: SignalMessage) => Promise<void>;
-  private readonly _onOffer: (message: OfferMessage) => Promise<Answer>;
+  private readonly _sendMessage: SwarmMessengerOptions['sendMessage'];
+  private readonly _onSignal: SwarmMessengerOptions['onSignal'];
+  private readonly _onOffer: SwarmMessengerOptions['onOffer'];
   private readonly _topic: PublicKey;
 
   private readonly _offerRecords: ComplexMap<PublicKey, OfferRecord> = new ComplexMap((key) => key.toHex());
@@ -48,15 +46,18 @@ export class SwarmMessenger implements SignalMessenger {
     this._topic = topic;
   }
 
-  async receiveMessage({
-    author,
-    recipient,
-    payload,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    payload: Any;
-  }): Promise<void> {
+  async receiveMessage(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      payload,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      payload: Any;
+    },
+  ): Promise<void> {
     if (payload.type_url !== 'dxos.mesh.swarm.SwarmMessage') {
       // Ignore not swarm messages.
       return;
@@ -71,35 +72,35 @@ export class SwarmMessenger implements SignalMessenger {
     log('received', { from: author, to: recipient, msg: message });
 
     if (message.data?.offer) {
-      await this._handleOffer({ author, recipient, message });
+      await this._handleOffer(ctx, { author, recipient, message });
     } else if (message.data?.answer) {
       await this._resolveAnswers(message);
     } else if (message.data?.signal) {
-      await this._handleSignal({ author, recipient, message });
+      await this._handleSignal(ctx, { author, recipient, message });
     } else if (message.data?.signalBatch) {
-      await this._handleSignal({ author, recipient, message });
+      await this._handleSignal(ctx, { author, recipient, message });
     } else {
       log.warn('unknown message', { message });
     }
   }
 
-  async signal(message: SignalMessage): Promise<void> {
+  async signal(ctx: Context, message: SignalMessage): Promise<void> {
     invariant(message.data?.signal || message.data?.signalBatch, 'Invalid message');
-    await this._sendReliableMessage({
+    await this._sendReliableMessage(ctx, {
       author: message.author,
       recipient: message.recipient,
       message,
     });
   }
 
-  async offer(message: OfferMessage): Promise<Answer> {
+  async offer(ctx: Context, message: OfferMessage): Promise<Answer> {
     const networkMessage: SwarmMessage = {
       ...message,
       messageId: PublicKey.random(),
     };
     return new Promise<Answer>((resolve, reject) => {
       this._offerRecords.set(networkMessage.messageId!, { resolve });
-      this._sendReliableMessage({
+      this._sendReliableMessage(ctx, {
         author: message.author,
         recipient: message.recipient,
         message: networkMessage,
@@ -107,15 +108,18 @@ export class SwarmMessenger implements SignalMessenger {
     });
   }
 
-  private async _sendReliableMessage({
-    author,
-    recipient,
-    message,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    message: MakeOptional<SwarmMessage, 'messageId'>;
-  }): Promise<void> {
+  private async _sendReliableMessage(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      message,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      message: MakeOptional<SwarmMessage, 'messageId'>;
+    },
+  ): Promise<void> {
     const networkMessage: SwarmMessage = {
       ...message,
       // Setting unique message_id if it not specified yet.
@@ -123,7 +127,7 @@ export class SwarmMessenger implements SignalMessenger {
     };
 
     log('sending', { from: author, to: recipient, msg: networkMessage });
-    await this._sendMessage({
+    await this._sendMessage(ctx, {
       author,
       recipient,
       payload: {
@@ -144,15 +148,18 @@ export class SwarmMessenger implements SignalMessenger {
     }
   }
 
-  private async _handleOffer({
-    author,
-    recipient,
-    message,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    message: SwarmMessage;
-  }): Promise<void> {
+  private async _handleOffer(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      message,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      message: SwarmMessage;
+    },
+  ): Promise<void> {
     invariant(message.data.offer, 'No offer');
     const offerMessage: OfferMessage = {
       author,
@@ -160,10 +167,10 @@ export class SwarmMessenger implements SignalMessenger {
       ...message,
       data: { offer: message.data.offer },
     };
-    const answer = await this._onOffer(offerMessage);
+    const answer = await this._onOffer(ctx, offerMessage);
     answer.offerMessageId = message.messageId;
     try {
-      await this._sendReliableMessage({
+      await this._sendReliableMessage(ctx, {
         author: recipient,
         recipient: author,
         message: {
@@ -181,15 +188,18 @@ export class SwarmMessenger implements SignalMessenger {
     }
   }
 
-  private async _handleSignal({
-    author,
-    recipient,
-    message,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    message: SwarmMessage;
-  }): Promise<void> {
+  private async _handleSignal(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      message,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      message: SwarmMessage;
+    },
+  ): Promise<void> {
     invariant(message.messageId);
     invariant(message.data.signal || message.data.signalBatch, 'Invalid message');
     const signalMessage: SignalMessage = {
@@ -202,6 +212,6 @@ export class SwarmMessenger implements SignalMessenger {
       },
     };
 
-    await this._onSignal(signalMessage);
+    await this._onSignal(ctx, signalMessage);
   }
 }

package/src/swarm/connection.test.ts

@@ -10,7 +10,6 @@ import { PublicKey } from '@dxos/keys';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { createRtcTransportFactory } from '../transport';
 import { chooseInitiatorPeer } from '../transport/webrtc/utils';
-
 import { Connection } from './connection';
 
 // Segfault in node-datachannel.
@@ -44,9 +43,9 @@ describe.skip('Connection', () => {
       sessionId,
       true,
       {
-        offer: async (msg) => ({ accept: true }),
-        signal: async (msg) => {
-          await fastConnection.signal(msg);
+        offer: async (_ctx, _msg) => ({ accept: true }),
+        signal: async (ctx, msg) => {
+          await fastConnection.signal(ctx, msg);
         },
       },
       slowPeerProtocol.factory({
@@ -66,9 +65,9 @@ describe.skip('Connection', () => {
       sessionId,
       false,
       {
-        offer: async (msg) => ({ accept: true }),
-        signal: async (msg) => {
-          await slowConnection.signal(msg);
+        offer: async (_ctx, _msg) => ({ accept: true }),
+        signal: async (ctx, msg) => {
+          await slowConnection.signal(ctx, msg);
         },
       },
       fastPeerProtocol.factory({

package/src/swarm/connection.ts

@@ -9,14 +9,7 @@ import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log, logInfo } from '@dxos/log';
 import { type PeerInfo } from '@dxos/messaging';
-import {
-  CancelledError,
-  ConnectionResetError,
-  ConnectivityError,
-  ProtocolError,
-  TimeoutError,
-  trace,
-} from '@dxos/protocols';
+import { CancelledError, ConnectionResetError, ConnectivityError, ProtocolError, TimeoutError } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 import { type SignalMessage, type SignalMessenger } from '../signal';
@@ -113,12 +106,10 @@ export class Connection {
   readonly stateChanged = new Event<ConnectionState>();
   readonly errors = new ErrorStream();
 
-  public _instanceId = PublicKey.random().toHex();
-
   public readonly transportStats = new Event<TransportStats>();
 
   private readonly _signalSendTask = new DeferredTask(this._ctx, async () => {
-    await this._flushSignalBuffer();
+    await this._flushSignalBuffer(this._ctx);
   });
 
   private _signallingDelay = STARTING_SIGNALLING_DELAY;
@@ -165,7 +156,7 @@ export class Connection {
    */
   async openConnection(): Promise<void> {
     invariant(this._state === ConnectionState.INITIAL, 'Invalid state.');
-    log.trace('dxos.mesh.connection.open-connection', trace.begin({ id: this._instanceId }));
+    log('opening connection');
     log.trace('dxos.mesh.connection.open', {
       sessionId: this.sessionId,
       topic: this.topic,
@@ -185,16 +176,18 @@ export class Connection {
     this._protocol.stream.on('close', () => {
       log('protocol stream closed');
       this._protocolClosed.wake();
-      this.close({ error: new ProtocolError('protocol stream closed') }).catch((err) => this.errors.raise(err));
+      this.close({ error: new ProtocolError({ message: 'protocol stream closed' }) }).catch((err) =>
+        this.errors.raise(err),
+      );
     });
 
     scheduleTask(
       this.connectedTimeoutContext,
       async () => {
         log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect, aborting`);
-        await this.abort(new TimeoutError(`${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect`)).catch(
-          (err) => this.errors.raise(err),
-        );
+        await this.abort(
+          new TimeoutError({ message: `${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect` }),
+        ).catch((err) => this.errors.raise(err));
       },
       TRANSPORT_CONNECTION_TIMEOUT,
     );
@@ -255,7 +248,7 @@ export class Connection {
 
     this._incomingSignalBuffer = [];
 
-    log.trace('dxos.mesh.connection.open-connection', trace.end({ id: this._instanceId }));
+    log('opened connection');
   }
 
   @synchronized
@@ -364,21 +357,21 @@ export class Connection {
     this._signalSendTask.schedule();
   }
 
-  private async _flushSignalBuffer(): Promise<void> {
+  private async _flushSignalBuffer(ctx: Context): Promise<void> {
     if (this._outgoingSignalBuffer.length === 0) {
       return;
     }
 
     try {
       if (process.env.NODE_ENV !== 'test') {
-        await cancelWithContext(this._ctx, sleep(this._signallingDelay));
+        await cancelWithContext(ctx, sleep(this._signallingDelay));
         this._signallingDelay = Math.min(this._signallingDelay * 2, MAX_SIGNALLING_DELAY);
       }
 
       const signals = [...this._outgoingSignalBuffer];
       this._outgoingSignalBuffer.length = 0;
 
-      await this._signalMessaging.signal({
+      await this._signalMessaging.signal(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId: this.sessionId,
@@ -397,14 +390,14 @@ export class Connection {
 
       // If signal fails treat connection as failed
       log.info('signal message failed to deliver', { err });
-      await this.close({ error: new ConnectivityError('signal message failed to deliver', err) });
+      await this.close({ error: new ConnectivityError({ message: 'signal message failed to deliver', cause: err }) });
     }
   }
 
   /**
    * Receive a signal from the remote peer.
    */
-  async signal(msg: SignalMessage): Promise<void> {
+  async signal(_ctx: Context, msg: SignalMessage): Promise<void> {
     invariant(msg.sessionId);
     if (!msg.sessionId.equals(this.sessionId)) {
       log('dropping signal for incorrect session id');

package/src/swarm/peer.ts

@@ -14,13 +14,12 @@ import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { type OfferMessage, type SignalMessage, type SignalMessenger } from '../signal';
 import { type TransportFactory } from '../transport';
 import { type WireProtocolProvider } from '../wire-protocol';
-
 import { Connection, ConnectionState } from './connection';
 import { type ConnectionLimiter } from './connection-limiter';
 
 export class ConnectionDisplacedError extends SystemError {
   constructor() {
-    super('Connection displaced by remote initiator.');
+    super({ message: 'Connection displaced by remote initiator.' });
   }
 }
 
@@ -106,7 +105,7 @@ export class Peer {
   /**
    * Respond to remote offer.
    */
-  async onOffer(message: OfferMessage): Promise<Answer> {
+  async onOffer(_ctx: Context, message: OfferMessage): Promise<Answer> {
     const remote = message.author;
 
     if (
@@ -162,13 +161,14 @@ export class Peer {
         return { accept: true };
       }
     }
+
     return { accept: false };
   }
 
   /**
    * Initiate a connection to the remote peer.
    */
-  async initiateConnection(): Promise<void> {
+  async initiateConnection(ctx: Context): Promise<void> {
     invariant(!this.initiating, 'Initiation in progress.');
     invariant(!this.connection, 'Already connected.');
     const sessionId = PublicKey.random();
@@ -182,7 +182,7 @@ export class Peer {
       await this._connectionLimiter.connecting(sessionId);
       connection.initiate();
 
-      answer = await this._signalMessaging.offer({
+      answer = await this._signalMessaging.offer(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId,
@@ -377,13 +377,13 @@ export class Peer {
     log('closed', { peerId: this.remoteInfo, sessionId: connection.sessionId });
   }
 
-  async onSignal(message: SignalMessage): Promise<void> {
+  async onSignal(ctx: Context, message: SignalMessage): Promise<void> {
     if (!this.connection) {
       log('dropping signal message for non-existent connection', { message });
       return;
     }
 
-    await this.connection.signal(message);
+    await this.connection.signal(ctx, message);
   }
 
   @synchronized

package/src/swarm/swarm.test.ts

@@ -18,7 +18,6 @@ import { ComplexSet } from '@dxos/util';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
 import { createRtcTransportFactory } from '../transport';
-
 import { ConnectionState } from './connection';
 import { ConnectionLimiter } from './connection-limiter';
 import { Swarm } from './swarm';
@@ -159,9 +158,9 @@ describe.skip('Swarm', () => {
     const messages = new ComplexSet<{ author: PeerInfo; recipient: PeerInfo }>(
       ({ author, recipient }) => author.peerKey + recipient.peerKey,
     );
-    signalManager.sendMessage = async (message) => {
+    signalManager.sendMessage = async (ctx, message) => {
       messages.add({ author: message.author, recipient: message.recipient });
-      return sendOriginal(message);
+      return sendOriginal(ctx, message);
     };
     // Stop signaling to stop connection in initiation state.
     signalManager.freeze();

package/src/swarm/swarm.ts

@@ -9,7 +9,6 @@ import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log, logInfo } from '@dxos/log';
 import { type ListeningHandle, type Messenger, type PeerInfo, PeerInfoHash, type SwarmEvent } from '@dxos/messaging';
-import { trace } from '@dxos/protocols';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap, isNonNullable } from '@dxos/util';
 
@@ -18,7 +17,6 @@ import { type SwarmController, type Topology } from '../topology';
 import { type TransportFactory } from '../transport';
 import { type Topic } from '../types';
 import { type WireProtocolProvider } from '../wire-protocol';
-
 import { type Connection, ConnectionState } from './connection';
 import { type ConnectionLimiter } from './connection-limiter';
 import { Peer } from './peer';
@@ -86,20 +84,15 @@ export class Swarm {
     private readonly _connectionLimiter: ConnectionLimiter,
     private readonly _initiationDelay = INITIATION_DELAY,
   ) {
-    log.trace(
-      'dxos.mesh.swarm.constructor',
-      trace.begin({ id: this._instanceId, data: { topic: this._topic.toHex(), peer: this._ownPeer } }),
-    );
-    log('creating swarm', { peerId: _ownPeer });
+    log('creating swarm', { topic: this._topic.toHex(), peer: this._ownPeer });
     _topology.init(this._getSwarmController());
 
     this._swarmMessenger = new SwarmMessenger({
-      sendMessage: async (msg) => await this._messenger.sendMessage(msg),
-      onSignal: async (msg) => await this.onSignal(msg),
-      onOffer: async (msg) => await this.onOffer(msg),
+      sendMessage: async (ctx, msg) => await this._messenger.sendMessage(ctx, msg),
+      onSignal: async (ctx, msg) => await this.onSignal(ctx, msg),
+      onOffer: async (ctx, msg) => await this.onOffer(ctx, msg),
       topic: this._topic,
     });
-    log.trace('dxos.mesh.swarm.constructor', trace.end({ id: this._instanceId }));
   }
 
   get connections() {
@@ -136,7 +129,7 @@ export class Swarm {
       payloadType: 'dxos.mesh.swarm.SwarmMessage',
       onMessage: async (message) => {
         await this._swarmMessenger
-          .receiveMessage(message)
+          .receiveMessage(this._ctx, message)
           // TODO(nf): discriminate between errors
           .catch((err) => log.info('Error while receiving message', { err }));
       },
@@ -205,7 +198,7 @@ export class Swarm {
   }
 
   @synchronized
-  async onOffer(message: OfferMessage): Promise<Answer> {
+  async onOffer(ctx: Context, message: OfferMessage): Promise<Answer> {
     log('offer', { message });
     if (this._ctx.disposed) {
       log('ignored for disposed swarm');
@@ -224,7 +217,7 @@ export class Swarm {
     }
 
     const peer = this._getOfferSenderPeer(message.author);
-    const answer = await peer.onOffer(message);
+    const answer = await peer.onOffer(ctx, message);
     this._topology.update();
     return answer;
   }
@@ -243,7 +236,7 @@ export class Swarm {
     return peer;
   }
 
-  async onSignal(message: SignalMessage): Promise<void> {
+  async onSignal(ctx: Context, message: SignalMessage): Promise<void> {
     log('signal', { message });
     if (this._ctx.disposed) {
       log.info('ignored for offline swarm');
@@ -257,7 +250,7 @@ export class Swarm {
     invariant(message.author);
 
     const peer = this._getOrCreatePeer(message.author);
-    await peer.onSignal(message);
+    await peer.onSignal(ctx, message);
   }
 
   // For debug purposes
@@ -404,7 +397,7 @@ export class Swarm {
     }
 
     log('initiating connection...', { remotePeer });
-    await peer.initiateConnection();
+    await peer.initiateConnection(ctx);
     this._topology.update();
     log('initiated', { remotePeer });
   }

package/src/testing/test-builder.ts

@@ -2,6 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
@@ -28,7 +29,6 @@ import {
   TransportKind,
   createRtcTransportFactory,
 } from '../transport';
-
 import { type TestTeleportExtensionFactory, TestWireProtocol } from './test-wire-protocol';
 
 // Signal server will be started by the setup script.
@@ -169,7 +169,7 @@ export class TestPeer {
 
     await this._proxy?.close();
     await this._service?.close();
-    await this._networkManager.close();
+    await this._networkManager.close(Context.default());
   }
 
   getSwarm(topic: PublicKey): TestSwarmConnection {
@@ -218,7 +218,7 @@ export class TestSwarmConnection {
   // TODO(burdon): Need to create new plugin instance per swarm?
   //  If so, then perhaps joinSwarm should return swarm object with access to plugins.
   async join(topology = new FullyConnectedTopology()): Promise<this> {
-    await this.peer._networkManager.joinSwarm({
+    await this.peer._networkManager.joinSwarm(Context.default(), {
       topic: this.topic,
       peerInfo: { peerKey: this.peer.peerId.toHex(), identityKey: this.peer.peerId.toHex() },
       protocolProvider: this.protocol.factory,
@@ -229,7 +229,7 @@ export class TestSwarmConnection {
   }
 
   async leave(): Promise<this> {
-    await this.peer._networkManager.leaveSwarm(this.topic);
+    await this.peer._networkManager.leaveSwarm(Context.default(), this.topic);
     return this;
   }
 }

package/src/tests/basic-test-suite.ts

@@ -11,7 +11,6 @@ import { range } from '@dxos/util';
 
 import { type TestBuilder } from '../testing';
 import { FullyConnectedTopology, StarTopology } from '../topology';
-
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 
 // TODO(burdon): Use PublicKey throughout (remove conversion to strings, from buffers, etc.)

package/src/tests/memory-transport.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { randomBytes } from 'node:crypto';
-
 import { describe, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
@@ -11,7 +10,6 @@ import { range } from '@dxos/util';
 
 import { TestBuilder } from '../testing';
 import { FullyConnectedTopology } from '../topology';
-
 import { basicTestSuite } from './basic-test-suite';
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 

package/src/tests/property-test-suite.ts

@@ -6,6 +6,7 @@ import * as fc from 'fast-check';
 import { type ModelRunSetup } from 'fast-check';
 import { test } from 'vitest';
 
+import { Context } from '@dxos/context';
 import { todo } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { ComplexMap, ComplexSet, range } from '@dxos/util';
@@ -97,7 +98,7 @@ export const propertyTestSuite = () => {
         model.joinedPeers.delete(this.peerId);
 
         const peer = real.peers.get(this.peerId);
-        await peer!.networkManager.close();
+        await peer!.networkManager.close(Context.default());
         real.peers.delete(this.peerId);
 
         await assertState(model, real);
@@ -119,7 +120,7 @@ export const propertyTestSuite = () => {
         // afterTest(() => presence.stop());
         // const protocol = createProtocolFactory(model.topic, this.peerId, [presence]);
 
-        await peer.networkManager.joinSwarm({
+        await peer.networkManager.joinSwarm(Context.default(), {
           peerInfo: {
             peerKey: this.peerId.toHex(),
             identityKey: this.peerId.toHex(),
@@ -146,7 +147,7 @@ export const propertyTestSuite = () => {
         model.joinedPeers.delete(this.peerId);
 
         const peer = real.peers.get(this.peerId)!;
-        await peer.networkManager.leaveSwarm(model.topic);
+        await peer.networkManager.leaveSwarm(Context.default(), model.topic);
         peer.presence = undefined;
 
         await assertState(model, real);

package/src/tests/tcp-transport.node.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { randomBytes } from 'node:crypto';
-
 import { describe, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
@@ -12,7 +11,6 @@ import { range } from '@dxos/util';
 import { TestBuilder } from '../testing';
 import { FullyConnectedTopology } from '../topology';
 import { TransportKind } from '../transport';
-
 import { basicTestSuite } from './basic-test-suite';
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 

package/src/tests/webrtc-transport.test.ts

@@ -5,7 +5,6 @@
 import { describe } from 'vitest';
 
 import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
-
 import { basicTestSuite } from './basic-test-suite';
 
 // Segfault in node-datachannel.

package/src/transport/tcp/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './tcp-transport';
+export * from '#tcp-transport-impl';