@dxos/network-manager 0.6.13 → 0.6.14-main.2b6a0f3

package/dist/lib/browser/index.mjs

@@ -6,28 +6,358 @@ import {
   ConnectionState,
   EventType,
   FullyConnectedTopology,
-  LibDataChannelTransport,
   MAX_CONCURRENT_INITIATING_CONNECTIONS,
-  MMSTTopology,
   MemoryTransport,
   MemoryTransportFactory,
-  SimplePeerTransport,
-  SimplePeerTransportProxy,
-  SimplePeerTransportProxyFactory,
-  SimplePeerTransportService,
-  StarTopology,
+  RtcTransportProxy,
+  RtcTransportProxyFactory,
+  RtcTransportService,
   Swarm,
   SwarmMapper,
   SwarmMessenger,
   SwarmNetworkManager,
-  TcpTransport,
-  TcpTransportFactory,
   TransportKind,
-  createIceProvider,
-  createLibDataChannelTransportFactory,
-  createSimplePeerTransportFactory,
+  createRtcTransportFactory,
   createTeleportProtocolFactory
-} from "./chunk-XYSYUN63.mjs";
+} from "./chunk-V3IRGRVX.mjs";
+import {
+  Buffer
+} from "./chunk-GW3YM55A.mjs";
+
+// packages/core/mesh/network-manager/src/signal/ice.ts
+import { asyncTimeout } from "@dxos/async";
+import { log } from "@dxos/log";
+import { isNotNullOrUndefined } from "@dxos/util";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/ice.ts";
+var createIceProvider = (iceProviders) => {
+  let cachedIceServers;
+  return {
+    getIceServers: async () => {
+      if (cachedIceServers) {
+        return cachedIceServers;
+      }
+      cachedIceServers = (await Promise.all(iceProviders.map(({ urls }) => asyncTimeout(fetch(urls, {
+        method: "GET"
+      }), 1e4).then((response) => response.json()).catch((err) => {
+        const isDev = typeof window !== "undefined" && window.location.href.includes("localhost");
+        if (!isDev) {
+          log.error("Failed to fetch ICE servers from provider", {
+            urls,
+            err
+          }, {
+            F: __dxlog_file,
+            L: 30,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      })))).filter(isNotNullOrUndefined).map(({ iceServers }) => iceServers).flat();
+      return cachedIceServers;
+    }
+  };
+};
+
+// packages/core/mesh/network-manager/src/topology/mmst-topology.ts
+import { invariant } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/topology/mmst-topology.ts";
+var MIN_UPDATE_INTERVAL = 1e3 * 10;
+var MAX_CHANGES_PER_UPDATE = 1;
+var MMSTTopology = class {
+  constructor({ originateConnections = 2, maxPeers = 4, sampleSize = 10 } = {}) {
+    this._sampleCollected = false;
+    this._lastAction = /* @__PURE__ */ new Date(0);
+    this._originateConnections = originateConnections;
+    this._maxPeers = maxPeers;
+    this._sampleSize = sampleSize;
+  }
+  init(controller) {
+    invariant(!this._controller, "Already initialized", {
+      F: __dxlog_file2,
+      L: 49,
+      S: this,
+      A: [
+        "!this._controller",
+        "'Already initialized'"
+      ]
+    });
+    this._controller = controller;
+  }
+  update() {
+    invariant(this._controller, "Not initialized", {
+      F: __dxlog_file2,
+      L: 54,
+      S: this,
+      A: [
+        "this._controller",
+        "'Not initialized'"
+      ]
+    });
+    const { connected, candidates } = this._controller.getState();
+    if (this._sampleCollected || connected.length > this._maxPeers || candidates.length > 0) {
+      log2("Running the algorithm.", void 0, {
+        F: __dxlog_file2,
+        L: 58,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._sampleCollected = true;
+      this._runAlgorithm();
+    }
+  }
+  forceUpdate() {
+    this._lastAction = /* @__PURE__ */ new Date(0);
+    this.update();
+  }
+  async onOffer(peer) {
+    invariant(this._controller, "Not initialized", {
+      F: __dxlog_file2,
+      L: 70,
+      S: this,
+      A: [
+        "this._controller",
+        "'Not initialized'"
+      ]
+    });
+    const { connected } = this._controller.getState();
+    const accept = connected.length < this._maxPeers;
+    log2(`Offer ${peer} accept=${accept}`, void 0, {
+      F: __dxlog_file2,
+      L: 73,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return accept;
+  }
+  async destroy() {
+  }
+  _runAlgorithm() {
+    invariant(this._controller, "Not initialized", {
+      F: __dxlog_file2,
+      L: 82,
+      S: this,
+      A: [
+        "this._controller",
+        "'Not initialized'"
+      ]
+    });
+    const { connected, candidates, ownPeerId } = this._controller.getState();
+    if (connected.length > this._maxPeers) {
+      log2(`disconnect ${connected.length - this._maxPeers} peers.`, void 0, {
+        F: __dxlog_file2,
+        L: 88,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const sorted = sortByXorDistance(connected, ownPeerId).reverse().slice(0, this._maxPeers - connected.length);
+      invariant(sorted.length === 0, void 0, {
+        F: __dxlog_file2,
+        L: 92,
+        S: this,
+        A: [
+          "sorted.length === 0",
+          ""
+        ]
+      });
+      if (sorted.length > MAX_CHANGES_PER_UPDATE) {
+        log2(`want to disconnect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`, void 0, {
+          F: __dxlog_file2,
+          L: 95,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {
+        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {
+          log2(`Disconnect ${peer}.`, void 0, {
+            F: __dxlog_file2,
+            L: 100,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._controller.disconnect(peer);
+        }
+        this._lastAction = /* @__PURE__ */ new Date();
+      } else {
+        log2("rate limited disconnect", void 0, {
+          F: __dxlog_file2,
+          L: 105,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    } else if (connected.length < this._originateConnections) {
+      log2(`connect ${this._originateConnections - connected.length} peers.`, void 0, {
+        F: __dxlog_file2,
+        L: 109,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const sample = candidates.sort(() => Math.random() - 0.5).slice(0, this._sampleSize);
+      const sorted = sortByXorDistance(sample, ownPeerId).slice(0, this._originateConnections - connected.length);
+      if (sorted.length > MAX_CHANGES_PER_UPDATE) {
+        log2(`want to connect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`, void 0, {
+          F: __dxlog_file2,
+          L: 114,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {
+        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {
+          log2(`Connect ${peer}.`, void 0, {
+            F: __dxlog_file2,
+            L: 118,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._controller.connect(peer);
+        }
+        this._lastAction = /* @__PURE__ */ new Date();
+      } else {
+        log2("rate limited connect", void 0, {
+          F: __dxlog_file2,
+          L: 123,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+  }
+  toString() {
+    return "MMSTTopology";
+  }
+};
+var sortByXorDistance = (keys, reference) => {
+  const sorted = keys.sort((a, b) => {
+    return compareXor(distXor(a.asBuffer(), reference.asBuffer()), distXor(b.asBuffer(), reference.asBuffer()));
+  });
+  log2("Sorted keys", {
+    keys,
+    reference,
+    sorted
+  }, {
+    F: __dxlog_file2,
+    L: 137,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  return sorted;
+};
+var distXor = (a, b) => {
+  const maxLength = Math.max(a.length, b.length);
+  const result = Buffer.allocUnsafe(maxLength);
+  for (let i = 0; i < maxLength; i++) {
+    result[i] = (a[i] || 0) ^ (b[i] || 0);
+  }
+  return result;
+};
+var compareXor = (a, b) => {
+  const maxLength = Math.max(a.length, b.length);
+  for (let i = 0; i < maxLength; i++) {
+    if ((a[i] || 0) === (b[i] || 0)) {
+      continue;
+    }
+    return (a[i] || 0) < (b[i] || 0) ? -1 : 1;
+  }
+  return 0;
+};
+
+// packages/core/mesh/network-manager/src/topology/star-topology.ts
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log3 } from "@dxos/log";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/topology/star-topology.ts";
+var StarTopology = class {
+  constructor(_centralPeer) {
+    this._centralPeer = _centralPeer;
+  }
+  toString() {
+    return `StarTopology(${this._centralPeer.truncate()})`;
+  }
+  init(controller) {
+    invariant2(!this._controller, "Already initialized.", {
+      F: __dxlog_file3,
+      L: 21,
+      S: this,
+      A: [
+        "!this._controller",
+        "'Already initialized.'"
+      ]
+    });
+    this._controller = controller;
+  }
+  update() {
+    invariant2(this._controller, "Not initialized.", {
+      F: __dxlog_file3,
+      L: 26,
+      S: this,
+      A: [
+        "this._controller",
+        "'Not initialized.'"
+      ]
+    });
+    const { candidates, connected, ownPeerId } = this._controller.getState();
+    if (!ownPeerId.equals(this._centralPeer)) {
+      log3("leaf peer dropping all connections apart from central peer.", void 0, {
+        F: __dxlog_file3,
+        L: 29,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      for (const peer of connected) {
+        if (!peer.equals(this._centralPeer)) {
+          log3("dropping connection", {
+            peer
+          }, {
+            F: __dxlog_file3,
+            L: 34,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._controller.disconnect(peer);
+        }
+      }
+    }
+    for (const peer of candidates) {
+      if (peer.equals(this._centralPeer) || ownPeerId.equals(this._centralPeer)) {
+        log3("connecting to peer", {
+          peer
+        }, {
+          F: __dxlog_file3,
+          L: 43,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._controller.connect(peer);
+      }
+    }
+  }
+  async onOffer(peer) {
+    invariant2(this._controller, "Not initialized.", {
+      F: __dxlog_file3,
+      L: 50,
+      S: this,
+      A: [
+        "this._controller",
+        "'Not initialized.'"
+      ]
+    });
+    const { ownPeerId } = this._controller.getState();
+    log3("offer", {
+      peer,
+      isCentral: peer.equals(this._centralPeer),
+      isSelfCentral: ownPeerId.equals(this._centralPeer)
+    }, {
+      F: __dxlog_file3,
+      L: 52,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return ownPeerId.equals(this._centralPeer) || peer.equals(this._centralPeer);
+  }
+  async destroy() {
+  }
+};
 export {
   Connection,
   ConnectionLimiter,
@@ -35,26 +365,21 @@ export {
   ConnectionState,
   EventType,
   FullyConnectedTopology,
-  LibDataChannelTransport,
   MAX_CONCURRENT_INITIATING_CONNECTIONS,
   MMSTTopology,
   MemoryTransport,
   MemoryTransportFactory,
-  SimplePeerTransport,
-  SimplePeerTransportProxy,
-  SimplePeerTransportProxyFactory,
-  SimplePeerTransportService,
+  RtcTransportProxy,
+  RtcTransportProxyFactory,
+  RtcTransportService,
   StarTopology,
   Swarm,
   SwarmMapper,
   SwarmMessenger,
   SwarmNetworkManager,
-  TcpTransport,
-  TcpTransportFactory,
   TransportKind,
   createIceProvider,
-  createLibDataChannelTransportFactory,
-  createSimplePeerTransportFactory,
+  createRtcTransportFactory,
   createTeleportProtocolFactory
 };
 //# sourceMappingURL=index.mjs.map

package/dist/lib/browser/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
+  "sources": ["../../../src/signal/ice.ts", "../../../src/topology/mmst-topology.ts", "../../../src/topology/star-topology.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { asyncTimeout } from '@dxos/async';\nimport { log } from '@dxos/log';\nimport { type Runtime } from '@dxos/protocols/proto/dxos/config';\nimport { isNotNullOrUndefined } from '@dxos/util';\n\nexport interface IceProvider {\n  getIceServers: () => Promise<RTCIceServer[]>;\n}\n\nexport const createIceProvider = (iceProviders: Runtime.Services.IceProvider[]): IceProvider => {\n  let cachedIceServers: RTCIceServer[];\n  return {\n    getIceServers: async () => {\n      if (cachedIceServers) {\n        return cachedIceServers;\n      }\n\n      cachedIceServers = (\n        await Promise.all(\n          iceProviders.map(({ urls }) =>\n            asyncTimeout(fetch(urls, { method: 'GET' }), 10_000)\n              .then((response) => response.json())\n              .catch((err) => {\n                const isDev = typeof window !== 'undefined' && window.location.href.includes('localhost');\n                if (!isDev) {\n                  log.error('Failed to fetch ICE servers from provider', { urls, err });\n                }\n              }),\n          ),\n        )\n      )\n        .filter(isNotNullOrUndefined)\n        .map(({ iceServers }: { iceServers: RTCIceServer[] }) => iceServers)\n        .flat();\n\n      return cachedIceServers;\n    },\n  };\n};\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type PublicKey } from '@dxos/keys';\nimport { log } from '@dxos/log';\n\nimport { type SwarmController, type Topology } from './topology';\n\nconst MIN_UPDATE_INTERVAL = 1000 * 10;\nconst MAX_CHANGES_PER_UPDATE = 1;\n\nexport interface MMSTTopologyOptions {\n  /**\n   * Number of connections the peer will originate by itself.\n   */\n  originateConnections?: number;\n\n  /**\n   * Maximum number of connections allowed, all other connections will be dropped.\n   */\n  maxPeers?: number;\n\n  /**\n   * Size of random sample from which peer candidates are selected.\n   */\n  sampleSize?: number;\n}\n\nexport class MMSTTopology implements Topology {\n  private readonly _originateConnections: number;\n  private readonly _maxPeers: number;\n  private readonly _sampleSize: number;\n\n  private _controller?: SwarmController;\n\n  private _sampleCollected = false;\n\n  private _lastAction = new Date(0);\n\n  constructor({ originateConnections = 2, maxPeers = 4, sampleSize = 10 }: MMSTTopologyOptions = {}) {\n    this._originateConnections = originateConnections;\n    this._maxPeers = maxPeers;\n    this._sampleSize = sampleSize;\n  }\n\n  init(controller: SwarmController): void {\n    invariant(!this._controller, 'Already initialized');\n    this._controller = controller;\n  }\n\n  update(): void {\n    invariant(this._controller, 'Not initialized');\n    const { connected, candidates } = this._controller.getState();\n    // Run the algorithms if we have first candidates, ran it before, or have more connections than needed.\n    if (this._sampleCollected || connected.length > this._maxPeers || candidates.length > 0) {\n      log('Running the algorithm.');\n      this._sampleCollected = true;\n      this._runAlgorithm();\n    }\n  }\n\n  forceUpdate() {\n    this._lastAction = new Date(0);\n    this.update();\n  }\n\n  async onOffer(peer: PublicKey): Promise<boolean> {\n    invariant(this._controller, 'Not initialized');\n    const { connected } = this._controller.getState();\n    const accept = connected.length < this._maxPeers;\n    log(`Offer ${peer} accept=${accept}`);\n    return accept;\n  }\n\n  async destroy(): Promise<void> {\n    // Nothing to do.\n  }\n\n  private _runAlgorithm() {\n    invariant(this._controller, 'Not initialized');\n    const { connected, candidates, ownPeerId } = this._controller.getState();\n\n    // TODO(nf): does this rate limiting/flap dampening logic belong here or in the SwarmController?\n    if (connected.length > this._maxPeers) {\n      // Disconnect extra peers.\n      log(`disconnect ${connected.length - this._maxPeers} peers.`);\n      const sorted = sortByXorDistance(connected, ownPeerId)\n        .reverse()\n        .slice(0, this._maxPeers - connected.length);\n      invariant(sorted.length === 0);\n\n      if (sorted.length > MAX_CHANGES_PER_UPDATE) {\n        log(`want to disconnect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`);\n      }\n\n      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {\n        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {\n          log(`Disconnect ${peer}.`);\n          this._controller.disconnect(peer);\n        }\n        this._lastAction = new Date();\n      } else {\n        log('rate limited disconnect');\n      }\n    } else if (connected.length < this._originateConnections) {\n      // Connect new peers to reach desired quota.\n      log(`connect ${this._originateConnections - connected.length} peers.`);\n      const sample = candidates.sort(() => Math.random() - 0.5).slice(0, this._sampleSize);\n      const sorted = sortByXorDistance(sample, ownPeerId).slice(0, this._originateConnections - connected.length);\n\n      if (sorted.length > MAX_CHANGES_PER_UPDATE) {\n        log(`want to connect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`);\n      }\n      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {\n        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {\n          log(`Connect ${peer}.`);\n          this._controller.connect(peer);\n        }\n        this._lastAction = new Date();\n      } else {\n        log('rate limited connect');\n      }\n    }\n  }\n\n  toString() {\n    return 'MMSTTopology';\n  }\n}\n\nconst sortByXorDistance = (keys: PublicKey[], reference: PublicKey): PublicKey[] => {\n  const sorted = keys.sort((a, b) => {\n    return compareXor(distXor(a.asBuffer(), reference.asBuffer()), distXor(b.asBuffer(), reference.asBuffer()));\n  });\n  log('Sorted keys', { keys, reference, sorted });\n  return sorted;\n};\n\nconst distXor = (a: Buffer, b: Buffer) => {\n  const maxLength = Math.max(a.length, b.length);\n  const result = Buffer.allocUnsafe(maxLength);\n  for (let i = 0; i < maxLength; i++) {\n    result[i] = (a[i] || 0) ^ (b[i] || 0);\n  }\n  return result;\n};\n\nconst compareXor = (a: Buffer, b: Buffer) => {\n  const maxLength = Math.max(a.length, b.length);\n  for (let i = 0; i < maxLength; i++) {\n    if ((a[i] || 0) === (b[i] || 0)) {\n      continue;\n    }\n    return (a[i] || 0) < (b[i] || 0) ? -1 : 1;\n  }\n  return 0;\n};\n", "//\n// Copyright 2020 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type PublicKey } from '@dxos/keys';\nimport { log } from '@dxos/log';\n\nimport { type SwarmController, type Topology } from './topology';\n\nexport class StarTopology implements Topology {\n  private _controller?: SwarmController;\n\n  constructor(private readonly _centralPeer: PublicKey) {}\n\n  toString() {\n    return `StarTopology(${this._centralPeer.truncate()})`;\n  }\n\n  init(controller: SwarmController): void {\n    invariant(!this._controller, 'Already initialized.');\n    this._controller = controller;\n  }\n\n  update(): void {\n    invariant(this._controller, 'Not initialized.');\n    const { candidates, connected, ownPeerId } = this._controller.getState();\n    if (!ownPeerId.equals(this._centralPeer)) {\n      log('leaf peer dropping all connections apart from central peer.');\n\n      // Drop all connections other than central peer.\n      for (const peer of connected) {\n        if (!peer.equals(this._centralPeer)) {\n          log('dropping connection', { peer });\n          this._controller.disconnect(peer);\n        }\n      }\n    }\n\n    for (const peer of candidates) {\n      // Connect to central peer.\n      if (peer.equals(this._centralPeer) || ownPeerId.equals(this._centralPeer)) {\n        log('connecting to peer', { peer });\n        this._controller.connect(peer);\n      }\n    }\n  }\n\n  async onOffer(peer: PublicKey): Promise<boolean> {\n    invariant(this._controller, 'Not initialized.');\n    const { ownPeerId } = this._controller.getState();\n    log('offer', {\n      peer,\n      isCentral: peer.equals(this._centralPeer),\n      isSelfCentral: ownPeerId.equals(this._centralPeer),\n    });\n    return ownPeerId.equals(this._centralPeer) || peer.equals(this._centralPeer);\n  }\n\n  async destroy(): Promise<void> {\n    // Nothing to do.\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["asyncTimeout", "log", "isNotNullOrUndefined", "createIceProvider", "iceProviders", "cachedIceServers", "getIceServers", "Promise", "all", "map", "urls", "fetch", "method", "then", "response", "json", "catch", "err", "isDev", "window", "location", "href", "includes", "error", "filter", "iceServers", "flat", "invariant", "log", "MIN_UPDATE_INTERVAL", "MAX_CHANGES_PER_UPDATE", "MMSTTopology", "constructor", "originateConnections", "maxPeers", "sampleSize", "_sampleCollected", "_lastAction", "Date", "_originateConnections", "_maxPeers", "_sampleSize", "init", "controller", "_controller", "update", "connected", "candidates", "getState", "length", "_runAlgorithm", "forceUpdate", "onOffer", "peer", "accept", "destroy", "ownPeerId", "sorted", "sortByXorDistance", "reverse", "slice", "now", "getTime", "disconnect", "sample", "sort", "Math", "random", "connect", "toString", "keys", "reference", "a", "b", "compareXor", "distXor", "asBuffer", "maxLength", "max", "result", "Buffer", "allocUnsafe", "i", "invariant", "log", "StarTopology", "constructor", "_centralPeer", "toString", "truncate", "init", "controller", "_controller", "update", "candidates", "connected", "ownPeerId", "getState", "equals", "peer", "disconnect", "connect", "onOffer", "isCentral", "isSelfCentral", "destroy"]
 }