@serfab/cadre-core 1.9.0 → 1.10.0

package/src/membership-connection-gater.ts

@@ -36,9 +36,9 @@
  *    node has at least one UNEXPIRED, NOT-FULLY-CONSUMED open invitation
  *    outstanding (`StrandSolicitationService.hasOutstandingInvitation` — the
  *    tokens this process minted or published, plus any still-redeemable
- *    `FormationInvite` row the usage recorder can see). Merely registering the
- *    responder (`CadreNode.initializeStrandSolicitation`) does NOT suspend it,
- *    so an app that registers eagerly at node bring-up keeps a live gate. The
+ *    `FormationInvite` row the usage recorder can see). Registering the
+ *    responder does NOT suspend it, so every node — each registers one at
+ *    `CadreNode.start` — keeps a live gate. The
  *    handler's own trust decision remains the per-token check, which is
  *    strictly finer than this one: a peer admitted here can still be rejected
  *    in-protocol for a bogus or spent token.

package/src/peer-dial.ts

@@ -2,12 +2,15 @@
  * Dialing one peer from a list of candidate addresses, so that an address that
  * never answers cannot use up the time the others needed.
  *
- * libp2p's own multi-address dial (`libp2p.dial(addrs)`, libp2p 3.1.3's
- * `DialQueue.dialPeer`) tries the addresses ONE AT A TIME under ONE signal, with
- * no time limit per address. An address whose connection attempt is silently
- * dropped — a firewall, a subnet the dialer cannot route to, a virtual adapter's
- * address a Windows host reports alongside its real ones — holds that dial until
- * the whole signal expires, and every address sorted after it is never tried. It
+ * libp2p's own multi-address dial (`libp2p.dial(addrs)`, `DialQueue.dialPeer`)
+ * tries the addresses ONE AT A TIME under ONE signal. Its only per-address limit
+ * is the connection manager's `addressDialTimeout` (libp2p 3.3+), which cadre
+ * sizes for a cold relayed open through two admission decisions
+ * (`optimysticDialLimits` in `link-budget.ts`: 39 s at the default declared
+ * link). An address whose connection attempt is silently dropped — a firewall, a
+ * subnet the dialer cannot route to, a virtual adapter's address a Windows host
+ * reports alongside its real ones — holds that dial for that long or until the
+ * whole signal expires, and the addresses sorted after it get what is left. It
  * also sorts the list itself (`defaultAddressSorter`), putting loopback addresses
  * last, behind exactly the LAN addresses most likely to be dropped. A phone
  * borrowing a node from a cadre-host whose only reachable address was the
@@ -34,17 +37,17 @@ const log = debug('sereus:cadre:peer-dial');
 
 /**
  * Default limit on ONE address's dial attempt, in ms, at the DEFAULT declared link round trip:
- * `RELAYED_DIAL_ROUND_TRIPS` (4) x `DECLARED_LINK_ROUND_TRIP_MS` (3500 ms) plus the called
- * machine's `ADMISSION_DECISION_TIMEOUT_MS` (2000 ms) = 16 000 ms (`relayedDialBudgetMs`). It
- * was a fixed 8000 ms before it was derived.
+ * `RELAYED_DIAL_ROUND_TRIPS` (5) x `DECLARED_LINK_ROUND_TRIP_MS` (3500 ms) plus
+ * `DIAL_ADMISSION_DECISIONS` (2) x `ADMISSION_DECISION_TIMEOUT_MS` (2000 ms) = 21 500 ms
+ * (`relayedDialBudgetMs`). It was a fixed 8000 ms before it was derived.
  *
  * It has to cover the slowest address that should succeed, because an attempt
  * that needs longer fails the same way on every retry. That is a relayed dial on
  * a mobile link: connect to the relay (transport, encryption and multiplexer
  * handshakes, when no relay connection is open yet), open the circuit, then run
  * both handshakes again end to end through the relay. `link-budget.ts` is where that
- * reasoning is now a measured count instead of an estimate — four link round trips, measured at
- * 12 094 ms on a link whose round trip is 3 s — so the value MOVES with a host's
+ * reasoning is now a measured count instead of an estimate — five link round trips, measured at
+ * 15 113 ms on a link whose round trip is 3 s — so the value MOVES with a host's
  * `NetworkConfig.linkRoundTripMs` rather than pinning the band this node can reach to whatever
  * number was typed here. A direct dial that works is far quicker — a phone's WebSocket dial to
  * a node forwarded over `adb reverse` measured 1.6 s end to end.
@@ -200,9 +203,10 @@ export async function dialPeerAddrs(
  * one address and immediately dialing the next for the same peer therefore
  * joins the dying job, which rejects the new dial with `AbortError` before it
  * touches the network — the next address is never tried. Seen against libp2p
- * 3.1.3; `test/peer-dial.spec.ts` dials real nodes so an upgrade that changes it
- * shows up there. All of the queue's cleanup runs as microtasks, so it has
- * finished by the time a macrotask runs.
+ * 3.1.3, and the queue's join is unchanged in 3.3.11; `test/peer-dial.spec.ts`
+ * dials real nodes so an upgrade that changes it shows up there. All of the
+ * queue's cleanup runs as microtasks, so it has finished by the time a
+ * macrotask runs.
  */
 export async function tryAddrsInTurn<T>(
 	addrs: readonly Multiaddr[],

package/src/peer-join-backfill.ts

@@ -175,9 +175,9 @@ export interface PeerJoinBackfillConfig {
   /** Max blocks per push message. Default 64. */
   maxChunkBlocks?: number;
   /**
-   * Per-push dial deadline, ms. Default {@link peerJoinPushBudget}'s `dialTimeoutMs` — four link
-   * round trips at the declared link plus the called machine's admission decision, 16 000 ms as
-   * shipped. NOT a fixed number: a relayed dial
+   * Per-push dial deadline, ms. Default {@link peerJoinPushBudget}'s `dialTimeoutMs` — five link
+   * round trips at the declared link plus two admission decisions (a party-run relay's and the
+   * called machine's), 21 500 ms as shipped. NOT a fixed number: a relayed dial
    * costs a fixed number of exchanges, so a host on a slower link moves this (and every other
    * cadre dial budget) by declaring `NetworkConfig.linkRoundTripMs`. Naming it here still wins
    * over the derived value — `link-budget.ts` has the counts and the measurement.