@skrillex1224/playwright-toolkit 2.1.164 → 2.1.166

package/dist/index.js

@@ -1387,6 +1387,27 @@ var resolveRouteByProxy = ({
 // 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);
@@ -1430,9 +1451,77 @@ var createTrafficState = () => ({
   directUploadBytes: 0,
   totalDownloadBytes: 0,
   proxyDownloadBytes: 0,
-  directDownloadBytes: 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";
@@ -1479,6 +1568,190 @@ var addDownloadBytes = (state, route, bytes = 0) => {
   }
   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 = [],
@@ -1486,7 +1759,10 @@ var createTrafficMeter = ({
 } = {}) => {
   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,
@@ -1494,62 +1770,169 @@ var createTrafficMeter = ({
       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 = String(params.type || request.type || "other").trim().toLowerCase() || "other";
+    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,
+        route: ensureRoute(route),
         resourceType,
+        domain,
         url,
-        uploadBytes
+        uploadBytes,
+        downloadBytes: 0
       });
     }
     debugLog(
       `request id=${requestId || "-"} route=${route} type=${resourceType} upload=${formatBytes(uploadBytes)} (${uploadBytes}) method=${String(request.method || "GET")} url=${url || "-"}`
     );
   };
-  const recordLoadingFinished = (params = {}) => {
+  const recordDataReceived = (params = {}) => {
     const requestId = String(params.requestId || "");
-    const requestState = requestId ? requestMap.get(requestId) : null;
-    const route = requestState?.route || "direct";
-    const resourceType = requestState?.resourceType || "other";
-    const downloadBytes = toSafeNumber(params.encodedDataLength);
-    addDownloadBytes(state, route, downloadBytes);
-    const uploadBytes = toSafeNumber(requestState?.uploadBytes);
-    const totalBytes = uploadBytes + downloadBytes;
-    debugLog(
-      `finish id=${requestId || "-"} route=${route} type=${resourceType} download=${formatBytes(downloadBytes)} (${downloadBytes}) total=${formatBytes(totalBytes)} (${totalBytes}) url=${requestState?.url || "-"}`
-    );
-    if (requestId) {
-      requestMap.delete(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;
-    debugLog(
-      `failed id=${requestId || "-"} route=${requestState?.route || "direct"} type=${requestState?.resourceType || "other"} reason=${String(params.errorText || "").trim() || "unknown"} canceled=${Boolean(params.canceled)} url=${requestState?.url || "-"}`
-    );
+    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 route = resolveRoute(params.url || "");
-    wsRouteMap.set(requestId, { route, url: String(params.url || "") });
+    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 || "");
@@ -1557,48 +1940,64 @@ var createTrafficMeter = ({
     wsRouteMap.delete(requestId);
   };
   const getWebSocketMeta = (requestId = "") => {
-    if (!requestId) return { route: "direct", url: "" };
+    if (!requestId) return { route: fallbackRoute(), url: "", domain: UNKNOWN_DOMAIN };
     const meta = wsRouteMap.get(requestId);
     if (!meta || typeof meta !== "object") {
-      return { route: "direct", url: "" };
+      return { route: fallbackRoute(), url: "", domain: UNKNOWN_DOMAIN };
     }
     return {
       route: ensureRoute(meta.route),
-      url: String(meta.url || "")
+      url: String(meta.url || ""),
+      domain: normalizeDomainKey(meta.domain)
     };
   };
   const recordWebSocketFrameSent = (params = {}) => {
     const requestId = String(params.requestId || "");
-    const { route, url } = getWebSocketMeta(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 } = getWebSocketMeta(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}`);
     }
@@ -1608,7 +2007,7 @@ var createTrafficMeter = ({
     const proxyBytes = state.proxyUploadBytes + state.proxyDownloadBytes;
     const directBytes = state.directUploadBytes + state.directDownloadBytes;
     return {
-      meter: "cdp",
+      meter: "cdp-data-received-v3",
       totalRequests: state.totalRequests,
       proxyRequests: state.proxyRequests,
       directRequests: state.directRequests,
@@ -1620,12 +2019,29 @@ var createTrafficMeter = ({
       directDownloadBytes: state.directDownloadBytes,
       totalBytes,
       proxyBytes,
-      directBytes
+      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 {
@@ -2360,6 +2776,196 @@ var Mutation = {
     logger11.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
     return result;
   },
+  /**
+   * 等待跨 root DOM 元素稳定（主文档 + iframe 内容）
+   * 通过轮询快照检测变化，适配 iframe / shadow 场景
+   *
+   * @param {import('playwright').Page} page - Playwright page 对象
+   * @param {string | string[]} selectors - 要监控的 CSS 选择器，单个或多个（建议传 iframe 选择器）
+   * @param {Object} [options] - 配置选项（签名与 waitForStable 保持一致）
+   * @param {number} [options.initialTimeout] - 等待元素出现的超时 (毫秒, 默认: 60000)
+   * @param {number} [options.stableTime] - 无变化持续时间后 resolve (毫秒, 默认: 10000)
+   * @param {number} [options.timeout] - 整体超时时间 (毫秒, 默认: 180000)
+   * @param {Function} [options.onMutation] - 变化时的回调钩子
+   * @returns {Promise<{ mutationCount: number, stableTime: number, wasPaused: boolean }>}
+   */
+  async waitForStableAcrossRoots(page, selectors, options = {}) {
+    const selectorList = Array.isArray(selectors) ? selectors : [selectors];
+    const selectorQuery = selectorList.join(",");
+    const initialTimeout = options.initialTimeout ?? 60 * 1e3;
+    const waitForStableTime = options.stableTime ?? 10 * 1e3;
+    const overallTimeout = options.timeout ?? 180 * 1e3;
+    const onMutation = options.onMutation;
+    const pollInterval = 500;
+    const sleep = (ms) => new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+    const truncate = (value, max = 800) => {
+      const text = String(value || "");
+      if (text.length <= max) return text;
+      return `${text.slice(0, max)}...`;
+    };
+    const buildState = async () => {
+      return await page.evaluate(({ selectorList: selectorList2 }) => {
+        const normalizeText = (value) => String(value || "").replace(/\s+/g, " ").trim();
+        const tail = (value, max = 512) => {
+          const text = String(value || "");
+          if (text.length <= max) return text;
+          return text.slice(text.length - max);
+        };
+        const safeFrameId = (frameEl) => {
+          const id = String(frameEl?.id || "").trim();
+          if (id) return id;
+          const name = String(frameEl?.name || "").trim();
+          if (name) return name;
+          return "no-id";
+        };
+        const items = [];
+        selectorList2.forEach((selector) => {
+          let nodes = [];
+          try {
+            nodes = Array.from(document.querySelectorAll(selector));
+          } catch {
+            return;
+          }
+          nodes.forEach((node, index) => {
+            const isIframe = node?.tagName === "IFRAME";
+            let text = "";
+            let html = "";
+            let source = "main";
+            let path = `${selector}[${index}]`;
+            if (isIframe) {
+              source = "iframe";
+              path = `${selector}[${index}]::iframe(${safeFrameId(node)})`;
+              try {
+                const frameDoc = node.contentDocument;
+                const frameRoot = frameDoc?.body || frameDoc?.documentElement;
+                if (frameRoot) {
+                  text = normalizeText(frameRoot.innerText || frameRoot.textContent || "");
+                  html = normalizeText(frameRoot.innerHTML || "");
+                }
+              } catch {
+              }
+            } else {
+              text = normalizeText(node?.innerText || node?.textContent || "");
+              html = normalizeText(node?.innerHTML || node?.outerHTML || "");
+            }
+            const snapshot = text || html;
+            items.push({
+              selector,
+              source,
+              path,
+              text,
+              html,
+              snapshot
+            });
+          });
+        });
+        const snapshotKey = items.map((item) => `${item.path}:${item.snapshot.length}:${tail(item.snapshot, 512)}`).join("||");
+        const summaryText = items.map((item) => item.snapshot || item.text).join("\n").trim();
+        const summaryHtml = items.map((item) => item.html).join("\n");
+        const hasMatched = items.length > 0;
+        const primary = items.length > 0 ? items[items.length - 1] : null;
+        return {
+          hasMatched,
+          snapshotKey,
+          text: summaryText,
+          html: summaryHtml,
+          snapshotLength: summaryText.length,
+          itemCount: items.length,
+          primaryPath: primary?.path || "",
+          mutationNodes: items.map((item) => ({
+            html: item.html,
+            text: item.snapshot || item.text,
+            mutationType: item.source
+          }))
+        };
+      }, { selectorList });
+    };
+    const invokeMutationCallback = async (context) => {
+      if (!onMutation) return "__CONTINUE__";
+      try {
+        const result = await onMutation(context);
+        return result === null || result === void 0 ? "__CONTINUE__" : "__PAUSE__";
+      } catch {
+        return "__CONTINUE__";
+      }
+    };
+    logger11.start(
+      "waitForStableAcrossRoots",
+      `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668(\u8DE8 root), \u7A33\u5B9A\u65F6\u95F4=${waitForStableTime}ms`
+    );
+    if (initialTimeout > 0) {
+      try {
+        await page.waitForSelector(selectorQuery, { timeout: initialTimeout });
+        logger11.info(`waitForStableAcrossRoots \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
+      } catch (e) {
+        logger11.warning(`waitForStableAcrossRoots \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
+        throw e;
+      }
+    }
+    let state = await buildState();
+    if (!state?.hasMatched) {
+      logger11.warning("waitForStableAcrossRoots \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
+      return { mutationCount: 0, stableTime: 0, wasPaused: false };
+    }
+    let mutationCount = 0;
+    let stableSince = 0;
+    let isPaused = false;
+    let wasPaused = false;
+    let lastSnapshotKey = state.snapshotKey;
+    const applyPauseSignal = (signal) => {
+      const nextPaused = signal === "__PAUSE__";
+      if (nextPaused) {
+        if (!isPaused) wasPaused = true;
+        isPaused = true;
+        stableSince = 0;
+        return;
+      }
+      isPaused = false;
+      stableSince = Date.now();
+    };
+    const initialSignal = await invokeMutationCallback({
+      mutationCount: 0,
+      html: state.html || "",
+      text: state.text || "",
+      mutationNodes: state.mutationNodes || []
+    });
+    applyPauseSignal(initialSignal);
+    const deadline = Date.now() + overallTimeout;
+    let lastState = state;
+    while (Date.now() < deadline) {
+      await sleep(pollInterval);
+      lastState = await buildState();
+      if (!lastState?.hasMatched) {
+        continue;
+      }
+      if (lastState.snapshotKey !== lastSnapshotKey) {
+        lastSnapshotKey = lastState.snapshotKey;
+        mutationCount += 1;
+        logger11.info(
+          `waitForStableAcrossRoots \u53D8\u5316#${mutationCount}, len=${lastState.snapshotLength}, path=${lastState.primaryPath || "unknown"}, preview="${truncate(lastState.text, 120)}"`
+        );
+        const signal = await invokeMutationCallback({
+          mutationCount,
+          html: lastState.html || "",
+          text: lastState.text || "",
+          mutationNodes: lastState.mutationNodes || []
+        });
+        applyPauseSignal(signal);
+        continue;
+      }
+      if (!isPaused && stableSince > 0 && Date.now() - stableSince >= waitForStableTime) {
+        logger11.success("waitForStableAcrossRoots", `DOM \u7A33\u5B9A, \u603B\u5171 ${mutationCount} \u6B21\u53D8\u5316${wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
+        return {
+          mutationCount,
+          stableTime: waitForStableTime,
+          wasPaused
+        };
+      }
+    }
+    throw new Error(`waitForStableAcrossRoots \u8D85\u65F6 (${overallTimeout}ms), \u5DF2\u68C0\u6D4B\u5230 ${mutationCount} \u6B21\u53D8\u5316, isPaused=${isPaused}`);
+  },
   /**
    * 创建一个持续监控 DOM 变化的监控器（默认仅监听新增 DOM）
    *