@decentnetwork/lan 0.1.179 → 0.1.181

package/dist/proxy/multi-exit-router.js

@@ -131,6 +131,15 @@ const STALL_MIN_BYTES = 16 * 1024; // delivered at least this = a healthy, real
 const STALL_DEAD_BYTES = 1024; // relayed LESS than this = the exit is genuinely dead (only THIS counts as a stall); a small-but-real request (playlist/key/keep-alive, 1-16 KB) is NEUTRAL, so it can't flap a healthy exit out of the pool
 const TRIP_AFTER_STALLS = 3; // consecutive DEAD tunnels before an exit is tripped out (hysteresis)
 const TRIP_AFTER_UPSTREAM_FAILS = 5; // consecutive non-200 CONNECT responses (exit's proxy broken, e.g. 502s everything) before tripping
+// Keep a proven exit in rotation only if its measured speed is at least this
+// fraction of the region's FASTEST proven exit. Below it (e.g. a 0.4 Mbps node
+// next to a 1.2 Mbps one) it's benched while a healthy exit exists, so heavy
+// streams don't stall on it. Unproven (unmeasured) exits are never benched.
+const SLOW_EXIT_FLOOR_FRACTION = 0.4;
+// Hosts that must NEVER be learned into an exit region — global services
+// reachable direct from anywhere; routing them through a china exit only 502s
+// and starves it. Guards against the recurring google→china mislearning.
+const NEVER_LEARN = /(^|\.)(google|gstatic|googleapis|googleusercontent|ggpht|gvt1|gvt2|youtube|ytimg|doubleclick|google-analytics|googletagmanager|firebase|crashlytics|facebook|fbcdn|instagram|twitter|twimg|cloudflare|cloudfront|akamai|akamaihd|amazonaws|apple|icloud|mzstatic|microsoft|windows|office|live|azureedge|github|githubusercontent|gitlab|cdn\.jsdelivr|unpkg|npmjs)\.(com|net|org|io|co|edu|dev|app)$/i;
 const TRIP_COOLDOWN_MS = 30_000; // how long a tripped exit stays excluded before it's retried
 // Measures peak short-window throughput of a byte stream. Feed it every chunk
 // length via add(); read peakBps at the end. Peak (not average) shrugs off TCP
