@dxos/network-manager 0.10.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/network-manager",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Network Manager",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -26,10 +26,10 @@
     "#tcp-transport": {
       "source": "./src/transport/tcp/index.ts",
       "types": "./dist/types/src/transport/tcp/index.d.ts",
-      "browser": "./dist/lib/browser/transport/tcp/index.mjs",
-      "node": "./dist/lib/node-esm/transport/tcp/index.mjs",
-      "import": "./dist/lib/browser/transport/tcp/index.mjs",
-      "require": "./dist/lib/node-esm/transport/tcp/index.mjs"
+      "browser": "./dist/lib/transport/tcp.mjs",
+      "node": "./dist/lib/transport/tcp.mjs",
+      "import": "./dist/lib/transport/tcp.mjs",
+      "require": "./dist/lib/transport/tcp.mjs"
     },
     "#tcp-transport-impl": {
       "source": {
@@ -37,28 +37,25 @@
         "default": "./src/transport/tcp/tcp-transport.ts"
       },
       "types": "./dist/types/src/transport/tcp/tcp-transport.d.ts",
-      "browser": "./dist/lib/browser/transport/tcp/tcp-transport.browser.mjs",
-      "default": "./dist/lib/node-esm/transport/tcp/tcp-transport.mjs"
+      "browser": "./dist/lib/transport/tcp/tcp-transport.browser.mjs",
+      "default": "./dist/lib/transport/tcp/tcp-transport.mjs"
     }
   },
   "exports": {
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "import": "./dist/lib/index.mjs"
     },
     "./testing": {
       "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs"
+      "import": "./dist/lib/testing.mjs"
     },
     "./transport/tcp": {
       "source": "./src/transport/tcp/index.ts",
       "types": "./dist/types/src/transport/tcp/index.d.ts",
-      "browser": "./dist/lib/browser/transport/tcp/index.mjs",
-      "node": "./dist/lib/node-esm/transport/tcp/index.mjs"
+      "import": "./dist/lib/transport/tcp.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -70,27 +67,27 @@
     "src"
   ],
   "dependencies": {
-    "node-datachannel": "^0.30.0",
-    "@dxos/debug": "0.10.0",
-    "@dxos/async": "0.10.0",
-    "@dxos/codec-protobuf": "0.10.0",
-    "@dxos/context": "0.10.0",
-    "@dxos/invariant": "0.10.0",
-    "@dxos/log": "0.10.0",
-    "@dxos/keys": "0.10.0",
-    "@dxos/messaging": "0.10.0",
-    "@dxos/node-std": "0.10.0",
-    "@dxos/rpc": "0.10.0",
-    "@dxos/protocols": "0.10.0",
-    "@dxos/teleport": "0.10.0",
-    "@dxos/tracing": "0.10.0",
-    "@dxos/util": "0.10.0"
+    "effect": "3.21.4",
+    "node-datachannel": "^0.32.3",
+    "@dxos/async": "0.11.1",
+    "@dxos/debug": "0.11.1",
+    "@dxos/context": "0.11.1",
+    "@dxos/codec-protobuf": "0.11.1",
+    "@dxos/invariant": "0.11.1",
+    "@dxos/keys": "0.11.1",
+    "@dxos/log": "0.11.1",
+    "@dxos/messaging": "0.11.1",
+    "@dxos/protocols": "0.11.1",
+    "@dxos/node-std": "0.11.1",
+    "@dxos/rpc": "0.11.1",
+    "@dxos/tracing": "0.11.1",
+    "@dxos/teleport": "0.11.1",
+    "@dxos/util": "0.11.1"
   },
   "devDependencies": {
     "fetch-mock": "^11.0.0",
-    "@dxos/edge-client": "0.10.0",
-    "@dxos/signal": "0.10.0",
-    "@dxos/keyring": "0.10.0"
+    "@dxos/edge-client": "0.11.1",
+    "@dxos/keyring": "0.11.1"
   },
   "publishConfig": {
     "access": "public"

package/src/network-manager.ts

@@ -2,6 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
+import * as EffectContext from 'effect/Context';
+
 import { Event, synchronized } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { assertArgument, invariant } from '@dxos/invariant';
@@ -60,6 +62,14 @@ export type SwarmNetworkManagerOptions = {
   peerInfo?: PeerInfo;
 };
 
+/**
+ * Effect service tag for {@link SwarmNetworkManager}.
+ */
+export class SwarmNetworkManagerService extends EffectContext.Tag('@dxos/network-manager/SwarmNetworkManager')<
+  SwarmNetworkManagerService,
+  SwarmNetworkManager
+>() {}
+
 /**
  * Manages p2p connection to the swarm.
  */
@@ -128,6 +138,10 @@ export class SwarmNetworkManager {
     this._peerInfo = peerInfo;
   }
 
+  getPeerInfo(): PeerInfo | undefined {
+    return this._peerInfo;
+  }
+
   async open(): Promise<void> {
     log('opening network manager');
     await this._messenger.open();
@@ -235,16 +249,15 @@ export class SwarmNetworkManager {
     switch (state) {
       case ConnectionState.OFFLINE: {
         this._connectionState = state;
-        // go offline
+        // Only signaling toggles across an offline/online cycle. The messenger stays open so its
+        // subscriptions survive — the swarm does not re-`listen` on reconnect — and its subscriptions
+        // are torn down only on a real `close`.
         await Promise.all([...this._swarms.values()].map((swarm) => swarm.goOffline()));
-        await this._messenger.close();
         await this._signalManager.close();
         break;
       }
       case ConnectionState.ONLINE: {
         this._connectionState = state;
-        // go online
-        this._messenger.open();
         await Promise.all([...this._swarms.values()].map((swarm) => swarm.goOnline()));
         await this._signalManager.open();
         break;

package/src/signal/integration.node.test.ts

@@ -2,25 +2,21 @@
 // Copyright 2022 DXOS.org
 //
 
-import { afterAll, beforeAll, describe, expect, onTestFinished, test } from 'vitest';
+import { beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
-import { Messenger, type PeerInfo, WebsocketSignalManager } from '@dxos/messaging';
-import { type SignalServerRunner, runTestSignalServer } from '@dxos/signal';
+import { MemorySignalManager, MemorySignalManagerContext, Messenger, type PeerInfo } from '@dxos/messaging';
 
 import { type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
 
 describe('Signal Integration Test', () => {
-  let broker: SignalServerRunner;
+  // In-memory signaling context connecting the peers in each test (replaces the KUBE server).
+  let context: MemorySignalManagerContext;
 
-  beforeAll(async () => {
-    broker = await runTestSignalServer();
-  });
-
-  afterAll(() => {
-    void broker.stop();
+  beforeEach(() => {
+    context = new MemorySignalManagerContext();
   });
 
   const setupPeer = async ({
@@ -30,7 +26,7 @@ describe('Signal Integration Test', () => {
     peer?: PeerInfo;
     topic?: PublicKey;
   }) => {
-    const signalManager = new WebsocketSignalManager([{ server: broker.url() }]);
+    const signalManager = new MemorySignalManager(context);
     await signalManager.open();
     onTestFinished(async () => {
       await signalManager.close();

package/src/signal/swarm-messenger.node.test.ts

@@ -2,48 +2,37 @@
 // Copyright 2022 DXOS.org
 //
 
-import { afterAll, beforeAll, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
+import { beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
-import { type Awaited } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
-import { Messenger, WebsocketSignalManager } from '@dxos/messaging';
+import { MemorySignalManager, MemorySignalManagerContext, Messenger } from '@dxos/messaging';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
-import { runTestSignalServer } from '@dxos/signal';
 
 import { type OfferMessage, type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
 
 describe('SwarmMessenger', { timeout: 7000 }, () => {
   let topic: PublicKey;
-
-  let broker1: Awaited<ReturnType<typeof runTestSignalServer>>;
-
-  beforeAll(async () => {
-    broker1 = await runTestSignalServer();
-  });
+  // Shared in-memory signaling context connecting the peers in each test (replaces the KUBE server).
+  let context: MemorySignalManagerContext;
 
   beforeEach(() => {
     topic = PublicKey.random();
-  });
-
-  afterAll(() => {
-    void broker1.stop();
+    context = new MemorySignalManagerContext();
   });
 
   const createSignalClientAndMessageRouter = async ({
-    signalApiUrl,
     onSignal = (async () => {}) as any,
     onOffer = async () => ({ accept: true }),
     topic,
   }: {
-    signalApiUrl: string;
     onSignal?: (ctx: Context, msg: SignalMessage) => Promise<void>;
     onOffer?: (ctx: Context, msg: OfferMessage) => Promise<Answer>;
     topic: PublicKey;
   }) => {
     const peer = { peerKey: PublicKey.random().toHex() };
-    const signalManager = new WebsocketSignalManager([{ server: signalApiUrl }]);
+    const signalManager = new MemorySignalManager(context);
     await signalManager.open();
     onTestFinished(async () => {
       await signalManager.close();
@@ -77,7 +66,6 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       received.push(msg);
     };
     const { signalManager: signalManager1, peer: peer1 } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: signalMock1,
       topic,
     });
@@ -85,10 +73,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       signalManager: signalManager2,
       router: router2,
       peer: peer2,
-    } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
-      topic,
-    });
+    } = await createSignalClientAndMessageRouter({ topic });
 
     await signalManager1.join(Context.default(), { topic, peer: peer1 });
     await signalManager2.join(Context.default(), { topic, peer: peer2 });
@@ -114,13 +99,11 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       router: router1,
       peer: peer1,
     } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: (async () => {}) as any,
       onOffer: async () => ({ accept: true }),
       topic,
     });
     const { signalManager: signalManager2, peer: peer2 } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: (async () => {}) as any,
       onOffer: async () => ({ accept: true }),
       topic,
@@ -148,7 +131,6 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       router: router1,
       peer: peer1,
     } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: signalMock1,
       onOffer: async () => ({ accept: true }),
       topic,
@@ -162,7 +144,6 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       router: router2,
       peer: peer2,
     } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: signalMock2,
       onOffer: async () => ({ accept: true }),
       topic,
@@ -176,7 +157,6 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       router: router3,
       peer: peer3,
     } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: signalMock3,
       onOffer: async () => ({ accept: true }),
       topic,
@@ -226,7 +206,6 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       router: router1,
       peer: peer1,
     } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: (async () => {}) as any,
       onOffer: async () => ({ accept: true }),
       topic,
@@ -236,7 +215,6 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       router: router2,
       peer: peer2,
     } = await createSignalClientAndMessageRouter({
-      signalApiUrl: broker1.url(),
       onSignal: (async () => {}) as any,
       onOffer: async () => ({ accept: true }),
       topic,

package/src/signal/swarm-messenger.ts

@@ -2,7 +2,6 @@
 // Copyright 2020 DXOS.org
 //
 
-import { type Any } from '@dxos/codec-protobuf';
 import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
@@ -46,22 +45,13 @@ export class SwarmMessenger implements SignalMessenger {
     this._topic = topic;
   }
 
-  async receiveMessage(
-    ctx: Context,
-    {
-      author,
-      recipient,
-      payload,
-    }: {
-      author: PeerInfo;
-      recipient: PeerInfo;
-      payload: Any;
-    },
-  ): Promise<void> {
+  async receiveMessage(ctx: Context, { author, recipient, payload }: Message): Promise<void> {
     if (payload.type_url !== 'dxos.mesh.swarm.SwarmMessage') {
       // Ignore not swarm messages.
       return;
     }
+    // Swarm signaling is point-to-point; a broadcast (DX-1125) never carries a SwarmMessage payload.
+    invariant(recipient, 'Recipient is required');
     const message: SwarmMessage = SwarmMessage.decode(payload.value);
 
     if (!this._topic.equals(message.topic)) {

package/src/swarm/swarm.test.ts

@@ -155,8 +155,8 @@ describe.skip('Swarm', () => {
 
     const signalManager = new MemorySignalManager(context);
     const sendOriginal = signalManager.sendMessage.bind(signalManager);
-    const messages = new ComplexSet<{ author: PeerInfo; recipient: PeerInfo }>(
-      ({ author, recipient }) => author.peerKey + recipient.peerKey,
+    const messages = new ComplexSet<{ author: PeerInfo; recipient?: PeerInfo }>(
+      ({ author, recipient }) => author.peerKey + recipient?.peerKey,
     );
     signalManager.sendMessage = async (ctx, message) => {
       messages.add({ author: message.author, recipient: message.recipient });

package/src/testing/test-builder.ts

@@ -4,16 +4,9 @@
 
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import {
-  MemorySignalManager,
-  MemorySignalManagerContext,
-  type SignalManager,
-  WebsocketSignalManager,
-} from '@dxos/messaging';
+import { MemorySignalManager, MemorySignalManagerContext, type SignalManager } from '@dxos/messaging';
 import { schema } from '@dxos/protocols/proto';
 import { ConnectionState } from '@dxos/protocols/proto/dxos/client/services';
-import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type ProtoRpcPeer, createLinkedPorts, createProtoRpcPeer } from '@dxos/rpc';
 import { ComplexMap } from '@dxos/util';
 
@@ -31,15 +24,7 @@ import {
 } from '../transport';
 import { type TestTeleportExtensionFactory, TestWireProtocol } from './test-wire-protocol';
 
-// Signal server will be started by the setup script.
-const port = process.env.SIGNAL_PORT ?? 4000;
-export const TEST_SIGNAL_HOSTS: Runtime.Services.Signal[] = [
-  { server: `ws://localhost:${port}/.well-known/dx/signal` },
-];
-
 export type TestBuilderOptions = {
-  signalHosts?: Runtime.Services.Signal[];
-  bridge?: boolean;
   transport?: TransportKind;
 };
 
@@ -51,11 +36,9 @@ export class TestBuilder {
 
   constructor(public readonly options: TestBuilderOptions = {}) {}
 
-  createSignalManager(): WebsocketSignalManager | MemorySignalManager {
-    if (this.options.signalHosts) {
-      return new WebsocketSignalManager(this.options.signalHosts);
-    }
-
+  createSignalManager(): MemorySignalManager {
+    // KUBE `WebsocketSignalManager` was removed; signaling is always in-memory (the shared context
+    // connects peers in-process). The transport is chosen independently via `options.transport`.
     return new MemorySignalManager(this._signalContext);
   }
 
@@ -86,9 +69,7 @@ export class TestPeer {
   constructor(
     private readonly testBuilder: TestBuilder,
     public readonly peerId: PublicKey,
-    public readonly transport: TransportKind = testBuilder.options.signalHosts
-      ? TransportKind.WEB_RTC
-      : TransportKind.MEMORY,
+    public readonly transport: TransportKind = TransportKind.MEMORY,
   ) {
     this._signalManager = this.testBuilder.createSignalManager();
     this._networkManager = this.createNetworkManager(this.transport);
@@ -98,57 +79,49 @@ export class TestPeer {
   // TODO(burdon): Move to TestBuilder.
   createNetworkManager(transport: TransportKind): SwarmNetworkManager {
     let transportFactory: TransportFactory;
-    if (this.testBuilder.options.signalHosts) {
-      log.info(`using ${transport} transport with signal server.`);
-      switch (transport) {
-        case TransportKind.MEMORY:
-          throw new Error('Memory transport not supported with signal server.');
-        case TransportKind.TCP:
-          transportFactory = TcpTransportFactory;
-          break;
-        case TransportKind.WEB_RTC:
-          transportFactory = createRtcTransportFactory();
-          break;
-        case TransportKind.WEB_RTC_PROXY:
-          {
-            // Simulates bridge to shared worker.
-            const [proxyPort, servicePort] = createLinkedPorts();
-
-            this._proxy = createProtoRpcPeer({
-              port: proxyPort,
-              requested: {
-                BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-              },
-              noHandshake: true,
-              encodingOptions: {
-                preserveAny: true,
-              },
-            });
-
-            this._service = createProtoRpcPeer({
-              port: servicePort,
-              exposed: {
-                BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-              },
-              handlers: { BridgeService: new RtcTransportService() },
-              noHandshake: true,
-              encodingOptions: {
-                preserveAny: true,
-              },
-            });
-
-            transportFactory = new RtcTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
-          }
-          break;
-        default:
-          throw new Error(`Unsupported transport: ${transport}`);
-      }
-    } else {
-      if (transport !== TransportKind.MEMORY && transport !== TransportKind.TCP) {
-        log.warn(`specified transport ${transport} but no signalling configured, using memory transport instead`);
-      }
-      log.info(`using ${transport} transport without signal server.`);
-      transportFactory = MemoryTransportFactory;
+    switch (transport) {
+      case TransportKind.MEMORY:
+        transportFactory = MemoryTransportFactory;
+        break;
+      case TransportKind.TCP:
+        transportFactory = TcpTransportFactory;
+        break;
+      case TransportKind.WEB_RTC:
+        transportFactory = createRtcTransportFactory();
+        break;
+      case TransportKind.WEB_RTC_PROXY:
+        {
+          // Simulates bridge to shared worker.
+          const [proxyPort, servicePort] = createLinkedPorts();
+
+          this._proxy = createProtoRpcPeer({
+            port: proxyPort,
+            requested: {
+              BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
+            },
+            noHandshake: true,
+            encodingOptions: {
+              preserveAny: true,
+            },
+          });
+
+          this._service = createProtoRpcPeer({
+            port: servicePort,
+            exposed: {
+              BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
+            },
+            handlers: { BridgeService: new RtcTransportService() },
+            noHandshake: true,
+            encodingOptions: {
+              preserveAny: true,
+            },
+          });
+
+          transportFactory = new RtcTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
+        }
+        break;
+      default:
+        throw new Error(`Unsupported transport: ${transport}`);
     }
 
     return new SwarmNetworkManager({

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

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

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

@@ -7,7 +7,6 @@ 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';
@@ -38,7 +37,6 @@ export type RtcPeerChannelFactoryOptions = {
  * Contains WebRTC connection establishment logic.
  * When the first Transport is opened a connection is established and kept until all the transports are closed.
  */
-@trace.resource()
 export class RtcPeerConnection {
   // A peer who is not the initiator waits for another party to open a channel.
   private readonly _channelCreatedCallbacks = new Map<string, ChannelCreatedCallback>();
@@ -427,7 +425,6 @@ export class RtcPeerConnection {
     await this._options.sendSignal({ payload: { data } });
   }
 
-  @trace.info()
   protected get _connectionInfo() {
     const connectionInfo = this._connection && {
       connectionState: this._connection.connectionState,

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

@@ -5,7 +5,8 @@
 import { Duplex } from 'stream';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { Event as AsyncEvent, TestStream, Trigger, sleep } from '@dxos/async';
+import { Event as AsyncEvent, Trigger, sleep } from '@dxos/async';
+import { TestStream } from '@dxos/async/testing';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { schema } from '@dxos/protocols/proto';

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

@@ -4,7 +4,8 @@
 
 import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { TestStream, sleep } from '@dxos/async';
+import { sleep } from '@dxos/async';
+import { TestStream } from '@dxos/async/testing';
 import { PublicKey } from '@dxos/keys';
 
 import { type TransportOptions } from '../transport';