@skrillex1224/playwright-toolkit 3.0.26 → 3.0.28

package/dist/index.js

@@ -202,7 +202,7 @@ var ActorInfo = {
       mode: "response",
       prefix: "https://www.doubao.com/thread/",
       xurl: [
-        "/samantha/thread/share/save",
+        "/share/save",
         "data",
         "share_id"
       ]
@@ -467,10 +467,7 @@ function createInternalLogger(moduleName, explicitLogger) {
 
 // src/internals/screenshot.js
 import delay from "delay";
-import { Jimp, JimpMime, intToRGBA } from "jimp";
-
-// src/internals/constants.js
-var PageRuntimeStateKey = "__playwright_toolkit_runtime_state__";
+import { Jimp, intToRGBA } from "jimp";
 
 // src/internals/viewport.js
 var toPositiveInt = (value) => {
@@ -502,35 +499,22 @@ var resolveCurrentViewportSize = async (page, fallback = {}) => {
 // src/internals/screenshot.js
 var logger = createInternalLogger("Screenshot");
 var DEFAULT_TIMEOUT_MS = 5e3;
-var FORCED_FULLPAGE_TYPE = "jpeg";
-var FORCED_FULLPAGE_QUALITY = 50;
-var SUPPORTED_TYPES = /* @__PURE__ */ new Set(["png", "jpeg", "webp"]);
-var EXPANDED_SCROLLABLE_CLASS = "__pk_expanded__";
-var STITCH_SCROLL_TARGET_ATTR = "data-pk-stitch-scroll-target";
 var DEFAULT_MAX_HEIGHT = 8e3;
-var DEFAULT_SETTLE_MS = 1e3;
-var DEFAULT_MOBILE_SETTLE_MS = 50;
-var DEFAULT_STITCH_SETTLE_MS = 120;
-var DEFAULT_STITCH_OVERLAP_PX = 24;
-var MIN_VIRTUALIZED_SCROLL_RATIO = 2.2;
-var MIN_SPARSE_SCROLL_RATIO = 4;
-var MIN_STITCH_VISIBLE_HEIGHT_PX = 120;
-var MIN_STITCH_VISIBLE_HEIGHT_RATIO = 0.22;
-var MIN_STITCH_OUTPUT_HEIGHT_RATIO = 0.35;
-var MIN_STITCH_OUTPUT_VIEWPORT_RATIO = 1.15;
-var MOBILE_VIEWPORT_WIDTH_THRESHOLD = 520;
-var DEFAULT_QUALITY_RETRY_ATTEMPTS = 2;
+var DEFAULT_SETTLE_MS = 260;
+var DEFAULT_QUALITY_RETRY_ATTEMPTS = 4;
 var DEFAULT_QUALITY_RETRY_DELAY_MS = 2500;
-var MIN_TRAILING_BLANK_GAP_PX = 320;
-var MIN_TRAILING_BLANK_GAP_RATIO = 0.12;
+var EXPANDED_ATTR = "data-pk-screenshot-expanded";
+var SUPPORTED_TYPES = /* @__PURE__ */ new Set(["png", "jpeg", "webp"]);
+var FULLPAGE_FALLBACK_TYPE = "jpeg";
+var FULLPAGE_FALLBACK_QUALITY = 50;
 var toPositiveNumber = (value, fallback = 0) => {
   const n = Number(value);
   if (!Number.isFinite(n) || n <= 0) return fallback;
   return n;
 };
 var toPositiveInteger = (value, fallback = 0) => {
-  const number = Math.round(Number(value) || 0);
-  return number > 0 ? number : fallback;
+  const n = Math.round(Number(value) || 0);
+  return n > 0 ? n : fallback;
 };
 var normalizeType = (value) => {
   const raw = String(value || "png").trim().toLowerCase();
@@ -545,964 +529,585 @@ var normalizeQuality = (value, type) => {
   if (rounded < 0 || rounded > 100) return void 0;
   return rounded;
 };
-var resolvePageDevice = async (page) => {
-  const declared = normalizeDevice(page?.[PageRuntimeStateKey]?.device);
-  if (declared === Device.Mobile) return Device.Mobile;
-  const viewport = await resolveCurrentViewportSize(page).catch(() => null);
-  const viewportWidth = Math.round(Number(viewport?.width) || 0);
-  if (viewportWidth > 0 && viewportWidth <= MOBILE_VIEWPORT_WIDTH_THRESHOLD) {
-    return Device.Mobile;
-  }
-  return declared;
-};
-var resolveStitchMode = (options = {}) => {
-  const raw = options.stitch ?? options.stitching ?? options.strategy;
-  if (raw === false || raw === "off" || raw === "none" || raw === "single") return "off";
-  if (raw === true || raw === "force" || raw === "stitched") return "force";
-  return "auto";
-};
 var buildFullPageClip = (metrics, viewport, maxClipHeight) => {
   const contentSize = metrics && typeof metrics === "object" ? metrics.contentSize || null : null;
   const width = Math.max(1, Math.ceil(viewport.width || contentSize?.width || 1));
   let height = Math.max(1, Math.ceil(contentSize?.height || viewport.height || 1));
-  if (maxClipHeight > 0) {
-    height = Math.min(height, maxClipHeight);
-  }
-  return {
-    x: 0,
-    y: 0,
-    width,
-    height,
-    scale: 1
+  if (maxClipHeight > 0) height = Math.min(height, maxClipHeight);
+  return { x: 0, y: 0, width, height, scale: 1 };
+};
+var capturePageScreenshot = async (page, options = {}) => {
+  const fullPage = Boolean(options.fullPage);
+  const type = fullPage ? FULLPAGE_FALLBACK_TYPE : normalizeType(options.type);
+  const quality = fullPage ? FULLPAGE_FALLBACK_QUALITY : normalizeQuality(options.quality, type);
+  const timeout = toPositiveNumber(options.timeout, DEFAULT_TIMEOUT_MS);
+  const maxClipHeight = Math.round(toPositiveNumber(options.maxClipHeight, 0));
+  const fallbackOptions = {
+    type: type === "webp" ? "png" : type,
+    fullPage
   };
+  if (quality !== void 0 && fallbackOptions.type === "jpeg") fallbackOptions.quality = quality;
+  if (timeout > 0) fallbackOptions.timeout = timeout;
+  try {
+    const context = page && typeof page.context === "function" ? page.context() : null;
+    if (!context || typeof context.newCDPSession !== "function") {
+      throw new Error("CDP session is not available");
+    }
+    const session = await context.newCDPSession(page);
+    try {
+      const viewport = await resolveCurrentViewportSize(page);
+      const captureParams = {
+        format: type,
+        fromSurface: true,
+        captureBeyondViewport: fullPage,
+        optimizeForSpeed: true
+      };
+      if (quality !== void 0) captureParams.quality = quality;
+      if (fullPage) {
+        const metrics = await session.send("Page.getLayoutMetrics");
+        captureParams.clip = buildFullPageClip(metrics, viewport, maxClipHeight);
+      }
+      const result = await session.send("Page.captureScreenshot", captureParams);
+      if (!result || typeof result.data !== "string" || !result.data) {
+        throw new Error("CDP returned empty screenshot data");
+      }
+      return Buffer.from(result.data, "base64");
+    } finally {
+      if (typeof session.detach === "function") {
+        await session.detach().catch(() => {
+        });
+      }
+    }
+  } catch (error) {
+    logger.warning(`CDP \u622A\u56FE\u5931\u8D25\uFF0C\u56DE\u9000 page.screenshot: ${error?.message || error}`);
+    return await page.screenshot(fallbackOptions);
+  }
 };
-var expandScrollableContent = async (page, options = {}) => {
-  return await page.evaluate(({ className, forceScrollableHeight, visibleOnly, expandDocumentElements }) => {
-    const body = document.body;
-    const root = document.documentElement;
-    const scrollingElement = document.scrollingElement;
-    const candidates = [];
-    const seen = /* @__PURE__ */ new Set();
-    let maxHeight = window.innerHeight || 0;
-    const pushCandidate = (el) => {
-      if (!el || seen.has(el)) return;
-      seen.add(el);
-      candidates.push(el);
+var readMainFrameScroll = async (page) => {
+  return await page.evaluate(() => ({
+    x: Math.max(0, Math.round(window.scrollX || document.scrollingElement?.scrollLeft || 0)),
+    y: Math.max(0, Math.round(window.scrollY || document.scrollingElement?.scrollTop || 0))
+  })).catch(() => ({ x: 0, y: 0 }));
+};
+var restoreMainFrameScroll = async (page, state2) => {
+  if (!state2) return;
+  await page.evaluate(({ x, y }) => {
+    window.scrollTo(Math.max(0, Math.round(Number(x) || 0)), Math.max(0, Math.round(Number(y) || 0)));
+  }, state2).catch(() => {
+  });
+};
+var freezeViewportMetrics = async (page) => {
+  const viewport = await resolveCurrentViewportSize(page).catch(() => null);
+  if (!viewport?.width || !viewport?.height) return false;
+  return await page.evaluate(({ width, height }) => {
+    const key = "__pkScreenshotViewportFreeze";
+    if (window[key]?.active) return true;
+    const state2 = {
+      active: true,
+      entries: []
+    };
+    const override = (target, prop, value) => {
+      if (!target) return;
+      try {
+        const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+        state2.entries.push({
+          target,
+          prop,
+          hadOwn: Boolean(descriptor),
+          descriptor
+        });
+        Object.defineProperty(target, prop, {
+          configurable: true,
+          get: () => value
+        });
+      } catch {
+      }
     };
-    pushCandidate(scrollingElement);
-    pushCandidate(root);
-    pushCandidate(body);
-    document.querySelectorAll("*").forEach(pushCandidate);
+    override(window, "innerWidth", width);
+    override(window, "innerHeight", height);
+    if (window.visualViewport) {
+      override(window.visualViewport, "width", width);
+      override(window.visualViewport, "height", height);
+    }
+    window[key] = state2;
+    return true;
+  }, {
+    width: Math.max(1, Math.round(viewport.width)),
+    height: Math.max(1, Math.round(viewport.height))
+  }).catch((error) => {
+    logger.warning(`\u51BB\u7ED3 viewport \u6307\u6807\u5931\u8D25: ${error?.message || error}`);
+    return false;
+  });
+};
+var restoreViewportMetrics = async (page) => {
+  await page.evaluate(() => {
+    const key = "__pkScreenshotViewportFreeze";
+    const state2 = window[key];
+    if (!state2?.active) return;
+    for (const entry of [...state2.entries].reverse()) {
+      try {
+        if (entry.hadOwn && entry.descriptor) {
+          Object.defineProperty(entry.target, entry.prop, entry.descriptor);
+        } else {
+          delete entry.target[entry.prop];
+        }
+      } catch {
+      }
+    }
+    delete window[key];
+  }).catch(() => {
+  });
+};
+var expandScrollableContentInContext = async (context, options = {}) => {
+  return await context.evaluate(async ({
+    expandedAttr,
+    maxHeight,
+    preloadLazyContent,
+    preloadSettleMs,
+    visibleOnly
+  }) => {
+    const root = document.documentElement;
+    const body = document.body;
+    const scrollingElement = document.scrollingElement || root || body;
+    const viewportWidth = window.innerWidth || root?.clientWidth || body?.clientWidth || 1;
+    const viewportHeight = window.innerHeight || root?.clientHeight || body?.clientHeight || 1;
     const scrollableOverflow = /* @__PURE__ */ new Set(["auto", "scroll", "overlay"]);
     const clippingOverflow = /* @__PURE__ */ new Set(["hidden", "clip"]);
+    const candidates = [];
+    const changed = [];
+    const push = (el) => {
+      if (el && !candidates.includes(el)) candidates.push(el);
+    };
+    push(scrollingElement);
+    push(root);
+    push(body);
+    document.querySelectorAll("*").forEach(push);
     const isDocumentElement = (el) => el === root || el === body || el === scrollingElement;
+    const delayMs = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
+    const styleValue = (el, prop) => el.style.getPropertyValue(prop) || "";
+    const stylePriority = (el, prop) => el.style.getPropertyPriority(prop) || "";
     const isVisible = (el, style, rect) => {
       if (!el || !style || !rect) return false;
-      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") {
-        return false;
-      }
-      if (Number(style.opacity) === 0) return false;
+      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") return false;
+      if (Number(style.opacity || 1) === 0) return false;
       return rect.width > 0 && rect.height > 0;
     };
+    const intersectsViewport = (rect) => {
+      if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+      return rect.bottom > 0 && rect.right > 0 && rect.top < viewportHeight && rect.left < viewportWidth;
+    };
+    const isVisibleInViewport = (el, style, rect) => isVisible(el, style, rect) && intersectsViewport(rect);
     const hasOverflowValue = (style, values) => {
-      const overflowY = String(style?.overflowY || "").toLowerCase();
       const overflow = String(style?.overflow || "").toLowerCase();
-      return values.has(overflowY) || values.has(overflow);
+      const overflowY = String(style?.overflowY || "").toLowerCase();
+      return values.has(overflow) || values.has(overflowY);
     };
     const isLargeVerticalClipper = (el, rect) => {
       if (!el || !rect) return false;
-      const viewportHeight = window.innerHeight || 0;
-      const visibleHeight = Math.ceil(rect.height || 0);
-      const clientHeight = Math.ceil(el.clientHeight || 0);
-      const boxHeight = Math.max(visibleHeight, clientHeight);
+      const boxHeight = Math.max(Math.ceil(rect.height || 0), Math.ceil(el.clientHeight || 0));
       return boxHeight >= Math.max(320, viewportHeight * 0.45);
     };
-    const hasLargeVerticalOverflow = (el, rect) => {
-      if (!isLargeVerticalClipper(el, rect)) return false;
-      const viewportHeight = window.innerHeight || 0;
-      const scrollHeight = Math.ceil(el.scrollHeight || 0);
-      const clientHeight = Math.ceil(el.clientHeight || 0);
-      const overflowDelta = scrollHeight - clientHeight;
-      return overflowDelta >= Math.max(160, viewportHeight * 0.18);
-    };
-    const rememberOriginalBoxStyles = (el, { includeDocumentElement = false } = {}) => {
-      if (!el || !includeDocumentElement && isDocumentElement(el) || el.classList.contains(className)) {
-        return;
-      }
-      el.dataset.pkOrigOverflow = el.style.overflow;
-      el.dataset.pkOrigOverflowPriority = el.style.getPropertyPriority("overflow") || "";
-      el.dataset.pkOrigHeight = el.style.height;
-      el.dataset.pkOrigHeightPriority = el.style.getPropertyPriority("height") || "";
-      el.dataset.pkOrigMinHeight = el.style.minHeight;
-      el.dataset.pkOrigMinHeightPriority = el.style.getPropertyPriority("min-height") || "";
-      el.dataset.pkOrigMaxHeight = el.style.maxHeight;
-      el.dataset.pkOrigMaxHeightPriority = el.style.getPropertyPriority("max-height") || "";
-      el.classList.add(className);
-    };
-    const expandDocumentElementsToHeight = (height) => {
-      if (!expandDocumentElements) return;
-      const targetHeight = Math.ceil(Number(height) || 0);
-      if (targetHeight <= 0) return;
-      [root, body, scrollingElement].forEach((el) => {
-        if (!el) return;
-        rememberOriginalBoxStyles(el, { includeDocumentElement: true });
-        el.style.setProperty("overflow", "visible", "important");
-        el.style.setProperty("height", `${targetHeight}px`, "important");
-        el.style.setProperty("min-height", `${targetHeight}px`, "important");
-        el.style.setProperty("max-height", "none", "important");
-      });
-    };
     const isScrollableY = (el, style, rect) => {
-      if (!el || el.scrollHeight <= el.clientHeight + 1) {
-        return false;
-      }
-      if (isDocumentElement(el)) {
-        return true;
-      }
-      if (hasOverflowValue(style, scrollableOverflow)) {
-        return true;
-      }
-      return hasOverflowValue(style, clippingOverflow) && hasLargeVerticalOverflow(el, rect);
+      if (!el || Math.ceil(el.scrollHeight || 0) <= Math.ceil(el.clientHeight || 0) + 2) return false;
+      if (isDocumentElement(el)) return true;
+      if (hasOverflowValue(style, scrollableOverflow)) return true;
+      if (!hasOverflowValue(style, clippingOverflow)) return false;
+      const overflowDelta = Math.ceil(el.scrollHeight || 0) - Math.ceil(el.clientHeight || 0);
+      return isLargeVerticalClipper(el, rect) && overflowDelta >= Math.max(160, viewportHeight * 0.18);
     };
-    const measureNeededHeight = (el) => {
-      if (!el) return 0;
-      const scrollHeight = Math.ceil(el.scrollHeight || 0);
-      if (scrollHeight <= 0) return 0;
-      if (isDocumentElement(el)) {
-        return scrollHeight;
-      }
-      const rect = el.getBoundingClientRect();
-      if (!rect || rect.width <= 0 || rect.height <= 0) {
-        return 0;
-      }
-      const documentTop = Math.max(0, Math.ceil(rect.top + (window.scrollY || window.pageYOffset || 0)));
-      return documentTop + scrollHeight;
+    const rememberBox = (el) => {
+      if (!el || el.getAttribute(expandedAttr) === "1") return;
+      el.setAttribute(expandedAttr, "1");
+      el.dataset.pkSsOverflow = styleValue(el, "overflow");
+      el.dataset.pkSsOverflowPriority = stylePriority(el, "overflow");
+      el.dataset.pkSsOverflowX = styleValue(el, "overflow-x");
+      el.dataset.pkSsOverflowXPriority = stylePriority(el, "overflow-x");
+      el.dataset.pkSsOverflowY = styleValue(el, "overflow-y");
+      el.dataset.pkSsOverflowYPriority = stylePriority(el, "overflow-y");
+      el.dataset.pkSsHeight = styleValue(el, "height");
+      el.dataset.pkSsHeightPriority = stylePriority(el, "height");
+      el.dataset.pkSsMinHeight = styleValue(el, "min-height");
+      el.dataset.pkSsMinHeightPriority = stylePriority(el, "min-height");
+      el.dataset.pkSsMaxHeight = styleValue(el, "max-height");
+      el.dataset.pkSsMaxHeightPriority = stylePriority(el, "max-height");
+      el.dataset.pkSsWidth = styleValue(el, "width");
+      el.dataset.pkSsWidthPriority = stylePriority(el, "width");
+      el.dataset.pkSsBoxSizing = styleValue(el, "box-sizing");
+      el.dataset.pkSsBoxSizingPriority = stylePriority(el, "box-sizing");
+      el.dataset.pkSsAlignSelf = styleValue(el, "align-self");
+      el.dataset.pkSsAlignSelfPriority = stylePriority(el, "align-self");
+      el.dataset.pkSsJustifySelf = styleValue(el, "justify-self");
+      el.dataset.pkSsJustifySelfPriority = stylePriority(el, "justify-self");
+      el.dataset.pkSsScrollTop = String(Math.max(0, Math.round(el.scrollTop || 0)));
+      el.dataset.pkSsScrollLeft = String(Math.max(0, Math.round(el.scrollLeft || 0)));
+      changed.push(el);
     };
-    const scrollableElements = [];
-    const expandedAncestors = [];
-    const expandElementToScrollHeight = (el) => {
-      if (!el || isDocumentElement(el)) return;
-      const scrollHeight = Math.ceil(el.scrollHeight || 0);
-      if (scrollHeight <= 0) return;
-      rememberOriginalBoxStyles(el);
+    const setExpandedBox = (el, { height, width }) => {
+      if (!el) return;
+      rememberBox(el);
       el.style.setProperty("overflow", "visible", "important");
-      el.style.setProperty("height", `${scrollHeight}px`, "important");
-      el.style.setProperty("min-height", `${scrollHeight}px`, "important");
+      el.style.setProperty("overflow-y", "visible", "important");
       el.style.setProperty("max-height", "none", "important");
+      if (height > 0) {
+        const cssHeight = `${Math.ceil(height)}px`;
+        el.style.setProperty("height", cssHeight, "important");
+        el.style.setProperty("min-height", cssHeight, "important");
+      }
+      if (!isDocumentElement(el) && width > 0) {
+        el.style.setProperty("box-sizing", "border-box", "important");
+        el.style.setProperty("width", `${Math.ceil(width)}px`, "important");
+        el.style.setProperty("align-self", "flex-start", "important");
+        el.style.setProperty("justify-self", "start", "important");
+      }
+      el.scrollTop = 0;
+      el.scrollLeft = 0;
     };
     const expandClippingAncestors = (el) => {
       for (let node = el?.parentElement; node && !isDocumentElement(node); node = node.parentElement) {
         const style = window.getComputedStyle(node);
         const rect = node.getBoundingClientRect();
         if (!isVisible(node, style, rect)) continue;
-        const scrollableClip = hasOverflowValue(style, scrollableOverflow);
-        const visualClip = hasOverflowValue(style, clippingOverflow);
-        if (!scrollableClip && (!visualClip || !isLargeVerticalClipper(node, rect))) continue;
-        rememberOriginalBoxStyles(node);
+        const clips = hasOverflowValue(style, scrollableOverflow) || hasOverflowValue(style, clippingOverflow);
+        if (!clips) continue;
+        rememberBox(node);
         node.style.setProperty("overflow", "visible", "important");
+        node.style.setProperty("overflow-y", "visible", "important");
         node.style.setProperty("max-height", "none", "important");
-        expandedAncestors.push(node);
       }
     };
-    const expandAncestorsToCurrentScrollHeight = () => {
-      const ancestors = [...new Set(expandedAncestors)];
-      for (let pass = 0; pass < 2; pass += 1) {
-        ancestors.forEach((node) => {
-          if (!node || isDocumentElement(node)) return;
-          const scrollHeight = Math.ceil(node.scrollHeight || 0);
-          if (scrollHeight <= node.clientHeight + 1) return;
-          rememberOriginalBoxStyles(node);
-          node.style.setProperty("height", `${scrollHeight}px`, "important");
-          node.style.setProperty("min-height", `${scrollHeight}px`, "important");
-          node.style.setProperty("max-height", "none", "important");
-        });
+    const preloadCandidates = [];
+    for (const el of candidates) {
+      const style = window.getComputedStyle(el);
+      const rect = isDocumentElement(el) ? { top: 0, left: 0, width: viewportWidth, height: viewportHeight } : el.getBoundingClientRect();
+      if (visibleOnly && !isDocumentElement(el) && !isVisibleInViewport(el, style, rect)) continue;
+      if (!isScrollableY(el, style, rect)) continue;
+      preloadCandidates.push(el);
+    }
+    if (preloadLazyContent && preloadCandidates.length > 0) {
+      preloadCandidates.forEach((el) => {
+        rememberBox(el);
+        const maxTop = Math.max(0, Math.ceil((el.scrollHeight || 0) - (el.clientHeight || viewportHeight || 0)));
+        if (isDocumentElement(el)) {
+          window.scrollTo(window.scrollX || 0, maxTop);
+        } else {
+          el.scrollTop = maxTop;
+          el.dispatchEvent(new Event("scroll", { bubbles: true }));
+        }
+      });
+      window.dispatchEvent(new Event("scroll"));
+      await delayMs(preloadSettleMs);
+    }
+    let targetHeight = viewportHeight;
+    let scrollableCount = 0;
+    let expandedCount = 0;
+    for (const el of preloadCandidates) {
+      const rect = isDocumentElement(el) ? { top: 0, left: 0, width: viewportWidth, height: viewportHeight } : el.getBoundingClientRect();
+      const scrollHeight = Math.ceil(el.scrollHeight || 0);
+      const clientHeight = Math.ceil(el.clientHeight || viewportHeight || 0);
+      if (scrollHeight <= clientHeight + 2) continue;
+      scrollableCount += 1;
+      if (isDocumentElement(el)) {
+        targetHeight = Math.max(targetHeight, scrollHeight);
+        el.scrollTop = 0;
+        continue;
       }
-    };
-    const measureExpandedRenderedBottom = () => {
-      let renderedBottom = maxHeight;
+      const documentTop = Math.max(0, Math.ceil(rect.top + (window.scrollY || window.pageYOffset || 0)));
+      const width = Math.max(1, Math.ceil(rect.width || el.clientWidth || viewportWidth || 1));
+      targetHeight = Math.max(targetHeight, documentTop + scrollHeight);
+      expandClippingAncestors(el);
+      setExpandedBox(el, { height: scrollHeight, width });
+      expandedCount += 1;
+    }
+    for (let pass = 0; pass < 2; pass += 1) {
+      for (const el of changed) {
+        if (!el || isDocumentElement(el)) continue;
+        const height = Math.ceil(el.scrollHeight || 0);
+        if (height > Math.ceil(el.clientHeight || 0) + 2) {
+          el.style.setProperty("height", `${height}px`, "important");
+          el.style.setProperty("min-height", `${height}px`, "important");
+        }
+      }
+    }
+    const measureDocumentHeight = () => Math.max(
+      viewportHeight,
+      Math.ceil(root?.scrollHeight || 0),
+      Math.ceil(body?.scrollHeight || 0),
+      Math.ceil(scrollingElement?.scrollHeight || 0)
+    );
+    const measureExpandedBottom = () => {
+      let bottom = viewportHeight;
       const scrollY = window.scrollY || window.pageYOffset || 0;
-      candidates.forEach((el) => {
+      document.querySelectorAll(`[${expandedAttr}="1"]`).forEach((el) => {
         if (!el || isDocumentElement(el)) return;
-        if (!el.classList.contains(className) && !el.closest(`.${className}`)) return;
-        const style = window.getComputedStyle(el);
         const rect = el.getBoundingClientRect();
-        if (!isVisible(el, style, rect)) return;
-        renderedBottom = Math.max(renderedBottom, Math.ceil(rect.bottom + scrollY));
+        if (!rect || rect.width <= 0 || rect.height <= 0) return;
+        bottom = Math.max(bottom, Math.ceil(rect.bottom + scrollY));
       });
-      return renderedBottom;
+      return bottom;
     };
-    const measureDocumentScrollHeight = () => {
-      return Math.max(
-        maxHeight,
-        Math.ceil(root?.scrollHeight || 0),
-        Math.ceil(body?.scrollHeight || 0),
-        Math.ceil(scrollingElement?.scrollHeight || 0)
-      );
-    };
-    candidates.forEach((el) => {
-      const style = window.getComputedStyle(el);
-      const rect = el.getBoundingClientRect();
-      if (visibleOnly && !isVisible(el, style, rect)) {
-        return;
-      }
-      if (!isScrollableY(el, style, rect)) {
-        return;
-      }
-      const neededHeight = measureNeededHeight(el);
-      if (neededHeight <= 0) {
-        return;
-      }
-      if (neededHeight > maxHeight) {
-        maxHeight = neededHeight;
-      }
-      scrollableElements.push(el);
-      if (isDocumentElement(el)) {
-        return;
-      }
-      expandClippingAncestors(el);
-      if (forceScrollableHeight) {
-        expandElementToScrollHeight(el);
-        return;
-      }
-      rememberOriginalBoxStyles(el);
-      el.style.overflow = "visible";
-      el.style.height = "auto";
-      el.style.maxHeight = "none";
+    targetHeight = Math.max(targetHeight, measureDocumentHeight(), measureExpandedBottom());
+    targetHeight = Math.min(Math.max(1, Math.ceil(targetHeight)), Math.max(1, Math.ceil(maxHeight || targetHeight)));
+    [root, body, scrollingElement].forEach((el) => {
+      if (!el) return;
+      setExpandedBox(el, { height: targetHeight, width: 0 });
     });
-    expandAncestorsToCurrentScrollHeight();
-    scrollableElements.forEach((el) => {
-      const neededHeight = measureNeededHeight(el);
-      if (neededHeight > maxHeight) {
-        maxHeight = neededHeight;
+    window.scrollTo(0, 0);
+    document.querySelectorAll(`[${expandedAttr}="1"]`).forEach((el) => {
+      if (!isDocumentElement(el)) {
+        el.scrollTop = 0;
+        el.scrollLeft = 0;
       }
     });
-    maxHeight = Math.max(maxHeight, measureDocumentScrollHeight(), measureExpandedRenderedBottom());
-    if (expandDocumentElements) {
-      for (let pass = 0; pass < 2; pass += 1) {
-        expandDocumentElementsToHeight(maxHeight);
-        maxHeight = Math.max(maxHeight, measureDocumentScrollHeight(), measureExpandedRenderedBottom());
-      }
-    }
-    return Math.ceil(maxHeight);
+    window.dispatchEvent(new Event("scroll"));
+    await delayMs(preloadSettleMs);
+    return {
+      height: Math.max(targetHeight, measureDocumentHeight(), measureExpandedBottom()),
+      scrollableCount,
+      expandedCount
+    };
   }, {
-    className: EXPANDED_SCROLLABLE_CLASS,
-    forceScrollableHeight: options.forceScrollableHeight !== false,
-    visibleOnly: options.visibleOnly !== false,
-    expandDocumentElements: options.expandDocumentElements === true
+    expandedAttr: EXPANDED_ATTR,
+    maxHeight: toPositiveInteger(options.maxHeight, DEFAULT_MAX_HEIGHT),
+    preloadLazyContent: options.preloadLazyContent !== false,
+    preloadSettleMs: Math.max(0, Math.min(500, Number(options.preloadSettleMs ?? options.settleMs ?? 120) || 0)),
+    visibleOnly: options.visibleOnly !== false
+  }).catch((error) => {
+    logger.warning(`\u5C55\u5F00\u6EDA\u52A8\u5BB9\u5668\u5931\u8D25: ${error?.message || error}`);
+    return { height: 0, scrollableCount: 0, expandedCount: 0 };
   });
 };
-var adjustAffixedElementsForExpandedScreenshot = async (page, options = {}) => {
-  return await page.evaluate(({ className, targetHeight }) => {
-    const viewportWidth = window.innerWidth || document.documentElement?.clientWidth || document.body?.clientWidth || 0;
-    const viewportHeight = window.innerHeight || document.documentElement?.clientHeight || document.body?.clientHeight || 0;
-    const scrollY = window.scrollY || window.pageYOffset || 0;
-    const safeTargetHeight = Math.ceil(Number(targetHeight) || 0);
-    if (safeTargetHeight <= viewportHeight + 1) {
-      return 0;
-    }
-    const hasOwn2 = (source, key) => Object.prototype.hasOwnProperty.call(source, key);
-    const isVisible = (el, style, rect) => {
-      if (!el || !style || !rect) return false;
-      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") {
-        return false;
-      }
-      if (Number(style.opacity) === 0) return false;
-      return rect.width > 0 && rect.height > 0;
-    };
-    const edgeThreshold = Math.max(24, Math.min(96, viewportHeight * 0.12));
-    const maxAffixedHeight = Math.max(56, viewportHeight * 0.65);
-    const candidates = [];
-    document.querySelectorAll("*").forEach((el) => {
-      const style = window.getComputedStyle(el);
-      const position = String(style.position || "").toLowerCase();
-      if (position !== "fixed" && position !== "sticky") return;
-      const rect = el.getBoundingClientRect();
-      if (!isVisible(el, style, rect)) return;
-      if (rect.height > maxAffixedHeight) return;
-      if (rect.width < viewportWidth * 0.25 && rect.height < 80) return;
-      const top = Number.parseFloat(style.top);
-      const bottom = Number.parseFloat(style.bottom);
-      const hasTopRule = Number.isFinite(top) && top <= Math.max(160, viewportHeight * 0.25);
-      const hasBottomRule = Number.isFinite(bottom) && bottom <= Math.max(160, viewportHeight * 0.25);
-      const isNearViewportTop = rect.top <= edgeThreshold;
-      const isNearViewportBottom = rect.bottom >= viewportHeight - edgeThreshold;
-      const edge = (hasBottomRule || isNearViewportBottom) && !(hasTopRule || isNearViewportTop) ? "bottom" : "top";
-      if (position === "fixed" && edge === "top" && !hasTopRule && !isNearViewportTop) return;
-      if (position === "fixed" && edge === "bottom" && !hasBottomRule && !isNearViewportBottom) return;
-      if (position === "sticky" && !hasTopRule && !hasBottomRule && !isNearViewportTop && !isNearViewportBottom) return;
-      candidates.push({ el, position, edge });
-    });
-    const candidateSet = new Set(candidates.map(({ el }) => el));
-    const topLevelCandidates = candidates.filter(({ el }) => {
-      for (let parent = el.parentElement; parent; parent = parent.parentElement) {
-        if (candidateSet.has(parent)) return false;
+var expandFrameElement = async (frame, height) => {
+  const handle = await frame.frameElement?.().catch(() => null);
+  if (!handle) return false;
+  try {
+    return await handle.evaluate((el, { expandedAttr, targetHeight }) => {
+      if (!el || targetHeight <= 0) return false;
+      if (el.getAttribute(expandedAttr) !== "1") {
+        el.setAttribute(expandedAttr, "1");
+        el.dataset.pkSsOverflow = el.style.getPropertyValue("overflow") || "";
+        el.dataset.pkSsOverflowPriority = el.style.getPropertyPriority("overflow") || "";
+        el.dataset.pkSsOverflowX = el.style.getPropertyValue("overflow-x") || "";
+        el.dataset.pkSsOverflowXPriority = el.style.getPropertyPriority("overflow-x") || "";
+        el.dataset.pkSsOverflowY = el.style.getPropertyValue("overflow-y") || "";
+        el.dataset.pkSsOverflowYPriority = el.style.getPropertyPriority("overflow-y") || "";
+        el.dataset.pkSsHeight = el.style.getPropertyValue("height") || "";
+        el.dataset.pkSsHeightPriority = el.style.getPropertyPriority("height") || "";
+        el.dataset.pkSsMinHeight = el.style.getPropertyValue("min-height") || "";
+        el.dataset.pkSsMinHeightPriority = el.style.getPropertyPriority("min-height") || "";
+        el.dataset.pkSsMaxHeight = el.style.getPropertyValue("max-height") || "";
+        el.dataset.pkSsMaxHeightPriority = el.style.getPropertyPriority("max-height") || "";
+        el.dataset.pkSsWidth = el.style.getPropertyValue("width") || "";
+        el.dataset.pkSsWidthPriority = el.style.getPropertyPriority("width") || "";
+        el.dataset.pkSsBoxSizing = el.style.getPropertyValue("box-sizing") || "";
+        el.dataset.pkSsBoxSizingPriority = el.style.getPropertyPriority("box-sizing") || "";
+        el.dataset.pkSsAlignSelf = el.style.getPropertyValue("align-self") || "";
+        el.dataset.pkSsAlignSelfPriority = el.style.getPropertyPriority("align-self") || "";
+        el.dataset.pkSsJustifySelf = el.style.getPropertyValue("justify-self") || "";
+        el.dataset.pkSsJustifySelfPriority = el.style.getPropertyPriority("justify-self") || "";
+        el.dataset.pkSsScrollTop = String(Math.max(0, Math.round(el.scrollTop || 0)));
+        el.dataset.pkSsScrollLeft = String(Math.max(0, Math.round(el.scrollLeft || 0)));
       }
+      el.style.setProperty("overflow", "visible", "important");
+      el.style.setProperty("overflow-y", "visible", "important");
+      el.style.setProperty("height", `${Math.ceil(targetHeight)}px`, "important");
+      el.style.setProperty("min-height", `${Math.ceil(targetHeight)}px`, "important");
+      el.style.setProperty("max-height", "none", "important");
+      el.style.setProperty("align-self", "flex-start", "important");
+      el.style.setProperty("justify-self", "start", "important");
       return true;
+    }, { expandedAttr: EXPANDED_ATTR, targetHeight: Math.ceil(height) });
+  } finally {
+    await handle.dispose?.().catch(() => {
     });
-    topLevelCandidates.forEach(({ el, position, edge }) => {
-      if (!hasOwn2(el.dataset, "pkAffixedAdjusted")) {
-        el.dataset.pkAffixedAdjusted = "1";
-        el.dataset.pkOrigPosition = el.style.getPropertyValue("position") || "";
-        el.dataset.pkOrigPositionPriority = el.style.getPropertyPriority("position") || "";
-        el.dataset.pkOrigTop = el.style.getPropertyValue("top") || "";
-        el.dataset.pkOrigTopPriority = el.style.getPropertyPriority("top") || "";
-        el.dataset.pkOrigBottom = el.style.getPropertyValue("bottom") || "";
-        el.dataset.pkOrigBottomPriority = el.style.getPropertyPriority("bottom") || "";
-        el.dataset.pkOrigTranslate = el.style.getPropertyValue("translate") || "";
-        el.dataset.pkOrigTranslatePriority = el.style.getPropertyPriority("translate") || "";
-      }
-      el.classList.add(className);
-      if (position === "fixed") {
-        const deltaY = edge === "bottom" ? safeTargetHeight - viewportHeight - scrollY : -scrollY;
-        if (Math.abs(deltaY) > 1) {
-          el.style.setProperty("translate", `0 ${Math.round(deltaY)}px`, "important");
-        }
-        return;
-      }
-      el.style.setProperty("position", "relative", "important");
-      el.style.setProperty("top", "auto", "important");
-      el.style.setProperty("bottom", "auto", "important");
-    });
-    return topLevelCandidates.length;
-  }, {
-    className: EXPANDED_SCROLLABLE_CLASS,
-    targetHeight: options.targetHeight
-  });
+  }
 };
-var restoreAffixedElementsForExpandedScreenshot = async (page) => {
-  await page.evaluate((className) => {
+var restoreExpandedStateInContext = async (context) => {
+  await context.evaluate(({ expandedAttr }) => {
     const hasOwn2 = (source, key) => Object.prototype.hasOwnProperty.call(source, key);
-    const expansionKeys = [
-      "pkOrigOverflow",
-      "pkOrigHeight",
-      "pkOrigMinHeight",
-      "pkOrigMaxHeight"
-    ];
-    document.querySelectorAll('[data-pk-affixed-adjusted="1"]').forEach((el) => {
-      if (hasOwn2(el.dataset, "pkOrigPosition")) {
-        el.style.setProperty("position", el.dataset.pkOrigPosition || "", el.dataset.pkOrigPositionPriority || "");
-        delete el.dataset.pkOrigPosition;
-        delete el.dataset.pkOrigPositionPriority;
-      }
-      if (hasOwn2(el.dataset, "pkOrigTop")) {
-        el.style.setProperty("top", el.dataset.pkOrigTop || "", el.dataset.pkOrigTopPriority || "");
-        delete el.dataset.pkOrigTop;
-        delete el.dataset.pkOrigTopPriority;
-      }
-      if (hasOwn2(el.dataset, "pkOrigBottom")) {
-        el.style.setProperty("bottom", el.dataset.pkOrigBottom || "", el.dataset.pkOrigBottomPriority || "");
-        delete el.dataset.pkOrigBottom;
-        delete el.dataset.pkOrigBottomPriority;
-      }
-      if (hasOwn2(el.dataset, "pkOrigTranslate")) {
-        el.style.setProperty("translate", el.dataset.pkOrigTranslate || "", el.dataset.pkOrigTranslatePriority || "");
-        delete el.dataset.pkOrigTranslate;
-        delete el.dataset.pkOrigTranslatePriority;
-      }
-      delete el.dataset.pkAffixedAdjusted;
-      const stillExpanded = expansionKeys.some((key) => hasOwn2(el.dataset, key));
-      if (!stillExpanded) {
-        el.classList.remove(className);
+    const restoreStyle = (el, prop, valueKey, priorityKey) => {
+      if (!hasOwn2(el.dataset, valueKey)) return;
+      const value = el.dataset[valueKey] || "";
+      const priority = el.dataset[priorityKey] || "";
+      if (value) {
+        el.style.setProperty(prop, value, priority);
+      } else {
+        el.style.removeProperty(prop);
       }
+      delete el.dataset[valueKey];
+      delete el.dataset[priorityKey];
+    };
+    document.querySelectorAll(`[${expandedAttr}="1"]`).forEach((el) => {
+      restoreStyle(el, "overflow", "pkSsOverflow", "pkSsOverflowPriority");
+      restoreStyle(el, "overflow-x", "pkSsOverflowX", "pkSsOverflowXPriority");
+      restoreStyle(el, "overflow-y", "pkSsOverflowY", "pkSsOverflowYPriority");
+      restoreStyle(el, "height", "pkSsHeight", "pkSsHeightPriority");
+      restoreStyle(el, "min-height", "pkSsMinHeight", "pkSsMinHeightPriority");
+      restoreStyle(el, "max-height", "pkSsMaxHeight", "pkSsMaxHeightPriority");
+      restoreStyle(el, "width", "pkSsWidth", "pkSsWidthPriority");
+      restoreStyle(el, "box-sizing", "pkSsBoxSizing", "pkSsBoxSizingPriority");
+      restoreStyle(el, "align-self", "pkSsAlignSelf", "pkSsAlignSelfPriority");
+      restoreStyle(el, "justify-self", "pkSsJustifySelf", "pkSsJustifySelfPriority");
+      if (hasOwn2(el.dataset, "pkSsScrollTop")) {
+        el.scrollTop = Math.max(0, Math.round(Number(el.dataset.pkSsScrollTop) || 0));
+        delete el.dataset.pkSsScrollTop;
+      }
+      if (hasOwn2(el.dataset, "pkSsScrollLeft")) {
+        el.scrollLeft = Math.max(0, Math.round(Number(el.dataset.pkSsScrollLeft) || 0));
+        delete el.dataset.pkSsScrollLeft;
+      }
+      el.removeAttribute(expandedAttr);
     });
-  }, EXPANDED_SCROLLABLE_CLASS);
+    window.dispatchEvent(new Event("scroll"));
+  }, {
+    expandedAttr: EXPANDED_ATTR
+  }).catch(() => {
+  });
 };
-var measureMeaningfulContentBounds = async (page) => {
-  return await page.evaluate(() => {
+var resetScrollPositionInContext = async (context) => {
+  await context.evaluate(() => {
+    const root = document.documentElement;
     const body = document.body;
-    if (!body) return null;
-    const viewportWidth = window.innerWidth || document.documentElement?.clientWidth || body.clientWidth || 0;
-    const viewportHeight = window.innerHeight || document.documentElement?.clientHeight || body.clientHeight || 0;
-    const scrollX = window.scrollX || window.pageXOffset || 0;
-    const scrollY = window.scrollY || window.pageYOffset || 0;
-    const bounds = {
-      left: Number.POSITIVE_INFINITY,
-      top: Number.POSITIVE_INFINITY,
-      right: 0,
-      bottom: 0,
-      nodes: 0
-    };
-    const isVisible = (el, style, rect) => {
-      if (!el || !style || !rect) return false;
-      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") return false;
-      if (Number(style.opacity) === 0) return false;
-      return rect.width > 1 && rect.height > 1;
-    };
-    const hasFixedAncestor = (el) => {
-      for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
-        const position = String(window.getComputedStyle(node).position || "").toLowerCase();
-        if (position === "fixed") {
-          return true;
-        }
-      }
-      return false;
-    };
-    const parseRgbColor = (value) => {
-      const raw = String(value || "").trim();
-      const match = raw.match(/rgba?\(([^)]+)\)/i);
-      if (!match) return null;
-      const parts = match[1].replace(/\//g, " ").split(/[,\s]+/).map((part) => part.trim()).filter(Boolean);
-      if (parts.length < 3) return null;
-      const normalizeChannel = (part) => {
-        if (part.endsWith("%")) {
-          return Math.max(0, Math.min(255, Number.parseFloat(part) * 2.55));
-        }
-        return Math.max(0, Math.min(255, Number.parseFloat(part)));
-      };
-      const alpha = parts.length >= 4 ? parts[3].endsWith("%") ? Number.parseFloat(parts[3]) / 100 : Number.parseFloat(parts[3]) : 1;
-      return {
-        r: normalizeChannel(parts[0]),
-        g: normalizeChannel(parts[1]),
-        b: normalizeChannel(parts[2]),
-        a: Number.isFinite(alpha) ? Math.max(0, Math.min(1, alpha)) : 1
-      };
-    };
-    const colorLuminance = (color) => {
-      const channel = (value) => {
-        const ratio = Math.max(0, Math.min(255, value)) / 255;
-        return ratio <= 0.03928 ? ratio / 12.92 : ((ratio + 0.055) / 1.055) ** 2.4;
-      };
-      return 0.2126 * channel(color.r) + 0.7152 * channel(color.g) + 0.0722 * channel(color.b);
-    };
-    const contrastRatio = (a, b) => {
-      const l1 = colorLuminance(a);
-      const l2 = colorLuminance(b);
-      const lighter = Math.max(l1, l2);
-      const darker = Math.min(l1, l2);
-      return (lighter + 0.05) / (darker + 0.05);
-    };
-    const resolveBackgroundColor = (el) => {
-      for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
-        const background = parseRgbColor(window.getComputedStyle(node).backgroundColor);
-        if (background && background.a > 0.2) {
-          return background;
-        }
-      }
-      return { r: 255, g: 255, b: 255, a: 1 };
-    };
-    const isLowInformationTextPaint = (el, style) => {
-      const color = parseRgbColor(style?.color);
-      if (!color) return false;
-      const opacity = Number(style.opacity);
-      if (color.a <= 0.08 || Number.isFinite(opacity) && opacity <= 0.18) {
-        return true;
-      }
-      const max = Math.max(color.r, color.g, color.b);
-      const min = Math.min(color.r, color.g, color.b);
-      if (!(min >= 224 && max - min <= 24 && color.a >= 0.85)) {
-        return false;
-      }
-      const background = resolveBackgroundColor(el);
-      return colorLuminance(background) > 0.76 && contrastRatio(color, background) < 1.35;
-    };
-    const addRect = (rect) => {
-      if (!rect || rect.width <= 1 || rect.height <= 1) return;
-      const left = Math.max(0, Math.floor(rect.left + scrollX));
-      const top = Math.max(0, Math.floor(rect.top + scrollY));
-      const right = Math.ceil(rect.right + scrollX);
-      const bottom = Math.ceil(rect.bottom + scrollY);
-      if (right <= left || bottom <= top) return;
-      bounds.left = Math.min(bounds.left, left);
-      bounds.top = Math.min(bounds.top, top);
-      bounds.right = Math.max(bounds.right, right);
-      bounds.bottom = Math.max(bounds.bottom, bottom);
-      bounds.nodes += 1;
-    };
-    const addElement = (el, { minArea = 12, text = false } = {}) => {
-      if (!el || el.nodeType !== 1 || hasFixedAncestor(el)) return;
-      const style = window.getComputedStyle(el);
-      if (text && isLowInformationTextPaint(el, style)) return;
-      const rects = Array.from(el.getClientRects ? el.getClientRects() : []);
-      rects.forEach((rect) => {
-        if (!isVisible(el, style, rect)) return;
-        if (rect.width * rect.height < minArea) return;
-        addRect(rect);
-      });
-    };
-    const walker = document.createTreeWalker(body, NodeFilter.SHOW_TEXT);
-    let visitedTextNodes = 0;
-    while (walker.nextNode() && visitedTextNodes < 6e3) {
-      const node = walker.currentNode;
-      visitedTextNodes += 1;
-      const text = String(node.nodeValue || "").replace(/\s+/g, " ").trim();
-      if (text.length < 2) continue;
-      addElement(node.parentElement, { minArea: 8, text: true });
-    }
-    document.querySelectorAll("img,video,canvas,svg,picture").forEach((el) => {
-      addElement(el, { minArea: 900 });
+    const scrollingElement = document.scrollingElement || root || body;
+    window.scrollTo(0, 0);
+    [root, body, scrollingElement].forEach((el) => {
+      if (!el) return;
+      el.scrollTop = 0;
+      el.scrollLeft = 0;
+      el.dispatchEvent(new Event("scroll", { bubbles: true }));
     });
-    if (!bounds.nodes || !Number.isFinite(bounds.left)) return null;
-    const paddingX = Math.max(16, Math.min(96, viewportWidth * 0.04));
-    const paddingY = Math.max(24, Math.min(160, viewportHeight * 0.18));
-    return {
-      left: Math.max(0, Math.floor(bounds.left - paddingX)),
-      top: Math.max(0, Math.floor(bounds.top - paddingY)),
-      right: Math.ceil(bounds.right + paddingX),
-      bottom: Math.ceil(bounds.bottom + paddingY),
-      width: Math.max(1, Math.ceil(bounds.right - bounds.left)),
-      height: Math.max(1, Math.ceil(bounds.bottom - bounds.top)),
-      nodes: bounds.nodes,
-      viewport: {
-        width: Math.max(1, Math.ceil(viewportWidth || 1)),
-        height: Math.max(1, Math.ceil(viewportHeight || 1))
-      }
-    };
-  }).catch((error) => {
-    logger.warning(`\u622A\u56FE\u5185\u5BB9\u8FB9\u754C\u6D4B\u91CF\u5931\u8D25: ${error?.message || error}`);
-    return null;
+    window.dispatchEvent(new Event("scroll"));
+  }).catch(() => {
   });
 };
 var prepareExpandedFullPageScreenshot = async (page, options = {}) => {
-  const originalViewport = await resolveCurrentViewportSize(page);
   const maxHeight = toPositiveInteger(options.maxHeight, DEFAULT_MAX_HEIGHT);
-  const device = await resolvePageDevice(page);
-  const preserveViewport = options.preserveViewport ?? device === Device.Mobile;
-  const defaultSettleMs = preserveViewport ? DEFAULT_MOBILE_SETTLE_MS : DEFAULT_SETTLE_MS;
-  const requestedSettleMs = Math.max(0, Number(options.settleMs ?? defaultSettleMs) || 0);
-  const settleMs = preserveViewport ? Math.min(requestedSettleMs, DEFAULT_MOBILE_SETTLE_MS) : requestedSettleMs;
-  const maxScrollHeight = await expandScrollableContent(page, {
-    forceScrollableHeight: options.forceScrollableHeight,
-    visibleOnly: options.visibleOnly !== false,
-    expandDocumentElements: preserveViewport
-  });
-  const contentBounds = await measureMeaningfulContentBounds(page);
-  let targetHeight = Math.min(maxScrollHeight, maxHeight);
-  if (contentBounds?.bottom > 0) {
-    const contentBottom = Math.min(Math.ceil(contentBounds.bottom), maxHeight);
-    const trailingGap = targetHeight - contentBottom;
-    const minTrailingGap = Math.max(
-      MIN_TRAILING_BLANK_GAP_PX,
-      Math.floor(targetHeight * MIN_TRAILING_BLANK_GAP_RATIO),
-      Math.floor(originalViewport.height * 0.45)
-    );
-    if (trailingGap >= minTrailingGap && contentBottom >= originalViewport.height * 0.65) {
-      targetHeight = Math.max(1, contentBottom);
-      logger.info(`\u957F\u622A\u56FE\u88C1\u6389\u4F4E\u4FE1\u606F\u5C3E\u90E8: contentBottom=${contentBottom}, originalHeight=${Math.min(maxScrollHeight, maxHeight)}`);
-    }
-  }
-  let viewportResized = false;
-  if (!preserveViewport) {
-    await page.setViewportSize({
-      width: originalViewport.width,
-      height: targetHeight
+  const settleMs = Math.max(0, Number(options.settleMs ?? DEFAULT_SETTLE_MS) || 0);
+  const frames = typeof page.frames === "function" ? page.frames() : [page.mainFrame?.()].filter(Boolean);
+  const mainFrame = page.mainFrame?.() || frames[0] || null;
+  let targetHeight = 0;
+  let scrollableCount = 0;
+  let expandedCount = 0;
+  for (const frame of frames) {
+    if (!frame || frame === mainFrame) continue;
+    const state2 = await expandScrollableContentInContext(frame, {
+      ...options,
+      maxHeight,
+      settleMs
     });
-    viewportResized = true;
-  } else {
-    await adjustAffixedElementsForExpandedScreenshot(page, { targetHeight }).catch((error) => {
-      logger.warning(`\u79FB\u52A8\u7AEF\u5438\u9644\u5143\u7D20\u91CD\u5B9A\u4F4D\u5931\u8D25: ${error?.message || error}`);
+    if (state2.height > 0) {
+      await expandFrameElement(frame, Math.min(state2.height, maxHeight)).catch(() => false);
+      await resetScrollPositionInContext(frame);
+    }
+    targetHeight = Math.max(targetHeight, state2.height || 0);
+    scrollableCount += state2.scrollableCount || 0;
+    expandedCount += state2.expandedCount || 0;
+  }
+  if (mainFrame) {
+    const state2 = await expandScrollableContentInContext(mainFrame, {
+      ...options,
+      maxHeight,
+      settleMs
     });
-  }
-  if (settleMs > 0) {
-    await delay(settleMs);
-  }
+    targetHeight = Math.max(targetHeight, state2.height || 0);
+    scrollableCount += state2.scrollableCount || 0;
+    expandedCount += state2.expandedCount || 0;
+    await resetScrollPositionInContext(mainFrame);
+  }
+  targetHeight = Math.min(Math.max(1, Math.ceil(targetHeight || 0)), maxHeight);
+  if (settleMs > 0) await delay(settleMs);
+  logger.info(`\u5C55\u5F00\u5F0F\u957F\u622A\u56FE\u76EE\u6807: height=${targetHeight}, scrollables=${scrollableCount}, expanded=${expandedCount}`);
   return {
-    originalViewport,
-    maxScrollHeight,
     targetHeight,
-    contentBounds,
-    preserveViewport,
-    viewportResized
+    frames,
+    settleMs
   };
 };
 var restoreExpandedFullPageScreenshot = async (page, state2 = {}) => {
-  await page.evaluate((className) => {
-    const targets = new Set([
-      ...document.querySelectorAll(`.${className}`),
-      document.documentElement,
-      document.body,
-      document.scrollingElement
-    ].filter((el) => el?.classList?.contains(className)));
-    targets.forEach((el) => {
-      el.style.setProperty("overflow", el.dataset.pkOrigOverflow || "", el.dataset.pkOrigOverflowPriority || "");
-      el.style.setProperty("height", el.dataset.pkOrigHeight || "", el.dataset.pkOrigHeightPriority || "");
-      el.style.setProperty("min-height", el.dataset.pkOrigMinHeight || "", el.dataset.pkOrigMinHeightPriority || "");
-      el.style.setProperty("max-height", el.dataset.pkOrigMaxHeight || "", el.dataset.pkOrigMaxHeightPriority || "");
-      delete el.dataset.pkOrigOverflow;
-      delete el.dataset.pkOrigOverflowPriority;
-      delete el.dataset.pkOrigHeight;
-      delete el.dataset.pkOrigHeightPriority;
-      delete el.dataset.pkOrigMinHeight;
-      delete el.dataset.pkOrigMinHeightPriority;
-      delete el.dataset.pkOrigMaxHeight;
-      delete el.dataset.pkOrigMaxHeightPriority;
-      el.classList.remove(className);
-    });
-  }, EXPANDED_SCROLLABLE_CLASS);
-  if (state2?.originalViewport && state2?.viewportResized) {
-    await page.setViewportSize(state2.originalViewport);
+  const frames = Array.isArray(state2.frames) ? [...state2.frames].reverse() : typeof page.frames === "function" ? [...page.frames()].reverse() : [];
+  for (const frame of frames) {
+    await restoreExpandedStateInContext(frame);
   }
 };
-var resolveVirtualizedScrollTarget = async (page, options = {}) => {
-  const stitchMode = resolveStitchMode(options);
-  if (stitchMode === "off") return null;
-  const device = await resolvePageDevice(page);
-  if (stitchMode !== "force" && device !== Device.Mobile) {
-    return null;
-  }
-  return await page.evaluate((config) => {
-    const viewportWidth = window.innerWidth || document.documentElement?.clientWidth || document.body?.clientWidth || 0;
-    const viewportHeight = window.innerHeight || document.documentElement?.clientHeight || document.body?.clientHeight || 0;
-    const root = document.documentElement;
-    const body = document.body;
-    const scrollingElement = document.scrollingElement;
-    const candidates = [];
-    const seen = /* @__PURE__ */ new Set();
-    const scrollableOverflow = /* @__PURE__ */ new Set(["auto", "scroll", "overlay"]);
-    const clippingOverflow = /* @__PURE__ */ new Set(["hidden", "clip"]);
-    const pushCandidate = (el2) => {
-      if (!el2 || seen.has(el2)) return;
-      seen.add(el2);
-      candidates.push(el2);
-    };
-    pushCandidate(scrollingElement);
-    pushCandidate(root);
-    pushCandidate(body);
-    document.querySelectorAll("*").forEach(pushCandidate);
-    const isDocumentElement = (el2) => el2 === root || el2 === body || el2 === scrollingElement;
-    const isVisible = (el2, style, rect) => {
-      if (!el2 || !style || !rect) return false;
-      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") return false;
-      if (Number(style.opacity) === 0) return false;
-      return rect.width > 0 && rect.height > 0;
-    };
-    const hasOverflowValue = (style, values) => {
-      const overflowY = String(style?.overflowY || "").toLowerCase();
-      const overflow = String(style?.overflow || "").toLowerCase();
-      return values.has(overflowY) || values.has(overflow);
-    };
-    const looksScrollable = (el2, style) => {
-      if (!el2 || el2.scrollHeight <= el2.clientHeight + 1) return false;
-      if (isDocumentElement(el2)) return true;
-      return hasOverflowValue(style, scrollableOverflow) || hasOverflowValue(style, clippingOverflow);
-    };
-    const textHeightFor = (el2) => {
-      const nodes = isDocumentElement(el2) ? document.querySelectorAll("body *") : el2.querySelectorAll("*");
-      let textHeight = 0;
-      let textNodes = 0;
-      const maxNodes = 3500;
-      for (const node of nodes) {
-        if (textNodes >= maxNodes) break;
-        const text = String(node.textContent || "").replace(/\s+/g, " ").trim();
-        if (text.length < 2) continue;
-        let childHasText = false;
-        for (const child of node.children || []) {
-          if (String(child.textContent || "").replace(/\s+/g, " ").trim().length >= 2) {
-            childHasText = true;
-            break;
-          }
-        }
-        if (childHasText) continue;
-        const style = window.getComputedStyle(node);
-        const rect = node.getBoundingClientRect();
-        if (!isVisible(node, style, rect)) continue;
-        textNodes += 1;
-        textHeight += Math.min(Math.ceil(rect.height || 0), 900);
-      }
-      return { textHeight, textNodes };
-    };
-    const resolveEdgeOcclusion = () => {
-      let top = 0;
-      let bottom = 0;
-      const maxHeight = Math.max(48, viewportHeight * 0.45);
-      document.querySelectorAll("*").forEach((el2) => {
-        const style = window.getComputedStyle(el2);
-        const position = String(style.position || "").toLowerCase();
-        if (position !== "fixed" && position !== "sticky") return;
-        const rect = el2.getBoundingClientRect();
-        if (!isVisible(el2, style, rect)) return;
-        if (rect.height <= 0 || rect.height > maxHeight) return;
-        if (rect.width < viewportWidth * 0.35) return;
-        if (rect.top <= Math.max(16, viewportHeight * 0.08)) {
-          top = Math.max(top, Math.ceil(rect.bottom));
-        }
-        if (rect.bottom >= viewportHeight - Math.max(16, viewportHeight * 0.08)) {
-          bottom = Math.max(bottom, Math.ceil(viewportHeight - rect.top));
-        }
-      });
-      return {
-        top: Math.max(0, Math.min(Math.ceil(top), Math.floor(viewportHeight * 0.45))),
-        bottom: Math.max(0, Math.min(Math.ceil(bottom), Math.floor(viewportHeight * 0.45)))
-      };
-    };
-    let best = null;
-    candidates.forEach((el2) => {
-      const style = window.getComputedStyle(el2);
-      const rect = isDocumentElement(el2) ? {
-        top: 0,
-        bottom: viewportHeight,
-        left: 0,
-        right: viewportWidth,
-        width: viewportWidth,
-        height: viewportHeight
-      } : el2.getBoundingClientRect();
-      if (!isDocumentElement(el2) && !isVisible(el2, style, rect)) return;
-      if (!looksScrollable(el2, style)) return;
-      const scrollHeight = Math.ceil(el2.scrollHeight || 0);
-      const clientHeight = Math.ceil(el2.clientHeight || viewportHeight || 0);
-      if (scrollHeight < Math.max(900, clientHeight * config.minScrollRatio)) return;
-      const visibleTop = Math.max(0, Math.round(rect.top || 0));
-      const visibleBottom = Math.min(viewportHeight, Math.round(rect.bottom || viewportHeight));
-      const visibleHeight = Math.max(0, visibleBottom - visibleTop);
-      const minVisibleHeight = Math.max(
-        config.minVisibleHeightPx,
-        Math.floor(viewportHeight * config.minVisibleHeightRatio)
-      );
-      if (!config.force && !isDocumentElement(el2) && visibleHeight < minVisibleHeight) return;
-      const { textHeight, textNodes } = textHeightFor(el2);
-      const sparseRatio = scrollHeight / Math.max(1, textHeight);
-      const sparse = config.force || textNodes > 0 && sparseRatio >= config.minSparseRatio && scrollHeight - textHeight > clientHeight;
-      if (!sparse) return;
-      const visibleWidth = Math.max(1, Math.ceil(rect.width || viewportWidth || 1));
-      const score2 = scrollHeight * Math.min(visibleWidth, viewportWidth || visibleWidth) * Math.min(1, visibleHeight / Math.max(1, viewportHeight));
-      if (!best || score2 > best.score) {
-        best = {
-          el: el2,
-          score: score2,
-          kind: isDocumentElement(el2) ? "document" : "element",
-          scrollHeight,
-          clientHeight,
-          scrollTop: Math.max(0, Math.round(el2.scrollTop || 0)),
-          rect: {
-            top: Math.max(0, Math.round(rect.top || 0)),
-            bottom: Math.min(viewportHeight, Math.round(rect.bottom || viewportHeight)),
-            left: Math.max(0, Math.round(rect.left || 0)),
-            width: Math.max(1, Math.round(rect.width || viewportWidth || 1)),
-            height: Math.max(1, Math.round(rect.height || viewportHeight || 1))
-          },
-          visibleHeight,
-          textHeight,
-          textNodes,
-          sparseRatio
-        };
-      }
-    });
-    if (!best) return null;
-    document.querySelectorAll(`[${config.attrName}="1"]`).forEach((node) => {
-      node.removeAttribute(config.attrName);
-    });
-    if (best.kind === "element") {
-      best.el.setAttribute(config.attrName, "1");
-    }
-    const { el, score, ...target } = best;
-    return {
-      ...target,
-      viewport: {
-        width: Math.max(1, Math.ceil(viewportWidth || best.rect.width || 1)),
-        height: Math.max(1, Math.ceil(viewportHeight || best.rect.height || 1))
-      },
-      edgeOcclusion: resolveEdgeOcclusion()
-    };
-  }, {
-    attrName: STITCH_SCROLL_TARGET_ATTR,
-    force: stitchMode === "force",
-    minScrollRatio: MIN_VIRTUALIZED_SCROLL_RATIO,
-    minSparseRatio: MIN_SPARSE_SCROLL_RATIO,
-    minVisibleHeightPx: MIN_STITCH_VISIBLE_HEIGHT_PX,
-    minVisibleHeightRatio: MIN_STITCH_VISIBLE_HEIGHT_RATIO
-  }).catch((error) => {
-    logger.warning(`\u865A\u62DF\u6EDA\u52A8\u622A\u56FE\u63A2\u6D4B\u5931\u8D25: ${error?.message || error}`);
-    return null;
-  });
-};
-var setStitchScrollTop = async (page, target, scrollTop) => {
-  await page.evaluate(({ attrName, kind, top }) => {
-    const el = kind === "document" ? document.scrollingElement || document.documentElement || document.body : document.querySelector(`[${attrName}="1"]`);
-    if (!el) return;
-    el.scrollTop = Math.max(0, Math.round(Number(top) || 0));
-    el.dispatchEvent(new Event("scroll", { bubbles: true }));
-    window.dispatchEvent(new Event("scroll"));
-  }, {
-    attrName: STITCH_SCROLL_TARGET_ATTR,
-    kind: target.kind,
-    top: scrollTop
-  });
-};
-var cleanupStitchTarget = async (page) => {
-  await page.evaluate((attrName) => {
-    document.querySelectorAll(`[${attrName}="1"]`).forEach((node) => {
-      node.removeAttribute(attrName);
-    });
-  }, STITCH_SCROLL_TARGET_ATTR).catch(() => {
-  });
-};
-var cropImage = (image, crop) => image.clone().crop({
-  x: Math.max(0, Math.round(crop.x || 0)),
-  y: Math.max(0, Math.round(crop.y || 0)),
-  w: Math.max(1, Math.round(crop.w || 1)),
-  h: Math.max(1, Math.round(crop.h || 1))
-});
-var captureStitchedScrollableScreenshot = async (page, target, options = {}) => {
-  const maxHeight = toPositiveInteger(options.maxHeight, DEFAULT_MAX_HEIGHT);
-  const settleMs = Math.max(0, Number(options.stitchSettleMs ?? DEFAULT_STITCH_SETTLE_MS) || 0);
-  const overlapPx = Math.max(0, Math.round(Number(options.stitchOverlapPx ?? DEFAULT_STITCH_OVERLAP_PX) || 0));
-  const viewport = target.viewport || await resolveCurrentViewportSize(page);
-  const rect = target.rect || {
-    top: 0,
-    bottom: viewport.height,
-    left: 0,
-    width: viewport.width,
-    height: viewport.height
-  };
-  const edge = target.edgeOcclusion || { top: 0, bottom: 0 };
-  const topCrop = Math.max(0, Math.min(rect.top, viewport.height - 1));
-  const topOverlay = Math.max(topCrop, Math.min(edge.top || 0, viewport.height - 1));
-  const bottomOverlay = Math.max(0, Math.min(edge.bottom || 0, viewport.height - topOverlay - 1));
-  const middleCropY = Math.max(topCrop, topOverlay);
-  const middleCropBottom = Math.max(
-    middleCropY + 1,
-    Math.min(rect.bottom || viewport.height, viewport.height - bottomOverlay)
-  );
-  const middleCropHeight = Math.max(1, middleCropBottom - middleCropY);
-  const scrollStep = Math.max(120, middleCropHeight - overlapPx);
-  const maxScrollTop = Math.max(0, Math.ceil(target.scrollHeight - target.clientHeight));
-  const positions = [];
-  for (let top = 0; top < maxScrollTop; top += scrollStep) {
-    positions.push(Math.round(top));
-  }
-  if (!positions.includes(maxScrollTop)) {
-    positions.push(maxScrollTop);
-  }
-  if (positions.length === 0) {
-    positions.push(0);
-  }
-  const segments = [];
-  let totalHeight = 0;
-  let outputWidth = Math.max(1, Math.round(viewport.width || rect.width || 1));
+var captureExpandedFullPageScreenshotOnce = async (page, options = {}) => {
+  const originalViewport = await resolveCurrentViewportSize(page).catch(() => null);
+  const originalMainScroll = await readMainFrameScroll(page);
+  let state2 = null;
+  let viewportResized = false;
   try {
-    for (let index = 0; index < positions.length && totalHeight < maxHeight; index += 1) {
-      const isFirst = index === 0;
-      const isLast = index === positions.length - 1;
-      await setStitchScrollTop(page, target, positions[index]);
-      if (settleMs > 0) {
-        await delay(settleMs);
-      }
-      const buffer = await capturePageScreenshot(page, {
-        type: options.type || "png",
-        quality: options.quality,
-        timeout: options.timeout
+    await freezeViewportMetrics(page);
+    state2 = await prepareExpandedFullPageScreenshot(page, options);
+    const targetHeight = Math.max(1, Math.ceil(state2.targetHeight || options.maxHeight || DEFAULT_MAX_HEIGHT));
+    if (originalViewport?.width && originalViewport?.height && targetHeight > Math.ceil(originalViewport.height) + 1) {
+      await page.setViewportSize({
+        width: Math.ceil(originalViewport.width),
+        height: targetHeight
       });
-      const image = await Jimp.read(buffer);
-      outputWidth = Math.min(outputWidth, image.bitmap.width);
-      const cropY = isFirst ? 0 : middleCropY;
-      const cropBottom = isLast ? image.bitmap.height : middleCropBottom;
-      let cropHeight = Math.max(1, Math.min(image.bitmap.height, cropBottom) - cropY);
-      const remaining = maxHeight - totalHeight;
-      if (cropHeight > remaining) {
-        cropHeight = remaining;
-      }
-      segments.push(cropImage(image, {
-        x: 0,
-        y: cropY,
-        w: outputWidth,
-        h: cropHeight
-      }));
-      totalHeight += cropHeight;
+      viewportResized = true;
+      if (state2.settleMs > 0) await delay(state2.settleMs);
     }
-    const canvas = new Jimp({
-      width: outputWidth,
-      height: Math.max(1, totalHeight),
-      color: 4294967295
+    return await capturePageScreenshot(page, {
+      ...options,
+      fullPage: true,
+      maxClipHeight: targetHeight
     });
-    let y = 0;
-    for (const segment of segments) {
-      canvas.composite(segment, 0, y);
-      y += segment.bitmap.height;
+  } finally {
+    if (options.restore) {
+      await restoreExpandedFullPageScreenshot(page, state2);
+      if (viewportResized && originalViewport?.width && originalViewport?.height) {
+        await page.setViewportSize({
+          width: Math.ceil(originalViewport.width),
+          height: Math.ceil(originalViewport.height)
+        }).catch((error) => {
+          logger.warning(`\u6062\u590D viewport \u5931\u8D25: ${error?.message || error}`);
+        });
+      }
     }
-    logger.info(
-      `\u865A\u62DF\u6EDA\u52A8\u5206\u6BB5\u622A\u56FE: segments=${segments.length}, height=${totalHeight}, scrollHeight=${target.scrollHeight}, textNodes=${target.textNodes}, sparseRatio=${Number(target.sparseRatio || 0).toFixed(2)}`
-    );
-    const expectedHeight = Math.min(maxHeight, Math.max(target.scrollHeight || 0, viewport.height || 0));
-    const minPlausibleHeight = Math.max(
-      Math.floor((viewport.height || rect.height || 0) * MIN_STITCH_OUTPUT_VIEWPORT_RATIO),
-      Math.floor(expectedHeight * MIN_STITCH_OUTPUT_HEIGHT_RATIO)
-    );
-    if (positions.length > 1 && expectedHeight > (viewport.height || rect.height || 0) * 1.3 && totalHeight < minPlausibleHeight) {
-      logger.warning(
-        `\u865A\u62DF\u6EDA\u52A8\u5206\u6BB5\u622A\u56FE\u7ED3\u679C\u8FC7\u77ED\uFF0C\u964D\u7EA7\u666E\u901A\u957F\u622A\u56FE: segments=${segments.length}, height=${totalHeight}, expectedMin=${minPlausibleHeight}, scrollHeight=${target.scrollHeight}, rect=${rect.width}x${rect.height}@${rect.top}`
-      );
-      return null;
+    await restoreViewportMetrics(page);
+    if (options.restore) {
+      await restoreMainFrameScroll(page, originalMainScroll);
     }
-    return await canvas.getBuffer(JimpMime.png);
-  } finally {
-    await setStitchScrollTop(page, target, target.scrollTop || 0).catch(() => {
-    });
-    await cleanupStitchTarget(page);
   }
 };
-var isLightBlankPixel = ({ r, g, b }) => {
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  return max >= 238 && max - min <= 18;
-};
 var isDarkBlankPixel = ({ r, g, b }) => {
   const max = Math.max(r, g, b);
   const min = Math.min(r, g, b);
   return max <= 34 && max - min <= 10;
 };
-var isLowInfoPixel = ({ r, g, b }) => {
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  return max - min <= 12;
-};
 var analyzeScreenshotBuffer = async (buffer) => {
   const image = await Jimp.read(buffer);
-  const width = image.bitmap.width;
-  const height = image.bitmap.height;
+  const { width, height } = image.bitmap;
   const stepY = Math.max(1, Math.floor(height / 900));
   const stepX = Math.max(1, Math.floor(width / 420));
-  const rows = [];
-  let lightRows = 0;
   let darkRows = 0;
-  let lowInfoRows = 0;
   let loadingLikeRows = 0;
-  const rowFlags = [];
+  let rows = 0;
   for (let y = 0; y < height; y += stepY) {
-    let light = 0;
+    rows += 1;
     let dark = 0;
-    let lowInfo = 0;
     let edge = 0;
     let count = 0;
     let prev = null;
     for (let x = 0; x < width; x += stepX) {
       const rgba = intToRGBA(image.getPixelColor(x, y));
       count += 1;
-      if (isLightBlankPixel(rgba)) light += 1;
       if (isDarkBlankPixel(rgba)) dark += 1;
-      if (isLowInfoPixel(rgba)) lowInfo += 1;
       if (prev) {
         const diff = Math.abs(rgba.r - prev.r) + Math.abs(rgba.g - prev.g) + Math.abs(rgba.b - prev.b);
         if (diff > 45) edge += 1;
       }
       prev = rgba;
     }
-    const stat = {
-      y,
-      lightRatio: light / Math.max(1, count),
-      darkRatio: dark / Math.max(1, count),
-      lowInfoRatio: lowInfo / Math.max(1, count),
-      edgeRatio: edge / Math.max(1, count - 1)
-    };
-    rows.push(stat);
-    const lightBlank = stat.lightRatio >= 0.965 && stat.edgeRatio <= 0.015;
-    const darkBlank = stat.darkRatio >= 0.965 && stat.edgeRatio <= 0.012;
-    const lowInfoBlank = stat.lowInfoRatio >= 0.965 && stat.edgeRatio <= 0.012;
-    const loadingLike = stat.darkRatio >= 0.88 && stat.edgeRatio <= 0.025;
-    if (lightBlank) lightRows += 1;
-    if (darkBlank) darkRows += 1;
-    if (lowInfoBlank) lowInfoRows += 1;
-    if (loadingLike) loadingLikeRows += 1;
-    rowFlags.push({ lightBlank, darkBlank, lowInfoBlank, loadingLike });
-  }
-  const sampledRows = Math.max(1, rows.length);
+    const darkRatio = dark / Math.max(1, count);
+    const edgeRatio = edge / Math.max(1, count - 1);
+    if (darkRatio >= 0.965 && edgeRatio <= 0.012) darkRows += 1;
+    if (darkRatio >= 0.88 && edgeRatio <= 0.025) loadingLikeRows += 1;
+  }
+  const sampledRows = Math.max(1, rows);
   return {
-    image,
     width,
     height,
-    lightBlankRowsRatio: lightRows / sampledRows,
     darkBlankRowsRatio: darkRows / sampledRows,
-    lowInfoRowsRatio: lowInfoRows / sampledRows,
-    loadingLikeRowsRatio: loadingLikeRows / sampledRows,
-    rowFlags
+    loadingLikeRowsRatio: loadingLikeRows / sampledRows
   };
 };
 var resolveScreenshotQualityIssue = (analysis) => {
@@ -1512,109 +1117,6 @@ var resolveScreenshotQualityIssue = (analysis) => {
   }
   return null;
 };
-var cropBufferToContentBounds = async (buffer, bounds, options = {}) => {
-  if (!bounds || bounds.nodes <= 0) return buffer;
-  const image = options.image || await Jimp.read(buffer);
-  const width = image.bitmap.width;
-  const height = image.bitmap.height;
-  const safeLeft = Math.max(0, Math.min(width - 1, Math.floor(bounds.left || 0)));
-  const safeRight = Math.max(safeLeft + 1, Math.min(width, Math.ceil(bounds.right || width)));
-  const safeTop = Math.max(0, Math.min(height - 1, Math.floor(bounds.top || 0)));
-  const safeBottom = Math.max(safeTop + 1, Math.min(height, Math.ceil(bounds.bottom || height)));
-  const cropW = safeRight - safeLeft;
-  const cropH = safeBottom - safeTop;
-  const shouldCropX = cropW > 80 && cropW <= width * 0.82 && (safeLeft > width * 0.04 || width - safeRight > width * 0.04);
-  const shouldCropY = cropH > 160 && cropH <= height * 0.88 && height - safeBottom > Math.max(320, height * 0.1);
-  if (!shouldCropX && !shouldCropY) {
-    return buffer;
-  }
-  const x = shouldCropX ? safeLeft : 0;
-  const y = shouldCropY ? safeTop : 0;
-  const w = shouldCropX ? cropW : width;
-  const h = shouldCropY ? cropH : height;
-  logger.info(`\u5185\u5BB9\u611F\u77E5\u88C1\u526A\u622A\u56FE: x=${x}, y=${y}, w=${w}, h=${h}, original=${width}x${height}`);
-  return await cropImage(image, { x, y, w, h }).getBuffer(JimpMime.png);
-};
-var captureExpandedFullPageScreenshotOnce = async (page, options = {}) => {
-  const stitchedTarget = await resolveVirtualizedScrollTarget(page, options);
-  if (stitchedTarget) {
-    const buffer = await captureStitchedScrollableScreenshot(page, stitchedTarget, options);
-    if (buffer) {
-      return buffer;
-    }
-  }
-  const state2 = await prepareExpandedFullPageScreenshot(page, options);
-  try {
-    const buffer = await capturePageScreenshot(page, {
-      fullPage: true,
-      type: options.type || "png",
-      quality: options.quality,
-      timeout: options.timeout,
-      maxClipHeight: state2.targetHeight
-    });
-    return await cropBufferToContentBounds(buffer, state2.contentBounds);
-  } finally {
-    await restoreAffixedElementsForExpandedScreenshot(page).catch((error) => {
-      logger.warning(`\u79FB\u52A8\u7AEF\u5438\u9644\u5143\u7D20\u6062\u590D\u5931\u8D25: ${error?.message || error}`);
-    });
-    if (options.restore) {
-      await restoreExpandedFullPageScreenshot(page, state2);
-    }
-  }
-};
-var capturePageScreenshot = async (page, options = {}) => {
-  const fullPage = Boolean(options.fullPage);
-  const type = fullPage ? FORCED_FULLPAGE_TYPE : normalizeType(options.type);
-  const quality = fullPage ? FORCED_FULLPAGE_QUALITY : normalizeQuality(options.quality, type);
-  const timeout = toPositiveNumber(options.timeout, DEFAULT_TIMEOUT_MS);
-  const maxClipHeight = Math.round(toPositiveNumber(options.maxClipHeight, 0));
-  const fallbackOptions = {
-    type: type === "webp" ? "png" : type,
-    fullPage
-  };
-  if (quality !== void 0 && fallbackOptions.type === "jpeg") {
-    fallbackOptions.quality = quality;
-  }
-  if (timeout > 0) {
-    fallbackOptions.timeout = timeout;
-  }
-  try {
-    const context = page && typeof page.context === "function" ? page.context() : null;
-    if (!context || typeof context.newCDPSession !== "function") {
-      throw new Error("CDP session is not available");
-    }
-    const session = await context.newCDPSession(page);
-    try {
-      const metrics = await session.send("Page.getLayoutMetrics");
-      const viewport = await resolveCurrentViewportSize(page);
-      const captureParams = {
-        format: type,
-        fromSurface: true,
-        captureBeyondViewport: fullPage,
-        optimizeForSpeed: true
-      };
-      if (quality !== void 0) {
-        captureParams.quality = quality;
-      }
-      if (fullPage) {
-        captureParams.clip = buildFullPageClip(metrics, viewport, maxClipHeight);
-      }
-      const result = await session.send("Page.captureScreenshot", captureParams);
-      if (!result || typeof result.data !== "string" || !result.data) {
-        throw new Error("CDP returned empty screenshot data");
-      }
-      return Buffer.from(result.data, "base64");
-    } finally {
-      if (typeof session.detach === "function") {
-        await session.detach().catch(() => {
-        });
-      }
-    }
-  } catch (error) {
-    logger.warning(`CDP \u622A\u56FE\u5931\u8D25\uFF0C\u56DE\u9000 page.screenshot: ${error?.message || error}`);
-    return await page.screenshot(fallbackOptions);
-  }
-};
 var captureExpandedFullPageScreenshot = async (page, options = {}) => {
   const attempts = Math.max(1, toPositiveInteger(options.qualityRetryAttempts, DEFAULT_QUALITY_RETRY_ATTEMPTS));
   const retryDelayMs = Math.max(0, Number(options.qualityRetryDelayMs ?? DEFAULT_QUALITY_RETRY_DELAY_MS) || 0);
@@ -1631,9 +1133,7 @@ var captureExpandedFullPageScreenshot = async (page, options = {}) => {
     lastBuffer = buffer;
     lastAnalysis = analysis;
     lastIssue = issue;
-    if (!issue) {
-      return buffer;
-    }
+    if (!issue) return buffer;
     if (attempt < attempts && retryDelayMs > 0) {
       logger.warning(`\u622A\u56FE\u7591\u4F3C\u5F02\u5E38(${issue})\uFF0C\u7B49\u5F85\u540E\u91CD\u8BD5: attempt=${attempt}/${attempts}`);
       await delay(retryDelayMs);
@@ -1641,7 +1141,7 @@ var captureExpandedFullPageScreenshot = async (page, options = {}) => {
   }
   if (lastIssue && lastAnalysis) {
     logger.warning(
-      `\u622A\u56FE\u8D28\u91CF\u4ECD\u5F02\u5E38(${lastIssue})\uFF0C\u8FD4\u56DE\u6700\u4F73\u53EF\u5F97\u7ED3\u679C: light=${lastAnalysis.lightBlankRowsRatio.toFixed(2)}, dark=${lastAnalysis.darkBlankRowsRatio.toFixed(2)}, loading=${lastAnalysis.loadingLikeRowsRatio.toFixed(2)}`
+      `\u622A\u56FE\u8D28\u91CF\u4ECD\u5F02\u5E38(${lastIssue})\uFF0C\u8FD4\u56DE\u6700\u4F73\u53EF\u5F97\u7ED3\u679C: dark=${lastAnalysis.darkBlankRowsRatio.toFixed(2)}, loading=${lastAnalysis.loadingLikeRowsRatio.toFixed(2)}`
     );
   }
   return lastBuffer;
@@ -2093,6 +1593,9 @@ var ProxyMeterRuntime = {
   getProxyMeterSnapshot
 };
 
+// src/internals/constants.js
+var PageRuntimeStateKey = "__playwright_toolkit_runtime_state__";
+
 // src/runtime-env.js
 var BROWSER_PROFILE_SCHEMA_VERSION = 1;
 var SUPPORTED_CLOAK_FINGERPRINT_PLATFORMS = /* @__PURE__ */ new Set(["linux", "macos", "windows"]);
@@ -9672,11 +9175,11 @@ var resolveScreenshotWatermarkifyMeta = async (page, options = {}) => {
     watermark: options.watermark,
     strip: options.strip,
     stripLogoSrc,
-    device: resolvePageDevice2(page)
+    device: resolvePageDevice(page)
   };
 };
 var buildFontFamily = () => 'MiSans, "SF Pro Display", "PingFang SC", "Helvetica Neue", Arial, sans-serif';
-var resolvePageDevice2 = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
+var resolvePageDevice = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
 var findStripSegment = (segments, kind) => {
   const found = Array.isArray(segments) ? segments.find((segment) => segment?.kind === kind) : null;
   return found && typeof found === "object" ? found : {};
@@ -10328,7 +9831,7 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null, options = {
 };
 
 // src/internals/compression.js
-import { Jimp as Jimp2, JimpMime as JimpMime2, ResizeStrategy } from "jimp";
+import { Jimp as Jimp2, JimpMime, ResizeStrategy } from "jimp";
 var logger15 = createInternalLogger("Compression");
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_SCREENSHOT_OUTPUT_TYPE = "jpeg";
@@ -10398,7 +9901,7 @@ var encodeJpeg = async (sourceImage, compression, scale, quality) => {
       mode: ResizeStrategy.BILINEAR
     });
   }
-  const buffer = await image.getBuffer(JimpMime2.jpeg, { quality });
+  const buffer = await image.getBuffer(JimpMime.jpeg, { quality });
   return {
     buffer,
     bytes: getBase64BytesFromBuffer(buffer),