@skrillex1224/playwright-toolkit 2.1.166 → 2.1.167

package/dist/index.js

@@ -93,10 +93,10 @@ var createActorInfo = (info) => {
       xurl
     };
   };
-  const buildLandingUrl = ({ protocol: protocol2, domain: domain2, path: path2 }) => {
+  const buildLandingUrl = ({ protocol: protocol2, domain: domain2, path: path3 }) => {
     const safeProtocol = String(protocol2).trim();
     const safeDomain = normalizeDomain(domain2);
-    const safePath = normalizePath(path2);
+    const safePath = normalizePath(path3);
     return `${safeProtocol}://${safeDomain}${safePath}`;
   };
   const buildIcon = ({ key }) => {
@@ -104,13 +104,13 @@ var createActorInfo = (info) => {
   };
   const protocol = info.protocol || "https";
   const domain = normalizeDomain(info.domain);
-  const path = normalizePath(info.path);
+  const path2 = normalizePath(info.path);
   const share = normalizeShare2(info.share);
   return {
     ...info,
     protocol,
     domain,
-    path,
+    path: path2,
     share,
     get icon() {
       if (info.icon) return info.icon;
@@ -124,7 +124,7 @@ var createActorInfo = (info) => {
 var ActorInfo = {
   qbot: createActorInfo({
     key: "qbot",
-    name: "\u641C\u72D7QBot",
+    name: "QQ\u6D4F\u89C8\u5668AI\u641C",
     domain: "sogou.com",
     path: "/web",
     share: {
@@ -546,20 +546,306 @@ var CrawlerError = class _CrawlerError extends Error {
 // src/apify-kit.js
 import { serializeError as serializeError2 } from "serialize-error";
 
-// src/traffic-runtime.js
-var trafficMeter = null;
-var setTrafficMeter = (meter) => {
-  trafficMeter = meter || null;
+// src/proxy-meter-runtime.js
+import { spawn, spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var logger2 = createInternalLogger("ProxyMeter");
+var MAX_TOP_DOMAINS = 20;
+var FLUSH_INTERVAL_MS = 2e3;
+var DEFAULT_DEBUG_MAX_EVENTS = 400;
+var runtime = null;
+var cleanupInstalled = false;
+var toSafeInt = (value) => {
+  const num = Number(value);
+  if (!Number.isFinite(num) || num <= 0) return 0;
+  return Math.round(num);
 };
-var getTrafficSnapshot = () => {
-  if (!trafficMeter || typeof trafficMeter.snapshot !== "function") {
+var toSafeFloat = (value) => {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return 0;
+  return num;
+};
+var resolveScriptPath = () => {
+  const baseDir = typeof __dirname !== "undefined" ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+  return path.join(baseDir, "proxy-meter.js");
+};
+var pickFreePort = () => {
+  const script = [
+    'const net=require("net");',
+    "const server=net.createServer();",
+    'server.listen(0,"127.0.0.1",()=>{',
+    "const port=server.address().port;",
+    "server.close(()=>{console.log(port);});",
+    "});"
+  ].join("");
+  const result = spawnSync(process.execPath, ["-e", script], { encoding: "utf8" });
+  const port = Number(String(result.stdout || "").trim());
+  if (result.status === 0 && Number.isFinite(port) && port > 0) {
+    return port;
+  }
+  return 2e4 + Math.floor(Math.random() * 2e4);
+};
+var resolveLogDir = () => {
+  const storageDir = process.env.APIFY_STORAGE_DIR || process.env.APIFY_LOCAL_STORAGE_DIR || "";
+  if (storageDir) {
+    return path.join(storageDir, "proxy-meter");
+  }
+  return path.join(tmpdir(), "proxy-meter");
+};
+var ensureLogPath = () => {
+  const baseDir = resolveLogDir();
+  if (!existsSync(baseDir)) {
+    try {
+      mkdirSync(baseDir, { recursive: true });
+    } catch {
+    }
+  }
+  const runId = String(process.env.APIFY_ACTOR_RUN_ID || "").trim();
+  const suffix = `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+  const label = runId ? `proxy-meter-${runId}-${suffix}.json` : `proxy-meter-${process.pid}-${suffix}.json`;
+  return path.join(baseDir, label);
+};
+var readSnapshot = (logPath) => {
+  if (!logPath || !existsSync(logPath)) return null;
+  try {
+    const raw = readFileSync(logPath, "utf8");
+    if (!raw) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var normalizeDomainRows = (hosts) => {
+  const rows = [];
+  let requestCount = 0;
+  let connectCount = 0;
+  for (const [domain, stat] of Object.entries(hosts || {})) {
+    if (!stat || typeof stat !== "object") continue;
+    const inBytes = toSafeInt(stat.inBytes);
+    const outBytes = toSafeInt(stat.outBytes);
+    const requests = toSafeInt(stat.requests);
+    const connections = toSafeInt(stat.connections);
+    const totalBytes = inBytes + outBytes;
+    requestCount += requests;
+    connectCount += connections;
+    if (totalBytes <= 0 && requests <= 0 && connections <= 0) continue;
+    rows.push({
+      domain,
+      inBytes,
+      outBytes,
+      totalBytes,
+      requests,
+      connections
+    });
+  }
+  rows.sort((a, b) => {
+    if (b.totalBytes !== a.totalBytes) return b.totalBytes - a.totalBytes;
+    if (b.requests !== a.requests) return b.requests - a.requests;
+    return String(a.domain).localeCompare(String(b.domain));
+  });
+  return {
+    topDomains: rows.slice(0, MAX_TOP_DOMAINS),
+    requestCount,
+    connectCount
+  };
+};
+var normalizeDebugRows = (rows, type) => {
+  if (!Array.isArray(rows) || rows.length === 0) return void 0;
+  const normalized = rows.map((row) => {
+    if (!row || typeof row !== "object") return null;
+    return {
+      domain: String(row.domain || "").trim(),
+      status: String(row.status || "").trim(),
+      count: toSafeInt(row.count),
+      failedCount: toSafeInt(row.failedCount),
+      inBytes: toSafeInt(row.inBytes),
+      outBytes: toSafeInt(row.outBytes),
+      totalBytes: toSafeInt(row.totalBytes),
+      avgDurationMs: toSafeFloat(row.avgDurationMs),
+      reconnectCount: toSafeInt(row.reconnectCount),
+      largeResponseCount: toSafeInt(row.largeResponseCount),
+      failureRatePct: toSafeFloat(row.failureRatePct),
+      type
+    };
+  }).filter((row) => row && row.domain && row.count > 0);
+  return normalized.length > 0 ? normalized : void 0;
+};
+var normalizeDebugEvent = (row) => {
+  if (!row || typeof row !== "object") return null;
+  const host = String(row.host || "").trim();
+  if (!host) return null;
+  return {
+    ts: String(row.ts || ""),
+    runId: String(row.runId || ""),
+    channel: String(row.channel || ""),
+    host,
+    method: String(row.method || ""),
+    path: String(row.path || ""),
+    statusCode: toSafeInt(row.statusCode),
+    durationMs: toSafeInt(row.durationMs),
+    inBytes: toSafeInt(row.inBytes),
+    outBytes: toSafeInt(row.outBytes),
+    totalBytes: toSafeInt(row.totalBytes),
+    error: String(row.error || "")
+  };
+};
+var normalizeDebugSummary = (debug) => {
+  if (!debug || typeof debug !== "object" || !debug.summary || typeof debug.summary !== "object") {
     return null;
   }
-  return trafficMeter.snapshot();
+  const summary = debug.summary;
+  const domainStatus = normalizeDebugRows(summary.domainStatus, "domain_status");
+  const topFailureDomains = normalizeDebugRows(summary.topFailureDomains, "top_failure");
+  const topLargeDomains = normalizeDebugRows(summary.topLargeDomains, "top_large");
+  const topReconnectDomains = normalizeDebugRows(summary.topReconnectDomains, "top_reconnect");
+  return {
+    enabled: Boolean(debug.enabled),
+    sampledEvents: toSafeInt(debug.sampledEvents),
+    droppedEvents: toSafeInt(debug.droppedEvents),
+    totalEvents: toSafeInt(debug.totalEvents),
+    largeResponseThresholdBytes: toSafeInt(summary.largeResponseThresholdBytes),
+    requestCount: toSafeInt(summary.requestCount),
+    failedCount: toSafeInt(summary.failedCount),
+    failureRatePct: toSafeFloat(summary.failureRatePct),
+    largeResponseCount: toSafeInt(summary.largeResponseCount),
+    reconnectCount: toSafeInt(summary.reconnectCount),
+    domainStatus,
+    topFailureDomains,
+    topLargeDomains,
+    topReconnectDomains
+  };
+};
+var normalizeSnapshot = (raw) => {
+  if (!raw || typeof raw !== "object") return null;
+  const totalIn = toSafeInt(raw.totalInBytes);
+  const totalOut = toSafeInt(raw.totalOutBytes);
+  const domains = normalizeDomainRows(raw.hosts && typeof raw.hosts === "object" ? raw.hosts : {});
+  const normalized = {
+    meter: "proxy-meter-v1",
+    totalBytes: totalIn + totalOut,
+    uploadBytes: totalOut,
+    downloadBytes: totalIn,
+    requestCount: domains.requestCount,
+    connectCount: domains.connectCount,
+    topDomains: domains.topDomains
+  };
+  const debug = raw.debug && typeof raw.debug === "object" ? raw.debug : null;
+  const summary = normalizeDebugSummary(debug);
+  const events = Array.isArray(debug?.events) ? debug.events.map(normalizeDebugEvent).filter(Boolean) : [];
+  if (summary) {
+    normalized.trafficDebugSummary = summary;
+  }
+  if (events.length > 0) {
+    normalized.trafficDebugEvents = events;
+  }
+  const hasSignal = normalized.totalBytes > 0 || normalized.uploadBytes > 0 || normalized.downloadBytes > 0 || normalized.requestCount > 0 || normalized.connectCount > 0 || normalized.topDomains && normalized.topDomains.length > 0 || Boolean(summary) || events.length > 0;
+  if (!hasSignal) return null;
+  return normalized;
+};
+var registerCleanup = () => {
+  if (cleanupInstalled) return;
+  cleanupInstalled = true;
+  const shutdown = () => {
+    if (!runtime || !runtime.proc) return;
+    try {
+      runtime.proc.kill("SIGTERM");
+    } catch {
+    }
+  };
+  process.once("exit", shutdown);
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+};
+var startProxyMeter = (options = {}) => {
+  const upstreamUrl = String(options.proxyUrl || "").trim();
+  if (!upstreamUrl) return null;
+  if (runtime && runtime.proc) {
+    try {
+      runtime.proc.kill("SIGTERM");
+    } catch {
+    }
+    runtime = null;
+  }
+  const port = pickFreePort();
+  const logPath = ensureLogPath();
+  const scriptPath = resolveScriptPath();
+  const debugMode = Boolean(options.debugMode);
+  const debugMaxEvents = Math.max(10, toSafeInt(options.debugMaxEvents) || DEFAULT_DEBUG_MAX_EVENTS);
+  const env = {
+    ...process.env,
+    PROXY_METER_PORT: String(port),
+    PROXY_METER_LOG: logPath,
+    PROXY_METER_UPSTREAM: upstreamUrl,
+    PROXY_METER_FLUSH_MS: String(FLUSH_INTERVAL_MS),
+    PROXY_METER_DEBUG: debugMode ? "1" : "0",
+    PROXY_METER_DEBUG_MAX_EVENTS: String(debugMaxEvents)
+  };
+  const child = spawn(process.execPath, [scriptPath], {
+    env,
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+  child.once("exit", (code) => {
+    if (code && code !== 0) {
+      logger2.warn(`[proxy-meter] exited with code ${code}`);
+    }
+  });
+  runtime = {
+    proc: child,
+    port,
+    logPath,
+    startedAt: Date.now()
+  };
+  registerCleanup();
+  return { server: `http://127.0.0.1:${port}` };
+};
+var stopProxyMeter = async () => {
+  if (!runtime) return null;
+  const { proc, logPath } = runtime;
+  if (!proc || proc.killed) {
+    runtime = null;
+    return logPath || null;
+  }
+  await new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+      resolve();
+    }, 2e3);
+    proc.once("exit", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    try {
+      proc.kill("SIGTERM");
+    } catch {
+      resolve();
+    }
+  });
+  runtime = null;
+  return logPath || null;
+};
+var getProxyMeterSnapshot = async (options = {}) => {
+  if (!runtime) return null;
+  const finalize = Boolean(options.finalize);
+  const logPath = finalize ? await stopProxyMeter() : runtime.logPath;
+  const raw = readSnapshot(logPath);
+  const snapshot = normalizeSnapshot(raw);
+  if (finalize && logPath) {
+    try {
+      rmSync(logPath, { force: true });
+    } catch {
+    }
+  }
+  return snapshot;
 };
 
 // src/apify-kit.js
-var logger2 = createInternalLogger("ApifyKit");
+var logger3 = createInternalLogger("ApifyKit");
 async function createApifyKit() {
   let apify = null;
   try {
@@ -587,29 +873,29 @@ async function createApifyKit() {
       const { times: retryTimes = 0, mode: retryMode = "direct", before: beforeRetry } = retry;
       const executeAction = async (attemptNumber) => {
         const attemptLabel = attemptNumber > 0 ? ` (\u91CD\u8BD5 #${attemptNumber})` : "";
-        logger2.start(`[Step] ${step}${attemptLabel}`);
+        logger3.start(`[Step] ${step}${attemptLabel}`);
         try {
           const result = await actionFn();
-          logger2.success(`[Step] ${step}${attemptLabel}`);
+          logger3.success(`[Step] ${step}${attemptLabel}`);
           return { success: true, result };
         } catch (error) {
-          logger2.fail(`[Step] ${step}${attemptLabel}`, error);
+          logger3.fail(`[Step] ${step}${attemptLabel}`, error);
           return { success: false, error };
         }
       };
       const prepareForRetry = async (attemptNumber) => {
         if (typeof beforeRetry === "function") {
-          logger2.start(`[RetryStep] \u6267\u884C\u81EA\u5B9A\u4E49 before \u94A9\u5B50 (\u7B2C ${attemptNumber} \u6B21\u91CD\u8BD5)`);
+          logger3.start(`[RetryStep] \u6267\u884C\u81EA\u5B9A\u4E49 before \u94A9\u5B50 (\u7B2C ${attemptNumber} \u6B21\u91CD\u8BD5)`);
           await beforeRetry(page, attemptNumber);
-          logger2.success(`[RetryStep] before \u94A9\u5B50\u5B8C\u6210`);
+          logger3.success(`[RetryStep] before \u94A9\u5B50\u5B8C\u6210`);
         } else if (retryMode === "refresh") {
-          logger2.start(`[RetryStep] \u5237\u65B0\u9875\u9762 (\u7B2C ${attemptNumber} \u6B21\u91CD\u8BD5)`);
+          logger3.start(`[RetryStep] \u5237\u65B0\u9875\u9762 (\u7B2C ${attemptNumber} \u6B21\u91CD\u8BD5)`);
           await page.reload({ waitUntil: "commit" });
-          logger2.success(`[RetryStep] \u9875\u9762\u5237\u65B0\u5B8C\u6210`);
+          logger3.success(`[RetryStep] \u9875\u9762\u5237\u65B0\u5B8C\u6210`);
         } else {
-          logger2.start(`[RetryStep] \u7B49\u5F85 3 \u79D2 (\u7B2C ${attemptNumber} \u6B21\u91CD\u8BD5)`);
+          logger3.start(`[RetryStep] \u7B49\u5F85 3 \u79D2 (\u7B2C ${attemptNumber} \u6B21\u91CD\u8BD5)`);
           await new Promise((resolve) => setTimeout(resolve, 3e3));
-          logger2.success(`[RetryStep] \u7B49\u5F85\u5B8C\u6210`);
+          logger3.success(`[RetryStep] \u7B49\u5F85\u5B8C\u6210`);
         }
       };
       let lastResult = await executeAction(0);
@@ -617,11 +903,11 @@ async function createApifyKit() {
         return lastResult.result;
       }
       for (let attempt = 1; attempt <= retryTimes; attempt++) {
-        logger2.start(`[RetryStep] \u51C6\u5907\u7B2C ${attempt}/${retryTimes} \u6B21\u91CD\u8BD5: ${step}`);
+        logger3.start(`[RetryStep] \u51C6\u5907\u7B2C ${attempt}/${retryTimes} \u6B21\u91CD\u8BD5: ${step}`);
         try {
           await prepareForRetry(attempt);
         } catch (prepareError) {
-          logger2.warn(`[RetryStep] \u91CD\u8BD5\u51C6\u5907\u5931\u8D25: ${prepareError.message}`);
+          logger3.warn(`[RetryStep] \u91CD\u8BD5\u51C6\u5907\u5931\u8D25: ${prepareError.message}`);
           continue;
         }
         lastResult = await executeAction(attempt);
@@ -642,7 +928,7 @@ async function createApifyKit() {
             base64 = `data:image/jpeg;base64,${buffer.toString("base64")}`;
           }
         } catch (snapErr) {
-          logger2.warn(`\u622A\u56FE\u751F\u6210\u5931\u8D25: ${snapErr.message}`);
+          logger3.warn(`\u622A\u56FE\u751F\u6210\u5931\u8D25: ${snapErr.message}`);
         }
         await this.pushFailed(finalError, {
           step,
@@ -676,7 +962,7 @@ async function createApifyKit() {
      * @param {Object} data - 要推送的数据对象
      */
     async pushSuccess(data) {
-      const traffic = getTrafficSnapshot();
+      const traffic = await getProxyMeterSnapshot({ finalize: true });
       await Actor2.pushData({
         // 固定为0
         code: Code.Success,
@@ -685,7 +971,7 @@ async function createApifyKit() {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data
       });
-      logger2.success("pushSuccess", "Data pushed");
+      logger3.success("pushSuccess", "Data pushed");
     },
     /**
      * 推送失败数据的通用方法（私有方法，仅供runStep内部使用）
@@ -698,7 +984,7 @@ async function createApifyKit() {
       const isCrawlerError = CrawlerError.isCrawlerError(error);
       const code = isCrawlerError ? error.code : Code.UnknownError;
       const context = isCrawlerError ? error.context : {};
-      const traffic = getTrafficSnapshot();
+      const traffic = await getProxyMeterSnapshot({ finalize: true });
       await Actor2.pushData({
         // 如果是 CrawlerError，使用其 code，否则使用默认 Failed code
         code,
@@ -709,7 +995,7 @@ async function createApifyKit() {
         context,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger2.success("pushFailed", "Error data pushed");
+      logger3.success("pushFailed", "Error data pushed");
     }
   };
 }
@@ -725,7 +1011,7 @@ var ApifyKit = {
 };
 
 // src/internals/utils.js
-var logger3 = createInternalLogger("InternalUtils");
+var logger4 = createInternalLogger("InternalUtils");
 var parseCookies = (cookieString, domain) => {
   const cookies = [];
   const pairs = cookieString.split(";").map((c) => c.trim());
@@ -743,7 +1029,7 @@ var parseCookies = (cookieString, domain) => {
       cookies.push(cookie);
     }
   }
-  logger3.success("parseCookies", `parsed ${cookies.length} cookies`);
+  logger4.success("parseCookies", `parsed ${cookies.length} cookies`);
   return cookies;
 };
 
@@ -786,7 +1072,7 @@ var Utils = {
 };
 
 // src/anti-cheat.js
-var logger4 = createInternalLogger("AntiCheat");
+var logger5 = createInternalLogger("AntiCheat");
 var BASE_CONFIG = Object.freeze({
   locale: "zh-CN",
   acceptLanguage: "zh-CN,zh;q=0.9",
@@ -848,7 +1134,7 @@ var AntiCheat = {
 // src/humanize.js
 import delay from "delay";
 import { createCursor } from "ghost-cursor-playwright";
-var logger5 = createInternalLogger("Humanize");
+var logger6 = createInternalLogger("Humanize");
 var $CursorWeakMap = /* @__PURE__ */ new WeakMap();
 function $GetCursor(page) {
   const cursor = $CursorWeakMap.get(page);
@@ -876,13 +1162,13 @@ var Humanize = {
    */
   async initializeCursor(page) {
     if ($CursorWeakMap.has(page)) {
-      logger5.debug("initializeCursor: cursor already exists, skipping");
+      logger6.debug("initializeCursor: cursor already exists, skipping");
       return;
     }
-    logger5.start("initializeCursor", "creating cursor");
+    logger6.start("initializeCursor", "creating cursor");
     const cursor = await createCursor(page);
     $CursorWeakMap.set(page, cursor);
-    logger5.success("initializeCursor", "cursor initialized");
+    logger6.success("initializeCursor", "cursor initialized");
   },
   /**
    * 人类化鼠标移动 - 使用 ghost-cursor 移动到指定位置或元素
@@ -892,17 +1178,17 @@ var Humanize = {
    */
   async humanMove(page, target) {
     const cursor = $GetCursor(page);
-    logger5.start("humanMove", `target=${typeof target === "string" ? target : "element/coords"}`);
+    logger6.start("humanMove", `target=${typeof target === "string" ? target : "element/coords"}`);
     try {
       if (typeof target === "string") {
         const element = await page.$(target);
         if (!element) {
-          logger5.warn(`humanMove: \u5143\u7D20\u4E0D\u5B58\u5728 ${target}`);
+          logger6.warn(`humanMove: \u5143\u7D20\u4E0D\u5B58\u5728 ${target}`);
           return false;
         }
         const box = await element.boundingBox();
         if (!box) {
-          logger5.warn(`humanMove: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E ${target}`);
+          logger6.warn(`humanMove: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E ${target}`);
           return false;
         }
         const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.2;
@@ -918,10 +1204,10 @@ var Humanize = {
           await cursor.actions.move({ x, y });
         }
       }
-      logger5.success("humanMove");
+      logger6.success("humanMove");
       return true;
     } catch (error) {
-      logger5.fail("humanMove", error);
+      logger6.fail("humanMove", error);
       throw error;
     }
   },
@@ -945,12 +1231,12 @@ var Humanize = {
       maxDurationMs = maxSteps * 220 + 800
     } = options;
     const targetDesc = typeof target === "string" ? target : "ElementHandle";
-    logger5.start("humanScroll", `target=${targetDesc}`);
+    logger6.start("humanScroll", `target=${targetDesc}`);
     let element;
     if (typeof target === "string") {
       element = await page.$(target);
       if (!element) {
-        logger5.warn(`humanScroll | \u5143\u7D20\u672A\u627E\u5230: ${target}`);
+        logger6.warn(`humanScroll | \u5143\u7D20\u672A\u627E\u5230: ${target}`);
         return { element: null, didScroll: false };
       }
     } else {
@@ -1025,26 +1311,26 @@ var Humanize = {
     try {
       for (let i = 0; i < maxSteps; i++) {
         if (Date.now() - startTime > maxDurationMs) {
-          logger5.warn(`humanScroll | \u8D85\u65F6\u4FDD\u62A4\u89E6\u53D1 (${maxDurationMs}ms)`);
+          logger6.warn(`humanScroll | \u8D85\u65F6\u4FDD\u62A4\u89E6\u53D1 (${maxDurationMs}ms)`);
           return { element, didScroll };
         }
         const status = await checkVisibility();
         if (status.code === "VISIBLE") {
           if (status.isFixed) {
-            logger5.info("humanScroll | fixed \u5BB9\u5668\u5185\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
+            logger6.info("humanScroll | fixed \u5BB9\u5668\u5185\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
           } else {
-            logger5.debug("humanScroll | \u5143\u7D20\u53EF\u89C1\u4E14\u65E0\u906E\u6321");
+            logger6.debug("humanScroll | \u5143\u7D20\u53EF\u89C1\u4E14\u65E0\u906E\u6321");
           }
-          logger5.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
+          logger6.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
           return { element, didScroll };
         }
-        logger5.debug(`humanScroll | \u6B65\u9AA4 ${i + 1}/${maxSteps}: ${status.reason} ${status.direction ? `(${status.direction})` : ""}`);
+        logger6.debug(`humanScroll | \u6B65\u9AA4 ${i + 1}/${maxSteps}: ${status.reason} ${status.direction ? `(${status.direction})` : ""}`);
         if (status.code === "OBSTRUCTED" && status.obstruction) {
-          logger5.debug(`humanScroll | \u88AB\u4EE5\u4E0B\u5143\u7D20\u906E\u6321 <${status.obstruction.tag} id="${status.obstruction.id}">`);
+          logger6.debug(`humanScroll | \u88AB\u4EE5\u4E0B\u5143\u7D20\u906E\u6321 <${status.obstruction.tag} id="${status.obstruction.id}">`);
         }
         const scrollRect = await getScrollableRect();
         if (!scrollRect && status.isFixed) {
-          logger5.warn("humanScroll | fixed \u5BB9\u5668\u5185\u4E14\u65E0\u53EF\u6EDA\u52A8\u7956\u5148\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
+          logger6.warn("humanScroll | fixed \u5BB9\u5668\u5185\u4E14\u65E0\u53EF\u6EDA\u52A8\u7956\u5148\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
           return { element, didScroll };
         }
         const stepMin = scrollRect ? Math.min(minStep, Math.max(60, scrollRect.height * 0.4)) : minStep;
@@ -1080,10 +1366,10 @@ var Humanize = {
         didScroll = true;
         await delay(this.jitterMs(20 + Math.random() * 40, 0.2));
       }
-      logger5.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
+      logger6.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
       return { element, didScroll };
     } catch (error) {
-      logger5.fail("humanScroll", error);
+      logger6.fail("humanScroll", error);
       throw error;
     }
   },
@@ -1101,7 +1387,7 @@ var Humanize = {
     const cursor = $GetCursor(page);
     const { reactionDelay = 250, throwOnMissing = true, scrollIfNeeded = true, restore = false } = options;
     const targetDesc = target == null ? "Current Position" : typeof target === "string" ? target : "ElementHandle";
-    logger5.start("humanClick", `target=${targetDesc}`);
+    logger6.start("humanClick", `target=${targetDesc}`);
     const restoreOnce = async () => {
       if (restoreOnce.restored) return;
       restoreOnce.restored = true;
@@ -1110,14 +1396,14 @@ var Humanize = {
         await delay(this.jitterMs(1e3));
         await restoreOnce.do();
       } catch (restoreError) {
-        logger5.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
+        logger6.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
       }
     };
     try {
       if (target == null) {
         await delay(this.jitterMs(reactionDelay, 0.4));
         await cursor.actions.click();
-        logger5.success("humanClick", "Clicked current position");
+        logger6.success("humanClick", "Clicked current position");
         return true;
       }
       let element;
@@ -1127,7 +1413,7 @@ var Humanize = {
           if (throwOnMissing) {
             throw new Error(`\u627E\u4E0D\u5230\u5143\u7D20 ${target}`);
           }
-          logger5.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${target}`);
+          logger6.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${target}`);
           return false;
         }
       } else {
@@ -1143,7 +1429,7 @@ var Humanize = {
         if (throwOnMissing) {
           throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
         }
-        logger5.warn("humanClick: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E\uFF0C\u8DF3\u8FC7\u70B9\u51FB");
+        logger6.warn("humanClick: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E\uFF0C\u8DF3\u8FC7\u70B9\u51FB");
         return false;
       }
       const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.3;
@@ -1152,11 +1438,11 @@ var Humanize = {
       await delay(this.jitterMs(reactionDelay, 0.4));
       await cursor.actions.click();
       await restoreOnce();
-      logger5.success("humanClick");
+      logger6.success("humanClick");
       return true;
     } catch (error) {
       await restoreOnce();
-      logger5.fail("humanClick", error);
+      logger6.fail("humanClick", error);
       throw error;
     }
   },
@@ -1167,9 +1453,9 @@ var Humanize = {
    */
   async randomSleep(baseMs, jitterPercent = 0.3) {
     const ms = this.jitterMs(baseMs, jitterPercent);
-    logger5.start("randomSleep", `base=${baseMs}, actual=${ms}ms`);
+    logger6.start("randomSleep", `base=${baseMs}, actual=${ms}ms`);
     await delay(ms);
-    logger5.success("randomSleep");
+    logger6.success("randomSleep");
   },
   /**
    * 模拟人类"注视"或"阅读"行为：鼠标在页面上随机微动
@@ -1179,7 +1465,7 @@ var Humanize = {
   async simulateGaze(page, baseDurationMs = 2500) {
     const cursor = $GetCursor(page);
     const durationMs = this.jitterMs(baseDurationMs, 0.4);
-    logger5.start("simulateGaze", `duration=${durationMs}ms`);
+    logger6.start("simulateGaze", `duration=${durationMs}ms`);
     const startTime = Date.now();
     const viewportSize = page.viewportSize() || { width: 1920, height: 1080 };
     while (Date.now() - startTime < durationMs) {
@@ -1188,7 +1474,7 @@ var Humanize = {
       await cursor.actions.move({ x, y });
       await delay(this.jitterMs(600, 0.5));
     }
-    logger5.success("simulateGaze");
+    logger6.success("simulateGaze");
   },
   /**
    * 人类化输入 - 带节奏变化（快-慢-停顿-偶尔加速）
@@ -1201,7 +1487,7 @@ var Humanize = {
    * @param {number} [options.pauseBase=800] - 停顿时长基础值 (ms)，实际 ±50% 抖动
    */
   async humanType(page, selector, text, options = {}) {
-    logger5.start("humanType", `selector=${selector}, textLen=${text.length}`);
+    logger6.start("humanType", `selector=${selector}, textLen=${text.length}`);
     const {
       baseDelay = 180,
       pauseProbability = 0.08,
@@ -1225,13 +1511,13 @@ var Humanize = {
         await delay(charDelay);
         if (Math.random() < pauseProbability && i < text.length - 1) {
           const pauseTime = this.jitterMs(pauseBase, 0.5);
-          logger5.debug(`\u505C\u987F ${pauseTime}ms...`);
+          logger6.debug(`\u505C\u987F ${pauseTime}ms...`);
           await delay(pauseTime);
         }
       }
-      logger5.success("humanType");
+      logger6.success("humanType");
     } catch (error) {
-      logger5.fail("humanType", error);
+      logger6.fail("humanType", error);
       throw error;
     }
   },
@@ -1241,22 +1527,22 @@ var Humanize = {
    * @param {string} selector - 输入框选择器
    */
   async humanClear(page, selector) {
-    logger5.start("humanClear", `selector=${selector}`);
+    logger6.start("humanClear", `selector=${selector}`);
     try {
       const locator = page.locator(selector);
       await locator.click();
       await delay(this.jitterMs(200, 0.4));
       const currentValue = await locator.inputValue();
       if (!currentValue || currentValue.length === 0) {
-        logger5.success("humanClear", "already empty");
+        logger6.success("humanClear", "already empty");
         return;
       }
       await page.keyboard.press("Meta+A");
       await delay(this.jitterMs(100, 0.4));
       await page.keyboard.press("Backspace");
-      logger5.success("humanClear");
+      logger6.success("humanClear");
     } catch (error) {
-      logger5.fail("humanClear", error);
+      logger6.fail("humanClear", error);
       throw error;
     }
   },
@@ -1268,7 +1554,7 @@ var Humanize = {
   async warmUpBrowsing(page, baseDuration = 3500) {
     const cursor = $GetCursor(page);
     const durationMs = this.jitterMs(baseDuration, 0.4);
-    logger5.start("warmUpBrowsing", `duration=${durationMs}ms`);
+    logger6.start("warmUpBrowsing", `duration=${durationMs}ms`);
     const startTime = Date.now();
     const viewportSize = page.viewportSize() || { width: 1920, height: 1080 };
     try {
@@ -1287,9 +1573,9 @@ var Humanize = {
           await delay(this.jitterMs(800, 0.5));
         }
       }
-      logger5.success("warmUpBrowsing");
+      logger6.success("warmUpBrowsing");
     } catch (error) {
-      logger5.fail("warmUpBrowsing", error);
+      logger6.fail("warmUpBrowsing", error);
       throw error;
     }
   },
@@ -1303,7 +1589,7 @@ var Humanize = {
   async naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
     const steps = Math.max(3, baseSteps + Math.floor(Math.random() * 3) - 1);
     const actualDistance = this.jitterMs(distance, 0.15);
-    logger5.start("naturalScroll", `dir=${direction}, dist=${actualDistance}, steps=${steps}`);
+    logger6.start("naturalScroll", `dir=${direction}, dist=${actualDistance}, steps=${steps}`);
     const sign = direction === "down" ? 1 : -1;
     const stepDistance = actualDistance / steps;
     try {
@@ -1315,9 +1601,9 @@ var Humanize = {
         const baseDelay = 60 + i * 25;
         await delay(this.jitterMs(baseDelay, 0.3));
       }
-      logger5.success("naturalScroll");
+      logger6.success("naturalScroll");
     } catch (error) {
-      logger5.fail("naturalScroll", error);
+      logger6.fail("naturalScroll", error);
       throw error;
     }
   }
@@ -1366,690 +1652,6 @@ var findMatchedByPassRule = (rules = [], requestUrl = "") => {
     hostname
   };
 };
-var resolveRouteByProxy = ({
-  requestUrl = "",
-  enableProxy = false,
-  byPassRules = []
-}) => {
-  if (!enableProxy) {
-    return { route: "direct", matchedRule: null, hostname: "" };
-  }
-  const matched = findMatchedByPassRule(byPassRules, requestUrl);
-  if (!matched) {
-    return { route: "proxy", matchedRule: null, hostname: "" };
-  }
-  if (matched.rule) {
-    return { route: "direct", matchedRule: matched.rule, hostname: matched.hostname };
-  }
-  return { route: "proxy", matchedRule: null, hostname: matched.hostname };
-};
-
-// src/traffic-meter.js
-var logger6 = createInternalLogger("TrafficMeter");
-var encoder = new TextEncoder();
-var MAX_DOMAIN_BUCKETS = 160;
-var MAX_REASON_BUCKETS = 64;
-var MAX_TOP_ITEMS = 12;
-var MAX_HINT_ITEMS = 8;
-var UNKNOWN_DOMAIN = "(unknown)";
-var OTHER_DOMAINS = "(other-domains)";
-var OTHER_REASONS = "(other-reasons)";
-var STATIC_RESOURCE_TYPES = /* @__PURE__ */ new Set([
-  "script",
-  "stylesheet",
-  "image",
-  "font",
-  "media",
-  "manifest"
-]);
-var BACKEND_RESOURCE_TYPES = /* @__PURE__ */ new Set([
-  "xhr",
-  "fetch",
-  "websocket",
-  "eventsource"
-]);
-var toSafeNumber = (value) => {
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
-  return Math.round(value);
-};
-var byteLength = (value) => {
-  const text = String(value || "");
-  if (!text) return 0;
-  try {
-    return encoder.encode(text).length;
-  } catch {
-    return text.length;
-  }
-};
-var normalizeHeaderValue = (value) => {
-  if (Array.isArray(value)) return value.join(",");
-  if (value === null || value === void 0) return "";
-  return String(value);
-};
-var estimateRequestBytes = (request = {}) => {
-  const method = String(request.method || "GET");
-  const url = String(request.url || "");
-  let total = byteLength(`${method} ${url} HTTP/1.1\r
-`);
-  const headers = request.headers && typeof request.headers === "object" ? request.headers : {};
-  Object.entries(headers).forEach(([key, value]) => {
-    total += byteLength(`${key}: ${normalizeHeaderValue(value)}\r
-`);
-  });
-  total += 2;
-  if (typeof request.postData === "string" && request.postData) {
-    total += byteLength(request.postData);
-  }
-  return total;
-};
-var createTrafficState = () => ({
-  totalRequests: 0,
-  proxyRequests: 0,
-  directRequests: 0,
-  totalUploadBytes: 0,
-  proxyUploadBytes: 0,
-  directUploadBytes: 0,
-  totalDownloadBytes: 0,
-  proxyDownloadBytes: 0,
-  directDownloadBytes: 0,
-  totalFailedRequests: 0,
-  proxyFailedRequests: 0,
-  directFailedRequests: 0,
-  totalCanceledRequests: 0,
-  proxyCanceledRequests: 0,
-  directCanceledRequests: 0,
-  orphanDataReceivedBytes: 0,
-  orphanProxyDataReceivedBytes: 0,
-  orphanFinishDeltaBytes: 0,
-  orphanProxyFinishDeltaBytes: 0,
-  domainStats: /* @__PURE__ */ new Map(),
-  typeStats: /* @__PURE__ */ new Map(),
-  failedReasonStats: /* @__PURE__ */ new Map()
-});
-var ensureRoute = (route) => route === "proxy" ? "proxy" : "direct";
-var normalizeResourceType = (value) => {
-  const type = String(value || "").trim().toLowerCase();
-  if (!type) return "other";
-  if (type === "ws") return "websocket";
-  return type;
-};
-var parseHostname = (url = "") => {
-  try {
-    const hostname = new URL(String(url || "")).hostname.toLowerCase();
-    return hostname || "";
-  } catch {
-    return "";
-  }
-};
-var normalizeDomainKey = (domain = "") => {
-  const key = String(domain || "").trim().toLowerCase();
-  return key || UNKNOWN_DOMAIN;
-};
-var isStaticType = (resourceType = "") => STATIC_RESOURCE_TYPES.has(normalizeResourceType(resourceType));
-var isBackendType = (resourceType = "") => BACKEND_RESOURCE_TYPES.has(normalizeResourceType(resourceType));
-var createDomainBucket = (domain) => ({
-  domain,
-  requests: 0,
-  proxyRequests: 0,
-  directRequests: 0,
-  uploadBytes: 0,
-  downloadBytes: 0,
-  totalBytes: 0,
-  proxyBytes: 0,
-  directBytes: 0,
-  failedRequests: 0,
-  canceledRequests: 0,
-  staticBytes: 0,
-  backendBytes: 0
-});
-var createTypeBucket = (resourceType) => ({
-  resourceType,
-  requests: 0,
-  proxyRequests: 0,
-  directRequests: 0,
-  uploadBytes: 0,
-  downloadBytes: 0,
-  totalBytes: 0,
-  proxyBytes: 0,
-  directBytes: 0,
-  failedRequests: 0,
-  canceledRequests: 0
-});
-var createReasonBucket = (reason) => ({
-  reason,
-  count: 0,
-  canceledCount: 0,
-  proxyCount: 0,
-  directCount: 0
-});
-var formatBytes = (bytes = 0) => {
-  const value = toSafeNumber(bytes);
-  if (value <= 0) return "0B";
-  const units = ["B", "KB", "MB", "GB", "TB"];
-  let size = value;
-  let unit = 0;
-  while (size >= 1024 && unit < units.length - 1) {
-    size /= 1024;
-    unit += 1;
-  }
-  const precision = size >= 100 || unit === 0 ? 0 : 2;
-  return `${size.toFixed(precision)}${units[unit]}`;
-};
-var addRequests = (state, route, count = 1) => {
-  const c = toSafeNumber(count);
-  if (c <= 0) return;
-  const normalizedRoute = ensureRoute(route);
-  state.totalRequests += c;
-  if (normalizedRoute === "proxy") {
-    state.proxyRequests += c;
-    return;
-  }
-  state.directRequests += c;
-};
-var addUploadBytes = (state, route, bytes = 0) => {
-  const b = toSafeNumber(bytes);
-  if (b <= 0) return;
-  const normalizedRoute = ensureRoute(route);
-  state.totalUploadBytes += b;
-  if (normalizedRoute === "proxy") {
-    state.proxyUploadBytes += b;
-    return;
-  }
-  state.directUploadBytes += b;
-};
-var addDownloadBytes = (state, route, bytes = 0) => {
-  const b = toSafeNumber(bytes);
-  if (b <= 0) return;
-  const normalizedRoute = ensureRoute(route);
-  state.totalDownloadBytes += b;
-  if (normalizedRoute === "proxy") {
-    state.proxyDownloadBytes += b;
-    return;
-  }
-  state.directDownloadBytes += b;
-};
-var incrementBucketRequests = (bucket, route) => {
-  if (!bucket) return;
-  bucket.requests += 1;
-  if (ensureRoute(route) === "proxy") {
-    bucket.proxyRequests += 1;
-    return;
-  }
-  bucket.directRequests += 1;
-};
-var incrementBucketBytes = (bucket, route, bytes = 0, direction = "download", resourceType = "other") => {
-  if (!bucket) return;
-  const b = toSafeNumber(bytes);
-  if (b <= 0) return;
-  if (direction === "upload") {
-    bucket.uploadBytes += b;
-  } else {
-    bucket.downloadBytes += b;
-  }
-  bucket.totalBytes += b;
-  if (ensureRoute(route) === "proxy") {
-    bucket.proxyBytes += b;
-  } else {
-    bucket.directBytes += b;
-  }
-  if (bucket.domain !== void 0) {
-    if (isStaticType(resourceType)) {
-      bucket.staticBytes += b;
-    } else if (isBackendType(resourceType)) {
-      bucket.backendBytes += b;
-    }
-  }
-};
-var incrementBucketFailed = (bucket, canceled = false) => {
-  if (!bucket) return;
-  bucket.failedRequests += 1;
-  if (canceled) {
-    bucket.canceledRequests += 1;
-  }
-};
-var ensureReasonText = (reason) => {
-  const normalized = String(reason || "").trim().toLowerCase();
-  return normalized || "unknown";
-};
-var pickDomainBucket = (state, domain = "") => {
-  const domainKey = normalizeDomainKey(domain);
-  const knownBucket = state.domainStats.get(domainKey);
-  if (knownBucket) return knownBucket;
-  if (state.domainStats.size < MAX_DOMAIN_BUCKETS) {
-    const bucket2 = createDomainBucket(domainKey);
-    state.domainStats.set(domainKey, bucket2);
-    return bucket2;
-  }
-  const overflow = state.domainStats.get(OTHER_DOMAINS);
-  if (overflow) return overflow;
-  const bucket = createDomainBucket(OTHER_DOMAINS);
-  state.domainStats.set(OTHER_DOMAINS, bucket);
-  return bucket;
-};
-var pickTypeBucket = (state, resourceType = "other") => {
-  const typeKey = normalizeResourceType(resourceType);
-  const knownBucket = state.typeStats.get(typeKey);
-  if (knownBucket) return knownBucket;
-  const bucket = createTypeBucket(typeKey);
-  state.typeStats.set(typeKey, bucket);
-  return bucket;
-};
-var pickReasonBucket = (state, reason = "") => {
-  const reasonKey = ensureReasonText(reason);
-  const knownBucket = state.failedReasonStats.get(reasonKey);
-  if (knownBucket) return knownBucket;
-  if (state.failedReasonStats.size < MAX_REASON_BUCKETS) {
-    const bucket2 = createReasonBucket(reasonKey);
-    state.failedReasonStats.set(reasonKey, bucket2);
-    return bucket2;
-  }
-  const overflow = state.failedReasonStats.get(OTHER_REASONS);
-  if (overflow) return overflow;
-  const bucket = createReasonBucket(OTHER_REASONS);
-  state.failedReasonStats.set(OTHER_REASONS, bucket);
-  return bucket;
-};
-var addRequestProfile = (state, route, domain, resourceType, uploadBytes = 0) => {
-  const domainBucket = pickDomainBucket(state, domain);
-  const typeBucket = pickTypeBucket(state, resourceType);
-  incrementBucketRequests(domainBucket, route);
-  incrementBucketRequests(typeBucket, route);
-  incrementBucketBytes(domainBucket, route, uploadBytes, "upload", resourceType);
-  incrementBucketBytes(typeBucket, route, uploadBytes, "upload", resourceType);
-};
-var addUploadProfile = (state, route, domain, resourceType, uploadBytes = 0) => {
-  const domainBucket = pickDomainBucket(state, domain);
-  const typeBucket = pickTypeBucket(state, resourceType);
-  incrementBucketBytes(domainBucket, route, uploadBytes, "upload", resourceType);
-  incrementBucketBytes(typeBucket, route, uploadBytes, "upload", resourceType);
-};
-var addDownloadProfile = (state, route, domain, resourceType, downloadBytes = 0) => {
-  const domainBucket = pickDomainBucket(state, domain);
-  const typeBucket = pickTypeBucket(state, resourceType);
-  incrementBucketBytes(domainBucket, route, downloadBytes, "download", resourceType);
-  incrementBucketBytes(typeBucket, route, downloadBytes, "download", resourceType);
-};
-var addFailedProfile = (state, route, domain, resourceType, reason = "unknown", canceled = false) => {
-  const domainBucket = pickDomainBucket(state, domain);
-  const typeBucket = pickTypeBucket(state, resourceType);
-  const reasonBucket = pickReasonBucket(state, reason);
-  incrementBucketFailed(domainBucket, canceled);
-  incrementBucketFailed(typeBucket, canceled);
-  reasonBucket.count += 1;
-  if (ensureRoute(route) === "proxy") {
-    reasonBucket.proxyCount += 1;
-  } else {
-    reasonBucket.directCount += 1;
-  }
-  if (canceled) {
-    reasonBucket.canceledCount += 1;
-  }
-};
-var toRoundedRatio = (numerator, denominator) => {
-  if (denominator <= 0) return 0;
-  return Number((numerator / denominator * 100).toFixed(2));
-};
-var sortByBytesAndRequests = (left, right) => {
-  if (right.totalBytes !== left.totalBytes) return right.totalBytes - left.totalBytes;
-  if (right.requests !== left.requests) return right.requests - left.requests;
-  return String(left.domain || left.resourceType || "").localeCompare(String(right.domain || right.resourceType || ""));
-};
-var buildTopDomains = (state) => {
-  return Array.from(state.domainStats.values()).filter((item) => item && item.totalBytes > 0).sort(sortByBytesAndRequests).slice(0, MAX_TOP_ITEMS).map((item) => ({
-    domain: item.domain,
-    requests: item.requests,
-    proxyRequests: item.proxyRequests,
-    directRequests: item.directRequests,
-    uploadBytes: item.uploadBytes,
-    downloadBytes: item.downloadBytes,
-    totalBytes: item.totalBytes,
-    proxyBytes: item.proxyBytes,
-    directBytes: item.directBytes,
-    failedRequests: item.failedRequests,
-    canceledRequests: item.canceledRequests,
-    staticBytes: item.staticBytes,
-    backendBytes: item.backendBytes
-  }));
-};
-var buildTopResourceTypes = (state) => {
-  return Array.from(state.typeStats.values()).filter((item) => item && (item.totalBytes > 0 || item.requests > 0)).sort(sortByBytesAndRequests).slice(0, MAX_TOP_ITEMS).map((item) => ({
-    resourceType: item.resourceType,
-    requests: item.requests,
-    proxyRequests: item.proxyRequests,
-    directRequests: item.directRequests,
-    uploadBytes: item.uploadBytes,
-    downloadBytes: item.downloadBytes,
-    totalBytes: item.totalBytes,
-    proxyBytes: item.proxyBytes,
-    directBytes: item.directBytes,
-    failedRequests: item.failedRequests,
-    canceledRequests: item.canceledRequests
-  }));
-};
-var buildFailedReasons = (state) => {
-  return Array.from(state.failedReasonStats.values()).filter((item) => item && item.count > 0).sort((left, right) => {
-    if (right.count !== left.count) return right.count - left.count;
-    return String(left.reason || "").localeCompare(String(right.reason || ""));
-  }).slice(0, MAX_TOP_ITEMS).map((item) => ({
-    reason: item.reason,
-    count: item.count,
-    canceledCount: item.canceledCount,
-    proxyCount: item.proxyCount,
-    directCount: item.directCount
-  }));
-};
-var buildProxyByPassHints = (state) => {
-  return Array.from(state.domainStats.values()).filter((item) => item && item.domain !== UNKNOWN_DOMAIN && item.domain !== OTHER_DOMAINS).filter((item) => item.proxyBytes >= 128 * 1024 && item.proxyRequests >= 2 && item.totalBytes > 0).filter((item) => item.staticBytes > item.backendBytes && toRoundedRatio(item.staticBytes, item.totalBytes) >= 80).sort((left, right) => {
-    if (right.proxyBytes !== left.proxyBytes) return right.proxyBytes - left.proxyBytes;
-    return right.proxyRequests - left.proxyRequests;
-  }).slice(0, MAX_HINT_ITEMS).map((item) => ({
-    domain: item.domain,
-    proxyBytes: item.proxyBytes,
-    proxyRequests: item.proxyRequests,
-    totalBytes: item.totalBytes,
-    staticBytes: item.staticBytes,
-    backendBytes: item.backendBytes,
-    staticRatioPct: toRoundedRatio(item.staticBytes, item.totalBytes)
-  }));
-};
-var createTrafficMeter = ({
-  enableProxy = false,
-  byPassRules = [],
-  debugMode = false
-} = {}) => {
-  const state = createTrafficState();
-  const requestMap = /* @__PURE__ */ new Map();
-  const orphanReceivedMap = /* @__PURE__ */ new Map();
-  const wsRouteMap = /* @__PURE__ */ new Map();
-  const attachedPages = /* @__PURE__ */ new WeakSet();
-  const attachedContexts = /* @__PURE__ */ new WeakSet();
-  const resolveRoute = (url = "") => {
-    return resolveRouteByProxy({
-      requestUrl: url,
-      enableProxy,
-      byPassRules
-    }).route;
-  };
-  const fallbackRoute = () => enableProxy ? "proxy" : "direct";
-  const debugLog = (message) => {
-    if (!debugMode) return;
-    logger6.info(`[\u9010\u8BF7\u6C42\u8C03\u8BD5] ${message}`);
-  };
-  const addFailed = (route, canceled = false) => {
-    const normalizedRoute = ensureRoute(route);
-    state.totalFailedRequests += 1;
-    if (normalizedRoute === "proxy") {
-      state.proxyFailedRequests += 1;
-    } else {
-      state.directFailedRequests += 1;
-    }
-    if (!canceled) return;
-    state.totalCanceledRequests += 1;
-    if (normalizedRoute === "proxy") {
-      state.proxyCanceledRequests += 1;
-    } else {
-      state.directCanceledRequests += 1;
-    }
-  };
-  const finalizeByEncodedLength = (requestId, encodedDataLength, source = "finished") => {
-    const safeRequestId = String(requestId || "");
-    if (!safeRequestId) return;
-    const requestState = requestMap.get(safeRequestId);
-    const orphanReceived = toSafeNumber(orphanReceivedMap.get(safeRequestId));
-    const encoded = toSafeNumber(encodedDataLength);
-    if (requestState) {
-      const routed2 = ensureRoute(requestState.route);
-      const downloaded = toSafeNumber(requestState.downloadBytes);
-      const delta2 = Math.max(0, encoded - downloaded);
-      if (delta2 > 0) {
-        addDownloadBytes(state, routed2, delta2);
-        addDownloadProfile(state, routed2, requestState.domain, requestState.resourceType, delta2);
-        requestState.downloadBytes = downloaded + delta2;
-      }
-      const uploadBytes = toSafeNumber(requestState.uploadBytes);
-      const total = uploadBytes + toSafeNumber(requestState.downloadBytes);
-      debugLog(
-        `final id=${safeRequestId} source=${source} status=ok route=${routed2} type=${requestState.resourceType || "other"} upload=${formatBytes(uploadBytes)} (${uploadBytes}) download=${formatBytes(requestState.downloadBytes)} (${requestState.downloadBytes}) total=${formatBytes(total)} (${total}) url=${requestState.url || "-"}`
-      );
-      requestMap.delete(safeRequestId);
-      orphanReceivedMap.delete(safeRequestId);
-      return;
-    }
-    const routed = fallbackRoute();
-    const delta = Math.max(0, encoded - orphanReceived);
-    if (delta > 0) {
-      addDownloadBytes(state, routed, delta);
-      addDownloadProfile(state, routed, UNKNOWN_DOMAIN, "other", delta);
-    }
-    state.orphanFinishDeltaBytes += delta;
-    if (routed === "proxy") {
-      state.orphanProxyFinishDeltaBytes += delta;
-    }
-    debugLog(
-      `final id=${safeRequestId} source=${source} status=orphan route=${routed} encoded=${formatBytes(encoded)} (${encoded}) delta=${formatBytes(delta)} (${delta})`
-    );
-    orphanReceivedMap.delete(safeRequestId);
-  };
-  const recordRequest = (params = {}) => {
-    const requestId = String(params.requestId || "");
-    const request = params.request && typeof params.request === "object" ? params.request : {};
-    const url = String(request.url || "");
-    const route = resolveRoute(url);
-    const resourceType = normalizeResourceType(params.type || request.type || "other");
-    const domain = normalizeDomainKey(parseHostname(url));
-    if (requestId && requestMap.has(requestId)) {
-      const redirectResponse = params.redirectResponse && typeof params.redirectResponse === "object" ? params.redirectResponse : null;
-      finalizeByEncodedLength(
-        requestId,
-        redirectResponse ? redirectResponse.encodedDataLength : 0,
-        "redirect"
-      );
-    }
-    addRequests(state, route, 1);
-    const uploadBytes = estimateRequestBytes(request);
-    addUploadBytes(state, route, uploadBytes);
-    addRequestProfile(state, route, domain, resourceType, uploadBytes);
-    if (requestId) {
-      requestMap.set(requestId, {
-        route: ensureRoute(route),
-        resourceType,
-        domain,
-        url,
-        uploadBytes,
-        downloadBytes: 0
-      });
-    }
-    debugLog(
-      `request id=${requestId || "-"} route=${route} type=${resourceType} upload=${formatBytes(uploadBytes)} (${uploadBytes}) method=${String(request.method || "GET")} url=${url || "-"}`
-    );
-  };
-  const recordDataReceived = (params = {}) => {
-    const requestId = String(params.requestId || "");
-    const bytes = toSafeNumber(params.encodedDataLength);
-    if (bytes <= 0) return;
-    if (!requestId) {
-      const routed2 = fallbackRoute();
-      addDownloadBytes(state, routed2, bytes);
-      addDownloadProfile(state, routed2, UNKNOWN_DOMAIN, "other", bytes);
-      state.orphanDataReceivedBytes += bytes;
-      if (routed2 === "proxy") {
-        state.orphanProxyDataReceivedBytes += bytes;
-      }
-      return;
-    }
-    const requestState = requestMap.get(requestId);
-    if (requestState) {
-      requestState.downloadBytes = toSafeNumber(requestState.downloadBytes) + bytes;
-      addDownloadBytes(state, requestState.route, bytes);
-      addDownloadProfile(state, requestState.route, requestState.domain, requestState.resourceType, bytes);
-      return;
-    }
-    const prev = toSafeNumber(orphanReceivedMap.get(requestId));
-    orphanReceivedMap.set(requestId, prev + bytes);
-    const routed = fallbackRoute();
-    addDownloadBytes(state, routed, bytes);
-    addDownloadProfile(state, routed, UNKNOWN_DOMAIN, "other", bytes);
-    state.orphanDataReceivedBytes += bytes;
-    if (routed === "proxy") {
-      state.orphanProxyDataReceivedBytes += bytes;
-    }
-  };
-  const recordLoadingFinished = (params = {}) => {
-    finalizeByEncodedLength(params.requestId, params.encodedDataLength, "loadingFinished");
-  };
-  const recordRequestFailed = (params = {}) => {
-    const requestId = String(params.requestId || "");
-    const requestState = requestId ? requestMap.get(requestId) : null;
-    const canceled = Boolean(params.canceled);
-    const reason = ensureReasonText(params.errorText);
-    const routed = ensureRoute(requestState?.route || fallbackRoute());
-    const resourceType = normalizeResourceType(requestState?.resourceType || "other");
-    const domain = normalizeDomainKey(requestState?.domain || "");
-    if (requestState) {
-      addFailed(routed, canceled);
-      addFailedProfile(state, routed, domain, resourceType, reason, canceled);
-      const uploadBytes = toSafeNumber(requestState.uploadBytes);
-      const downloadBytes = toSafeNumber(requestState.downloadBytes);
-      const totalBytes = uploadBytes + downloadBytes;
-      debugLog(
-        `final id=${requestId || "-"} source=loadingFailed status=failed route=${routed} type=${requestState.resourceType || "other"} upload=${formatBytes(uploadBytes)} (${uploadBytes}) download=${formatBytes(downloadBytes)} (${downloadBytes}) total=${formatBytes(totalBytes)} (${totalBytes}) canceled=${canceled} reason=${reason} url=${requestState.url || "-"}`
-      );
-    } else {
-      const orphanDownload = toSafeNumber(orphanReceivedMap.get(requestId));
-      addFailed(routed, canceled);
-      addFailedProfile(state, routed, UNKNOWN_DOMAIN, "other", reason, canceled);
-      debugLog(
-        `final id=${requestId || "-"} source=loadingFailed status=orphan-failed route=${routed} upload=0B (0) download=${formatBytes(orphanDownload)} (${orphanDownload}) total=${formatBytes(orphanDownload)} (${orphanDownload}) canceled=${canceled} reason=${reason} url=-`
-      );
-    }
-    if (requestId) {
-      requestMap.delete(requestId);
-      orphanReceivedMap.delete(requestId);
-    }
-  };
-  const bindWebSocketRoute = (params = {}) => {
-    const requestId = String(params.requestId || "");
-    if (!requestId) return;
-    const url = String(params.url || "");
-    const route = resolveRoute(url);
-    wsRouteMap.set(requestId, { route, url, domain: normalizeDomainKey(parseHostname(url)) });
-  };
-  const clearWebSocketRoute = (params = {}) => {
-    const requestId = String(params.requestId || "");
-    if (!requestId) return;
-    wsRouteMap.delete(requestId);
-  };
-  const getWebSocketMeta = (requestId = "") => {
-    if (!requestId) return { route: fallbackRoute(), url: "", domain: UNKNOWN_DOMAIN };
-    const meta = wsRouteMap.get(requestId);
-    if (!meta || typeof meta !== "object") {
-      return { route: fallbackRoute(), url: "", domain: UNKNOWN_DOMAIN };
-    }
-    return {
-      route: ensureRoute(meta.route),
-      url: String(meta.url || ""),
-      domain: normalizeDomainKey(meta.domain)
-    };
-  };
-  const recordWebSocketFrameSent = (params = {}) => {
-    const requestId = String(params.requestId || "");
-    const { route, url, domain } = getWebSocketMeta(requestId);
-    const payload = params.response && typeof params.response === "object" ? params.response.payloadData : "";
-    const bytes = byteLength(payload || "");
-    addUploadBytes(state, route, bytes);
-    addUploadProfile(state, route, domain, "websocket", bytes);
-    debugLog(`ws-send id=${requestId || "-"} route=${route} bytes=${formatBytes(bytes)} (${bytes}) url=${url || "-"}`);
-  };
-  const recordWebSocketFrameReceived = (params = {}) => {
-    const requestId = String(params.requestId || "");
-    const { route, url, domain } = getWebSocketMeta(requestId);
-    const payload = params.response && typeof params.response === "object" ? params.response.payloadData : "";
-    const bytes = byteLength(payload || "");
-    addDownloadBytes(state, route, bytes);
-    addDownloadProfile(state, route, domain, "websocket", bytes);
-    debugLog(`ws-recv id=${requestId || "-"} route=${route} bytes=${formatBytes(bytes)} (${bytes}) url=${url || "-"}`);
-  };
-  const attachPage = async (page) => {
-    if (!page || typeof page.context !== "function") return;
-    if (attachedPages.has(page)) return;
-    attachedPages.add(page);
-    try {
-      const context = page.context();
-      if (!context || typeof context.newCDPSession !== "function") {
-        return;
-      }
-      if (!attachedContexts.has(context) && typeof context.on === "function") {
-        attachedContexts.add(context);
-        context.on("page", (nextPage) => {
-          if (!nextPage) return;
-          attachPage(nextPage).catch((error) => {
-            logger6.warn(`\u5B50\u9875\u9762 CDP \u76D1\u542C\u6CE8\u518C\u5931\u8D25: ${error?.message || error}`);
-          });
-        });
-      }
-      const session = await context.newCDPSession(page);
-      await session.send("Network.enable");
-      session.on("Network.requestWillBeSent", recordRequest);
-      session.on("Network.dataReceived", recordDataReceived);
-      session.on("Network.loadingFinished", recordLoadingFinished);
-      session.on("Network.loadingFailed", recordRequestFailed);
-      session.on("Network.webSocketCreated", bindWebSocketRoute);
-      session.on("Network.webSocketClosed", clearWebSocketRoute);
-      session.on("Network.webSocketFrameSent", recordWebSocketFrameSent);
-      session.on("Network.webSocketFrameReceived", recordWebSocketFrameReceived);
-      debugLog("CDP \u76D1\u542C\u5DF2\u6CE8\u518C");
-    } catch (error) {
-      logger6.warn(`CDP \u76D1\u542C\u6CE8\u518C\u5931\u8D25: ${error?.message || error}`);
-    }
-  };
-  const snapshot = () => {
-    const totalBytes = state.totalUploadBytes + state.totalDownloadBytes;
-    const proxyBytes = state.proxyUploadBytes + state.proxyDownloadBytes;
-    const directBytes = state.directUploadBytes + state.directDownloadBytes;
-    return {
-      meter: "cdp-data-received-v3",
-      totalRequests: state.totalRequests,
-      proxyRequests: state.proxyRequests,
-      directRequests: state.directRequests,
-      totalUploadBytes: state.totalUploadBytes,
-      proxyUploadBytes: state.proxyUploadBytes,
-      directUploadBytes: state.directUploadBytes,
-      totalDownloadBytes: state.totalDownloadBytes,
-      proxyDownloadBytes: state.proxyDownloadBytes,
-      directDownloadBytes: state.directDownloadBytes,
-      totalBytes,
-      proxyBytes,
-      directBytes,
-      totalFailedRequests: state.totalFailedRequests,
-      proxyFailedRequests: state.proxyFailedRequests,
-      directFailedRequests: state.directFailedRequests,
-      totalCanceledRequests: state.totalCanceledRequests,
-      proxyCanceledRequests: state.proxyCanceledRequests,
-      directCanceledRequests: state.directCanceledRequests,
-      orphanDataReceivedBytes: state.orphanDataReceivedBytes,
-      orphanProxyDataReceivedBytes: state.orphanProxyDataReceivedBytes,
-      orphanFinishDeltaBytes: state.orphanFinishDeltaBytes,
-      orphanProxyFinishDeltaBytes: state.orphanProxyFinishDeltaBytes,
-      openRequestCount: requestMap.size,
-      orphanOpenCount: orphanReceivedMap.size,
-      topDomains: buildTopDomains(state),
-      topResourceTypes: buildTopResourceTypes(state),
-      failedReasons: buildFailedReasons(state),
-      proxyBypassHints: buildProxyByPassHints(state)
-    };
-  };
-  const reset = () => {
-    Object.assign(state, createTrafficState());
-    requestMap.clear();
-    orphanReceivedMap.clear();
-    wsRouteMap.clear();
-  };
-  return {
-    attachPage,
-    snapshot,
-    reset
-  };
-};
 
 // src/launch.js
 var logger7 = createInternalLogger("Launch");
@@ -2064,24 +1666,10 @@ var resolveProxyLaunchOptions = (proxyConfiguration = {}) => {
   const proxyUrl = String(config.proxy_url || "").trim();
   const enableProxy = typeof config.enable_proxy === "boolean" ? config.enable_proxy : proxyUrl !== "";
   if (!enableProxy || !proxyUrl) {
-    return { launchProxy: null, byPassDomains: [], enableProxy, proxyUrl };
+    return { byPassDomains: [], enableProxy, proxyUrl };
   }
   const byPassDomains = normalizeByPassDomains(config.by_pass_domains);
-  let parsedProxyUrl;
-  parsedProxyUrl = new URL(proxyUrl);
-  const launchProxy = {
-    server: `${parsedProxyUrl.protocol}//${parsedProxyUrl.host}`
-  };
-  if (parsedProxyUrl.username) {
-    launchProxy.username = decodeURIComponent(parsedProxyUrl.username);
-  }
-  if (parsedProxyUrl.password) {
-    launchProxy.password = decodeURIComponent(parsedProxyUrl.password);
-  }
-  if (byPassDomains.length > 0) {
-    launchProxy.bypass = byPassDomains.join(",");
-  }
-  return { launchProxy, byPassDomains, enableProxy, proxyUrl };
+  return { byPassDomains, enableProxy, proxyUrl };
 };
 var Launch = {
   getPlaywrightCrawlerOptions(options = {}) {
@@ -2097,14 +1685,13 @@ var Launch = {
       preNavigationHooks = [],
       postNavigationHooks = []
     } = normalizedOptions;
-    const { launchProxy, byPassDomains, enableProxy, proxyUrl } = resolveProxyLaunchOptions(proxyConfiguration);
+    const { byPassDomains, enableProxy, proxyUrl } = resolveProxyLaunchOptions(proxyConfiguration);
     const byPassRules = buildByPassDomainRules(byPassDomains);
-    const trafficMeter2 = createTrafficMeter({
-      enableProxy: Boolean(launchProxy),
-      byPassRules,
-      debugMode: Boolean(debugMode)
-    });
-    setTrafficMeter(trafficMeter2);
+    const proxyMeter = enableProxy && proxyUrl ? startProxyMeter({ proxyUrl, debugMode }) : null;
+    const launchProxy = proxyMeter ? { server: proxyMeter.server } : null;
+    if (launchProxy && byPassDomains.length > 0) {
+      launchProxy.bypass = byPassDomains.join(",");
+    }
     const launchOptions = {
       args: [
         ...AntiCheat.getLaunchArgs(),
@@ -2117,8 +1704,14 @@ var Launch = {
     }
     const enableByPassLogger = Boolean(logOptions && logOptions.enable);
     if (enableByPassLogger && launchProxy) {
+      let upstreamLabel = "";
+      try {
+        const parsedProxyUrl = new URL(proxyUrl);
+        upstreamLabel = `${parsedProxyUrl.protocol}//${parsedProxyUrl.host}`;
+      } catch {
+      }
       logger7.info(
-        `[\u4EE3\u7406\u5DF2\u542F\u7528] \u4EE3\u7406\u670D\u52A1=${launchProxy.server} \u76F4\u8FDE\u57DF\u540D=${(byPassDomains || []).join(",")}`
+        `[\u4EE3\u7406\u5DF2\u542F\u7528] \u672C\u5730=${launchProxy.server} \u4E0A\u6E38=${upstreamLabel || "-"} \u76F4\u8FDE\u57DF\u540D=${(byPassDomains || []).join(",")}`
       );
       logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     } else if (enableByPassLogger && enableProxy && !launchProxy) {
@@ -2138,9 +1731,6 @@ var Launch = {
       const recommendedGotoOptions = {
         waitUntil: "commit"
       };
-      if (page && typeof page.on === "function") {
-        trafficMeter2.attachPage(page);
-      }
       if (!enableByPassLogger || byPassDomains.length === 0 || !page || typeof page.on !== "function") {
         return recommendedGotoOptions;
       }
@@ -2833,10 +2423,10 @@ var Mutation = {
             let text = "";
             let html = "";
             let source = "main";
-            let path = `${selector}[${index}]`;
+            let path2 = `${selector}[${index}]`;
             if (isIframe) {
               source = "iframe";
-              path = `${selector}[${index}]::iframe(${safeFrameId(node)})`;
+              path2 = `${selector}[${index}]::iframe(${safeFrameId(node)})`;
               try {
                 const frameDoc = node.contentDocument;
                 const frameRoot = frameDoc?.body || frameDoc?.documentElement;
@@ -2854,7 +2444,7 @@ var Mutation = {
             items.push({
               selector,
               source,
-              path,
+              path: path2,
               text,
               html,
               snapshot