@@ -252,6 +261,12 @@ export function startMultiExitRouter(opts) {
     function noteDirectBad(host) {
         if (!fallbackRegion || !regionHasExits(fallbackRegion))
             return;
+        // Never learn a clearly-GLOBAL host into an exit region. These are reachable
+        // direct from anywhere; a china exit only 502s them and wastes its bandwidth
+        // (the recurring google→china pollution). Belt-and-suspenders alongside the
+        // preconnect fix in suspiciousClose.
+        if (NEVER_LEARN.test(host))
+            return;
         if (learner.recordDirectBad(host))
             learner.learn(host, fallbackRegion);
     }
@@ -430,6 +445,20 @@ export function startMultiExitRouter(opts) {
         // Unproven exits still get overflow traffic once the proven ones fill up,
         // which measures them safely without risking the video.
         const unprovenBps = measuredVals.length > 0 ? measuredVals[0] : 800_000;
+        // Speed FLOOR: exclude exits that are dramatically slower than the best
+        // PROVEN exit. `score = speed/(active+1)` self-balances, but once the fast
+        // exit fills, a bandwidth-heavy stream (CCTV opens dozens of parallel
+        // segment tunnels) spills onto a degraded node (observed 0.4 Mbps vs 1.2
+        // Mbps) and stalls/rebuffers. Keep such nodes OUT of rotation while a
+        // healthy-speed exit exists; unproven exits (null speed) stay in so they
+        // still get measured, and we never empty the pool.
+        if (measuredVals.length >= 2) {
+            const best = measuredVals[measuredVals.length - 1];
+            const floor = best * SLOW_EXIT_FLOOR_FRACTION;
+            const fast = pool.filter((e) => e.speedEwma === null || e.speedEwma >= floor);
+            if (fast.length > 0)
+                pool = fast;
+        }
         const score = (e) => (e.speedEwma ?? unprovenBps) / (e.active + 1);
         return [...pool].sort((a, b) => score(b) - score(a) || a.served - b.served);
     }
@@ -650,7 +679,9 @@ export function startMultiExitRouter(opts) {
             // fallback region for next time.
             const t0 = Date.now();
             let down = 0;
+            let sentUp = head?.length ?? 0; // bytes the CLIENT sent upstream (ClientHello etc.)
             up.on("data", (d) => { down += d.length; });
+            client.on("data", (d) => { sentUp += d.length; });
             let closed = false;
             const done = () => {
                 if (closed)
@@ -659,7 +690,10 @@ export function startMultiExitRouter(opts) {
                 directActive = Math.max(0, directActive - 1);
                 if (local)
                     return;
-                if (RouteLearner.suspiciousClose(down, Date.now() - t0))
+                // A short close only counts as a geo-block if the client actually sent a
+                // request. A speculative preconnect (sentUp≈0) is ignored, so global
+                // hosts (google/gstatic) no longer get mislearned into a china exit.
+                if (RouteLearner.suspiciousClose(down, sentUp, Date.now() - t0))
                     noteDirectBad(h);
                 else
                     learner.recordDirectGood(h);

package/dist/proxy/route-learner.d.ts

@@ -8,6 +8,13 @@ export declare const MISCLASSIFIED_AFTER = 2;
  *  and is never counted. */
 export declare const SUSPICIOUS_MS = 3000;
 export declare const SUSPICIOUS_BYTES = 1024;
+/** Minimum bytes the CLIENT must have sent upstream before a short close counts
+ *  as a geo-block. A real GFW RST happens AFTER the client's TLS ClientHello
+ *  (>~100 bytes). A speculative preconnect that Chrome opens and closes WITHOUT
+ *  sending anything (0 bytes up) is NOT a block — counting it mislearned
+ *  google/gstatic/googleapis preconnects into the china exit, which then 502'd
+ *  and starved CCTV. */
+export declare const MIN_CLIENTHELLO_BYTES = 64;
 export declare class RouteLearner {
     #private;
     constructor(path?: string, log?: (msg: string) => void);
@@ -19,8 +26,11 @@ export declare class RouteLearner {
     recordDirectBad(host: string): boolean;
     /** A DIRECT tunnel to the host worked properly — clear its strike counter. */
     recordDirectGood(host: string): void;
-    /** Classify an established tunnel's ending: was it a suspicious early close? */
-    static suspiciousClose(bytesDown: number, lifetimeMs: number): boolean;
+    /** Classify an established tunnel's ending: was it a suspicious early close
+     *  (GFW-style RST after a real request)? `bytesUp` is what the CLIENT sent —
+     *  a connection that sent no ClientHello (a Chrome preconnect) is NOT a
+     *  geo-block and must never be learned. */
+    static suspiciousClose(bytesDown: number, bytesUp: number, lifetimeMs: number): boolean;
     learn(host: string, region: string): void;
     /** The learned region failed too (all exits down for this host) — forget it
      *  so the host can try DIRECT again next time. */

package/dist/proxy/route-learner.js

@@ -25,6 +25,13 @@ export const MISCLASSIFIED_AFTER = 2;
  *  and is never counted. */
 export const SUSPICIOUS_MS = 3000;
 export const SUSPICIOUS_BYTES = 1024;
+/** Minimum bytes the CLIENT must have sent upstream before a short close counts
+ *  as a geo-block. A real GFW RST happens AFTER the client's TLS ClientHello
+ *  (>~100 bytes). A speculative preconnect that Chrome opens and closes WITHOUT
+ *  sending anything (0 bytes up) is NOT a block — counting it mislearned
+ *  google/gstatic/googleapis preconnects into the china exit, which then 502'd
+ *  and starved CCTV. */
+export const MIN_CLIENTHELLO_BYTES = 64;
 /** Learned entries expire after this long (the internet moves; re-verify). */
 const LEARNED_TTL_MS = 30 * 24 * 3600 * 1000;
 /** Cap the failure-counter table so hostile traffic can't grow it unbounded. */
@@ -68,9 +75,12 @@ export class RouteLearner {
     recordDirectGood(host) {
         this.#fails.delete(host);
     }
-    /** Classify an established tunnel's ending: was it a suspicious early close? */
-    static suspiciousClose(bytesDown, lifetimeMs) {
-        return lifetimeMs < SUSPICIOUS_MS && bytesDown < SUSPICIOUS_BYTES;
+    /** Classify an established tunnel's ending: was it a suspicious early close
+     *  (GFW-style RST after a real request)? `bytesUp` is what the CLIENT sent —
+     *  a connection that sent no ClientHello (a Chrome preconnect) is NOT a
+     *  geo-block and must never be learned. */
+    static suspiciousClose(bytesDown, bytesUp, lifetimeMs) {
+        return bytesUp >= MIN_CLIENTHELLO_BYTES && lifetimeMs < SUSPICIOUS_MS && bytesDown < SUSPICIOUS_BYTES;
     }
     learn(host, region) {
         this.#learned.set(host, { region, at: Date.now() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.179",
+  "version": "0.1.181",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",