@skrillex1224/playwright-toolkit 2.1.164 → 2.1.165

package/dist/index.cjs

@@ -1414,6 +1414,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);
@@ -1457,9 +1478,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";
@@ -1506,6 +1595,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 = [],
@@ -1513,7 +1786,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,
@@ -1521,62 +1797,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 || "");
@@ -1584,48 +1967,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}`);
     }
@@ -1635,7 +2034,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,
@@ -1647,12 +2046,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 {