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

package/dist/lib/node/index.cjs

@@ -18,36 +18,360 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  Connection: () => import_chunk_4YAYC7WN.Connection,
-  ConnectionLimiter: () => import_chunk_4YAYC7WN.ConnectionLimiter,
-  ConnectionLog: () => import_chunk_4YAYC7WN.ConnectionLog,
-  ConnectionState: () => import_chunk_4YAYC7WN.ConnectionState,
-  EventType: () => import_chunk_4YAYC7WN.EventType,
-  FullyConnectedTopology: () => import_chunk_4YAYC7WN.FullyConnectedTopology,
-  LibDataChannelTransport: () => import_chunk_4YAYC7WN.LibDataChannelTransport,
-  MAX_CONCURRENT_INITIATING_CONNECTIONS: () => import_chunk_4YAYC7WN.MAX_CONCURRENT_INITIATING_CONNECTIONS,
-  MMSTTopology: () => import_chunk_4YAYC7WN.MMSTTopology,
-  MemoryTransport: () => import_chunk_4YAYC7WN.MemoryTransport,
-  MemoryTransportFactory: () => import_chunk_4YAYC7WN.MemoryTransportFactory,
-  SimplePeerTransport: () => import_chunk_4YAYC7WN.SimplePeerTransport,
-  SimplePeerTransportProxy: () => import_chunk_4YAYC7WN.SimplePeerTransportProxy,
-  SimplePeerTransportProxyFactory: () => import_chunk_4YAYC7WN.SimplePeerTransportProxyFactory,
-  SimplePeerTransportService: () => import_chunk_4YAYC7WN.SimplePeerTransportService,
-  StarTopology: () => import_chunk_4YAYC7WN.StarTopology,
-  Swarm: () => import_chunk_4YAYC7WN.Swarm,
-  SwarmMapper: () => import_chunk_4YAYC7WN.SwarmMapper,
-  SwarmMessenger: () => import_chunk_4YAYC7WN.SwarmMessenger,
-  SwarmNetworkManager: () => import_chunk_4YAYC7WN.SwarmNetworkManager,
-  TcpTransport: () => import_chunk_4YAYC7WN.TcpTransport,
-  TcpTransportFactory: () => import_chunk_4YAYC7WN.TcpTransportFactory,
-  TransportKind: () => import_chunk_4YAYC7WN.TransportKind,
-  createIceProvider: () => import_chunk_4YAYC7WN.createIceProvider,
-  createLibDataChannelTransportFactory: () => import_chunk_4YAYC7WN.createLibDataChannelTransportFactory,
-  createSimplePeerTransportFactory: () => import_chunk_4YAYC7WN.createSimplePeerTransportFactory,
-  createTeleportProtocolFactory: () => import_chunk_4YAYC7WN.createTeleportProtocolFactory
+  Connection: () => import_chunk_4TTFBX3M.Connection,
+  ConnectionLimiter: () => import_chunk_4TTFBX3M.ConnectionLimiter,
+  ConnectionLog: () => import_chunk_4TTFBX3M.ConnectionLog,
+  ConnectionState: () => import_chunk_4TTFBX3M.ConnectionState,
+  EventType: () => import_chunk_4TTFBX3M.EventType,
+  FullyConnectedTopology: () => import_chunk_4TTFBX3M.FullyConnectedTopology,
+  MAX_CONCURRENT_INITIATING_CONNECTIONS: () => import_chunk_4TTFBX3M.MAX_CONCURRENT_INITIATING_CONNECTIONS,
+  MMSTTopology: () => MMSTTopology,
+  MemoryTransport: () => import_chunk_4TTFBX3M.MemoryTransport,
+  MemoryTransportFactory: () => import_chunk_4TTFBX3M.MemoryTransportFactory,
+  RtcTransportProxy: () => import_chunk_4TTFBX3M.RtcTransportProxy,
+  RtcTransportProxyFactory: () => import_chunk_4TTFBX3M.RtcTransportProxyFactory,
+  RtcTransportService: () => import_chunk_4TTFBX3M.RtcTransportService,
+  StarTopology: () => StarTopology,
+  Swarm: () => import_chunk_4TTFBX3M.Swarm,
+  SwarmMapper: () => import_chunk_4TTFBX3M.SwarmMapper,
+  SwarmMessenger: () => import_chunk_4TTFBX3M.SwarmMessenger,
+  SwarmNetworkManager: () => import_chunk_4TTFBX3M.SwarmNetworkManager,
+  TransportKind: () => import_chunk_4TTFBX3M.TransportKind,
+  createIceProvider: () => createIceProvider,
+  createRtcTransportFactory: () => import_chunk_4TTFBX3M.createRtcTransportFactory,
+  createTeleportProtocolFactory: () => import_chunk_4TTFBX3M.createTeleportProtocolFactory
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_4YAYC7WN = require("./chunk-4YAYC7WN.cjs");
+var import_chunk_4TTFBX3M = require("./chunk-4TTFBX3M.cjs");
+var import_async = require("@dxos/async");
+var import_log = require("@dxos/log");
+var import_util = require("@dxos/util");
+var import_invariant = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var import_invariant2 = require("@dxos/invariant");
+var import_log3 = require("@dxos/log");
+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 }) => (0, import_async.asyncTimeout)(fetch(urls, {
+        method: "GET"
+      }), 1e4).then((response) => response.json()).catch((err) => {
+        const isDev = typeof window !== "undefined" && window.location.href.includes("localhost");
+        if (!isDev) {
+          import_log.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(import_util.isNotNullOrUndefined).map(({ iceServers }) => iceServers).flat();
+      return cachedIceServers;
+    }
+  };
+};
+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) {
+    (0, import_invariant.invariant)(!this._controller, "Already initialized", {
+      F: __dxlog_file2,
+      L: 49,
+      S: this,
+      A: [
+        "!this._controller",
+        "'Already initialized'"
+      ]
+    });
+    this._controller = controller;
+  }
+  update() {
+    (0, import_invariant.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) {
+      (0, import_log2.log)("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) {
+    (0, import_invariant.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;
+    (0, import_log2.log)(`Offer ${peer} accept=${accept}`, void 0, {
+      F: __dxlog_file2,
+      L: 73,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return accept;
+  }
+  async destroy() {
+  }
+  _runAlgorithm() {
+    (0, import_invariant.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) {
+      (0, import_log2.log)(`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);
+      (0, import_invariant.invariant)(sorted.length === 0, void 0, {
+        F: __dxlog_file2,
+        L: 92,
+        S: this,
+        A: [
+          "sorted.length === 0",
+          ""
+        ]
+      });
+      if (sorted.length > MAX_CHANGES_PER_UPDATE) {
+        (0, import_log2.log)(`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)) {
+          (0, import_log2.log)(`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 {
+        (0, import_log2.log)("rate limited disconnect", void 0, {
+          F: __dxlog_file2,
+          L: 105,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    } else if (connected.length < this._originateConnections) {
+      (0, import_log2.log)(`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) {
+        (0, import_log2.log)(`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)) {
+          (0, import_log2.log)(`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 {
+        (0, import_log2.log)("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()));
+  });
+  (0, import_log2.log)("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;
+};
+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) {
+    (0, import_invariant2.invariant)(!this._controller, "Already initialized.", {
+      F: __dxlog_file3,
+      L: 21,
+      S: this,
+      A: [
+        "!this._controller",
+        "'Already initialized.'"
+      ]
+    });
+    this._controller = controller;
+  }
+  update() {
+    (0, import_invariant2.invariant)(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)) {
+      (0, import_log3.log)("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)) {
+          (0, import_log3.log)("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)) {
+        (0, import_log3.log)("connecting to peer", {
+          peer
+        }, {
+          F: __dxlog_file3,
+          L: 43,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._controller.connect(peer);
+      }
+    }
+  }
+  async onOffer(peer) {
+    (0, import_invariant2.invariant)(this._controller, "Not initialized.", {
+      F: __dxlog_file3,
+      L: 50,
+      S: this,
+      A: [
+        "this._controller",
+        "'Not initialized.'"
+      ]
+    });
+    const { ownPeerId } = this._controller.getState();
+    (0, import_log3.log)("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() {
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Connection,
@@ -56,26 +380,21 @@ var import_chunk_4YAYC7WN = require("./chunk-4YAYC7WN.cjs");
   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.cjs.map

package/dist/lib/node/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["index.cjs"],
-  "sourcesContent": ["import {\n  Connection,\n  ConnectionLimiter,\n  ConnectionLog,\n  ConnectionState,\n  EventType,\n  FullyConnectedTopology,\n  LibDataChannelTransport,\n  MAX_CONCURRENT_INITIATING_CONNECTIONS,\n  MMSTTopology,\n  MemoryTransport,\n  MemoryTransportFactory,\n  SimplePeerTransport,\n  SimplePeerTransportProxy,\n  SimplePeerTransportProxyFactory,\n  SimplePeerTransportService,\n  StarTopology,\n  Swarm,\n  SwarmMapper,\n  SwarmMessenger,\n  SwarmNetworkManager,\n  TcpTransport,\n  TcpTransportFactory,\n  TransportKind,\n  createIceProvider,\n  createLibDataChannelTransportFactory,\n  createSimplePeerTransportFactory,\n  createTeleportProtocolFactory\n} from \"./chunk-4YAYC7WN.cjs\";\nexport {\n  Connection,\n  ConnectionLimiter,\n  ConnectionLog,\n  ConnectionState,\n  EventType,\n  FullyConnectedTopology,\n  LibDataChannelTransport,\n  MAX_CONCURRENT_INITIATING_CONNECTIONS,\n  MMSTTopology,\n  MemoryTransport,\n  MemoryTransportFactory,\n  SimplePeerTransport,\n  SimplePeerTransportProxy,\n  SimplePeerTransportProxyFactory,\n  SimplePeerTransportService,\n  StarTopology,\n  Swarm,\n  SwarmMapper,\n  SwarmMessenger,\n  SwarmNetworkManager,\n  TcpTransport,\n  TcpTransportFactory,\n  TransportKind,\n  createIceProvider,\n  createLibDataChannelTransportFactory,\n  createSimplePeerTransportFactory,\n  createTeleportProtocolFactory\n};\n//# sourceMappingURL=index.cjs.map\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BA4BO;",
-  "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": ["import_log", "import_invariant", "createIceProvider", "iceProviders", "cachedIceServers", "getIceServers", "Promise", "all", "map", "urls", "asyncTimeout", "fetch", "method", "then", "response", "json", "catch", "err", "isDev", "window", "location", "href", "includes", "log", "error", "filter", "isNotNullOrUndefined", "iceServers", "flat", "MIN_UPDATE_INTERVAL", "MAX_CHANGES_PER_UPDATE", "MMSTTopology", "constructor", "originateConnections", "maxPeers", "sampleSize", "_sampleCollected", "_lastAction", "Date", "_originateConnections", "_maxPeers", "_sampleSize", "init", "controller", "invariant", "_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", "StarTopology", "_centralPeer", "truncate", "equals", "isCentral", "isSelfCentral"]
 }