@dxos/network-manager 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

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

@@ -3,16 +3,18 @@
 //
 
 import { randomBytes } from 'node:crypto';
+
 import { describe, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
 import { range } from '@dxos/util';
 
-import { basicTestSuite } from './basic-test-suite';
-import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 import { TestBuilder } from '../testing';
 import { FullyConnectedTopology } from '../topology';
 
+import { basicTestSuite } from './basic-test-suite';
+import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
+
 describe('Memory transport', () => {
   const testBuilder = new TestBuilder();
   basicTestSuite(testBuilder);

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,17 +3,19 @@
 //
 
 import { randomBytes } from 'node:crypto';
+
 import { describe, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
 import { range } from '@dxos/util';
 
-import { basicTestSuite } from './basic-test-suite';
-import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
 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';
+
 describe('Tcp transport', () => {
   const testBuilder = new TestBuilder({
     transport: TransportKind.TCP,

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

@@ -4,15 +4,18 @@
 
 import { describe } from 'vitest';
 
-import { basicTestSuite } from './basic-test-suite';
 import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
 
-describe('WebRTC transport', { timeout: 10_000 }, () => {
+import { basicTestSuite } from './basic-test-suite';
+
+// Segfault in node-datachannel.
+describe.skip('WebRTC transport', { timeout: 10_000 }, () => {
   const testBuilder = new TestBuilder();
   basicTestSuite(testBuilder);
 });
 
-describe('WebRTC transport proxy', { timeout: 10_000 }, () => {
+// Segfault in node-datachannel.
+describe.skip('WebRTC transport proxy', { timeout: 10_000 }, () => {
   const testBuilder = new TestBuilder({ bridge: true });
   basicTestSuite(testBuilder);
 });

package/src/transport/tcp/index.ts

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

package/src/transport/tcp/tcp-transport.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import { type AddressInfo, Socket, type Server } from 'node:net';
+import { type AddressInfo, type Server, Socket } from 'node:net';
 
 import { Event } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';

package/src/transport/webrtc/rtc-peer-connection.ts

@@ -2,18 +2,19 @@
 // Copyright 2024 DXOS.org
 //
 
-import { synchronized, Trigger, Mutex } from '@dxos/async';
+import { Mutex, Trigger, synchronized } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
 import { log, logInfo } from '@dxos/log';
 import { ConnectivityError } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { trace } from '@dxos/tracing';
 
+import type { IceProvider } from '../../signal';
+import { type TransportOptions } from '../transport';
+
 import { type RtcConnectionFactory } from './rtc-connection-factory';
 import { RtcTransportChannel } from './rtc-transport-channel';
 import { areSdpEqual, chooseInitiatorPeer } from './utils';
-import type { IceProvider } from '../../signal';
-import { type TransportOptions } from '../transport';
 
 export type RtcPeerChannelFactoryOptions = {
   ownPeerKey: string;
@@ -468,7 +469,7 @@ type IceCandidateErrorDetails = { url: string; errorCode: number; errorText: str
 
 const createIceFailureError = (details: IceCandidateErrorDetails[]) => {
   const candidateErrors = details.map(({ url, errorCode, errorText }) => `${errorCode} ${url}: ${errorText}`);
-  return new ConnectivityError(`ICE failed:\n${candidateErrors.join('\n')}`);
+  return new ConnectivityError({ message: `ICE failed:\n${candidateErrors.join('\n')}` });
 };
 
 type ChannelCreatedCallback = {

package/src/transport/webrtc/rtc-transport-channel.test.ts

@@ -3,14 +3,16 @@
 //
 
 import { Duplex } from 'node:stream';
+
 import { describe, expect, test } from 'vitest';
 
 import { sleep } from '@dxos/async';
 
+import { type TransportOptions } from '../transport';
+
 import { type RtcPeerConnection } from './rtc-peer-connection';
 import { RtcTransportChannel } from './rtc-transport-channel';
 import { handleChannelErrors } from './test-utils';
-import { type TransportOptions } from '../transport';
 
 describe('RtcTransportChannel', () => {
   test('transport error raised if channel creation fails', async () => {

package/src/transport/webrtc/rtc-transport-channel.ts

@@ -12,9 +12,10 @@ import { log } from '@dxos/log';
 import { ConnectivityError } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
+import { type Transport, type TransportOptions, type TransportStats } from '../transport';
+
 import { type RtcPeerConnection } from './rtc-peer-connection';
 import { createRtcTransportStats, describeSelectedRemoteCandidate } from './rtc-transport-stats';
-import { type Transport, type TransportOptions, type TransportStats } from '../transport';
 
 // https://viblast.com/blog/2015/2/5/webrtc-data-channel-message-size
 const MAX_MESSAGE_SIZE = 64 * 1024;
@@ -70,7 +71,7 @@ export class RtcTransportChannel extends Resource implements Transport {
           const error =
             err instanceof Error
               ? err
-              : new ConnectivityError(`Failed to create a channel: ${JSON.stringify(err?.message)}`);
+              : new ConnectivityError({ message: `Failed to create a channel: ${JSON.stringify(err?.message)}` });
           this.errors.raise(error);
         } else {
           log.verbose('connection establishment failed after transport was closed', { err });

package/src/transport/webrtc/rtc-transport-factory.ts

@@ -2,11 +2,12 @@
 // Copyright 2024 DXOS.org
 //
 
-import { getRtcConnectionFactory } from './rtc-connection-factory';
-import { RtcPeerConnection } from './rtc-peer-connection';
 import type { IceProvider } from '../../signal';
 import type { TransportFactory } from '../transport';
 
+import { getRtcConnectionFactory } from './rtc-connection-factory';
+import { RtcPeerConnection } from './rtc-peer-connection';
+
 export const createRtcTransportFactory = (
   webrtcConfig?: RTCConfiguration,
   iceProvider?: IceProvider,

package/src/transport/webrtc/rtc-transport-proxy.test.ts

@@ -3,21 +3,24 @@
 //
 
 import { Duplex } from 'stream';
-import { onTestFinished, describe, test, expect } from 'vitest';
+
+import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Event as AsyncEvent, TestStream, Trigger, sleep } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { schema } from '@dxos/protocols/proto';
 import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { createLinkedPorts, createProtoRpcPeer, type RpcPort } from '@dxos/rpc';
+import { type RpcPort, createLinkedPorts, createProtoRpcPeer } from '@dxos/rpc';
+
+import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from '../transport';
 
 import { RtcTransportProxy } from './rtc-transport-proxy';
 import { RtcTransportService } from './rtc-transport-service';
 import { handleChannelErrors } from './test-utils';
-import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from '../transport';
 
-describe('RtcPeerTransportProxy', () => {
+// Segfault in node-datachannel.
+describe.skip('RtcPeerTransportProxy', () => {
   test('open and close', async () => {
     const { proxy } = await setupProxy();
     await proxy.open();

package/src/transport/webrtc/rtc-transport-proxy.ts

@@ -176,7 +176,9 @@ export class RtcTransportProxy extends Resource implements Transport {
     } catch (error) {
       const type = signalEvent.payload.payload.data?.type;
       if (type === 'offer' || type === 'answer') {
-        this._raiseIfOpen(new ConnectivityError(`Session establishment failed: ${type} couldn't be sent.`));
+        this._raiseIfOpen(
+          new ConnectivityError({ message: `Session establishment failed: ${type} couldn't be sent.` }),
+        );
       }
     }
   }
@@ -255,11 +257,11 @@ export class RtcTransportProxyFactory implements TransportFactory {
 const decodeError = (err: Error | string) => {
   const message = typeof err === 'string' ? err : err.message;
   if (message.includes('CONNECTION_RESET')) {
-    return new ConnectionResetError(message);
+    return new ConnectionResetError({ message });
   } else if (message.includes('TIMEOUT')) {
-    return new TimeoutError(message);
+    return new TimeoutError({ message });
   } else if (message.includes('CONNECTIVITY_ERROR')) {
-    return new ConnectivityError(message);
+    return new ConnectivityError({ message });
   } else {
     return typeof err === 'string' ? new Error(err) : err;
   }

package/src/transport/webrtc/rtc-transport-service.ts

@@ -9,24 +9,25 @@ import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
+  type BridgeEvent,
   type BridgeService,
+  type CloseRequest,
   type ConnectionRequest,
-  type SignalRequest,
-  type DataRequest,
-  type BridgeEvent,
   ConnectionState,
-  type CloseRequest,
+  type DataRequest,
   type DetailsRequest,
   type DetailsResponse,
+  type SignalRequest,
   type StatsRequest,
   type StatsResponse,
 } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { ComplexMap } from '@dxos/util';
 
-import { createRtcTransportFactory } from './rtc-transport-factory';
 import { type IceProvider } from '../../signal';
 import { type Transport, type TransportFactory } from '../transport';
 
+import { createRtcTransportFactory } from './rtc-transport-factory';
+
 type TransportState = {
   proxyId: PublicKey;
   transport: Transport;

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

@@ -2,20 +2,22 @@
 // Copyright 2020 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { sleep, TestStream } from '@dxos/async';
+import { TestStream, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 
+import { type TransportOptions } from '../transport';
+
 import { getRtcConnectionFactory } from './rtc-connection-factory';
 import { RtcPeerConnection } from './rtc-peer-connection';
 import { type RtcTransportChannel } from './rtc-transport-channel';
 import { chooseInitiatorPeer } from './utils';
-import { type TransportOptions } from '../transport';
 
 const connectionFactory = getRtcConnectionFactory();
 
-describe('RtcTransport', () => {
+// Segfault in node-datachannel.
+describe.skip('RtcTransport', () => {
   test('channel open and close', async () => {
     const peer = await createConnection();
     const channel = createChannel(peer);

package/src/wire-protocol.ts

@@ -5,16 +5,16 @@
 import { type Duplex } from 'node:stream';
 
 import { type PublicKey } from '@dxos/keys';
-import { Teleport, type TeleportParams } from '@dxos/teleport';
+import { Teleport, type TeleportProps } from '@dxos/teleport';
 
-export type WireProtocolParams = {
+export type WireProtocolProps = {
   initiator: boolean;
   localPeerId: PublicKey;
   remotePeerId: PublicKey;
   topic: PublicKey;
 };
 
-export type WireProtocolProvider = (params: WireProtocolParams) => WireProtocol;
+export type WireProtocolProvider = (params: WireProtocolProps) => WireProtocol;
 
 /**
  * Application-specific network protocol that is used when a connection to a peer is established.
@@ -31,15 +31,15 @@ export interface WireProtocol {
 /**
  * Create a wire-protocol provider backed by a teleport instance.
  * @param onConnection Called after teleport is initialized for the session. Protocol extensions could be attached here.
- * @param defaultParams Optionally provide default Teleport params that might be overridden by factory callers.
+ * @param defaultProps Optionally provide default Teleport params that might be overridden by factory callers.
  * @returns
  */
 export const createTeleportProtocolFactory = (
   onConnection: (teleport: Teleport) => Promise<void>,
-  defaultParams?: Partial<TeleportParams>,
+  defaultProps?: Partial<TeleportProps>,
 ): WireProtocolProvider => {
   return (params) => {
-    const teleport = new Teleport({ ...defaultParams, ...params });
+    const teleport = new Teleport({ ...defaultProps, ...params });
     return {
       stream: teleport.stream,
       open: async (sessionId?: PublicKey) => {