@decentnetwork/peer 0.1.142 → 0.1.143

package/dist/peer.js

@@ -898,6 +898,41 @@ export class Peer {
         if (!this.#bootstrap) {
             throw new Error("Peer is not started");
         }
+        // A browser has no UDP and never will. The DHT bootstrap is a getnodes
+        // datagram waiting for a sendnodes reply, so there it can only ever time
+        // out — 30 seconds, then an error that reads like a network fault.
+        //
+        // That cost far more than a slow start. Everything after the await lives
+        // downstream of it: the self-announce (without which nobody can FIND this
+        // peer), the announce loop, and the express pull loop (without which
+        // offline messages are never collected). start() launches only the
+        // friend-connection loop, so a browser could talk to a friend who was
+        // already online and whose endpoint it had cached — and nothing else.
+        // That is exactly the half-working shape this looked like from outside.
+        //
+        // With tcpOnlyBootstrap we skip the datagram round trip and seed the node
+        // list from the configured bootstrap nodes, which is what the TCP relay
+        // path uses anyway. Announce and both loops then run normally.
+        if (this.#opts.tcpOnlyBootstrap) {
+            const seed = this.#opts.bootstrapNodes ?? [];
+            if (seed.length === 0) {
+                throw new Error("tcpOnlyBootstrap needs at least one bootstrap node to seed from");
+            }
+            this.#knownNodes = dedupeNodes([...seed]);
+            await this.#runSelfAnnounce(false, Date.now() + JOIN_ANNOUNCE_TIMEOUT_MS);
+            this.#ensureSelfAnnounceLoop();
+            this.#ensureDhtMaintenanceLoop();
+            this.#ensureFriendConnectionLoop();
+            this.#ensureExpressPullLoop();
+            void this.#doFriendConnections().catch((error) => {
+                this.#debugLog(`initial friend connection cycle failed: ${error.message}`);
+            });
+            const first = seed[0];
+            return {
+                respondingNode: first,
+                discoveredNodes: []
+            };
+        }
         const result = await this.#bootstrap.join();
         this.#recordNodeSuccess(`${result.respondingNode.host}:${result.respondingNode.port}`);
         const discovered = result.discoveredNodes.map((node) => ({

package/dist/types/peer.d.ts

@@ -93,6 +93,13 @@ export type PeerOptions = {
      *  and the field is omitted entirely (never sent as ""), so a friend keeps
      *  whatever picture they already have for us. */
     punkId?: number;
+    /** Skip the UDP DHT bootstrap and seed the node list from bootstrapNodes.
+     *
+     *  For hosts with no UDP — a browser above all. Without it joinNetwork()
+     *  waits 30s for a datagram that cannot arrive, and everything downstream
+     *  of it never runs: self-announce (so nobody can find this peer) and the
+     *  express pull loop (so offline messages are never collected). */
+    tcpOnlyBootstrap?: boolean;
     compatibilityMode?: CompatibilityMode;
     debugLabel?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.142",
+  "version": "0.1.143",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",