@decentnetwork/lan 0.1.180 → 0.1.182

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

@@ -136,6 +136,10 @@ const TRIP_AFTER_UPSTREAM_FAILS = 5; // consecutive non-200 CONNECT responses (e
 // 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
@@ -236,6 +240,20 @@ export function startMultiExitRouter(opts) {
     // route kept failing get auto-promoted into the fallback region (and
     // persisted). Explicit domain lists always win over learned entries.
     const learner = new RouteLearner(opts.learnedRoutesPath, log);
+    // Auto-purge on startup: drop any EXISTING learned entry for a global host
+    // (google/gstatic/…) that older builds mislearned into an exit. So a user just
+    // updating + restarting is self-healed — no manual learned-routes cleanup.
+    {
+        let purged = 0;
+        for (const { host } of learner.entries()) {
+            if (NEVER_LEARN.test(host)) {
+                learner.unlearn(host);
+                purged++;
+            }
+        }
+        if (purged > 0)
+            log(`purged ${purged} stale global-host route(s) mislearned into an exit`);
+    }
     const fallbackRegion = opts.fallbackRegion
         ?? regions.find((r) => opts.exits.some((e) => (e.region ?? "default") === r.name))?.name
         ?? null;
@@ -257,6 +275,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);
     }
@@ -669,7 +693,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)
@@ -678,7 +704,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.180",
+  "version": "0.1.182",
   "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",