@skrillex1224/playwright-toolkit 2.1.226 → 2.1.228

package/dist/index.js

@@ -439,6 +439,9 @@ function createInternalLogger(moduleName, explicitLogger) {
   };
 }
 
+// src/internals/screenshot.js
+import delay from "delay";
+
 // src/internals/viewport.js
 var toPositiveInt = (value) => {
   const number = Math.round(Number(value) || 0);
@@ -472,11 +475,18 @@ 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 DEFAULT_MAX_HEIGHT = 8e3;
+var DEFAULT_SETTLE_MS = 1e3;
 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;
+};
 var normalizeType = (value) => {
   const raw = String(value || "png").trim().toLowerCase();
   if (!SUPPORTED_TYPES.has(raw)) return "png";
@@ -505,6 +515,138 @@ var buildFullPageClip = (metrics, viewport, maxClipHeight) => {
     scale: 1
   };
 };
+var expandScrollableContent = async (page, options = {}) => {
+  return await page.evaluate(({ className, forceScrollableHeight, visibleOnly }) => {
+    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);
+    };
+    pushCandidate(scrollingElement);
+    pushCandidate(root);
+    pushCandidate(body);
+    document.querySelectorAll("*").forEach(pushCandidate);
+    const isDocumentElement = (el) => el === root || el === body || el === scrollingElement;
+    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 isScrollableY = (el, style) => {
+      if (!el || el.scrollHeight <= el.clientHeight + 1) {
+        return false;
+      }
+      if (isDocumentElement(el)) {
+        return true;
+      }
+      const overflowY = String(style.overflowY || "").toLowerCase();
+      const overflow = String(style.overflow || "").toLowerCase();
+      const scrollableOverflow = /* @__PURE__ */ new Set(["auto", "scroll", "overlay"]);
+      return scrollableOverflow.has(overflowY) || scrollableOverflow.has(overflow);
+    };
+    candidates.forEach((el) => {
+      const style = window.getComputedStyle(el);
+      const rect = el.getBoundingClientRect();
+      if (visibleOnly && !isVisible(el, style, rect)) {
+        return;
+      }
+      if (!isScrollableY(el, style)) {
+        return;
+      }
+      const scrollHeight = Math.ceil(el.scrollHeight || 0);
+      if (scrollHeight <= 0) {
+        return;
+      }
+      if (scrollHeight > maxHeight) {
+        maxHeight = scrollHeight;
+      }
+      if (isDocumentElement(el)) {
+        return;
+      }
+      if (!el.classList.contains(className)) {
+        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);
+      }
+      if (forceScrollableHeight) {
+        el.style.setProperty("overflow", "visible", "important");
+        el.style.setProperty("height", `${scrollHeight}px`, "important");
+        el.style.setProperty("min-height", `${scrollHeight}px`, "important");
+        el.style.setProperty("max-height", "none", "important");
+        return;
+      }
+      el.style.overflow = "visible";
+      el.style.height = "auto";
+      el.style.maxHeight = "none";
+    });
+    return maxHeight;
+  }, {
+    className: EXPANDED_SCROLLABLE_CLASS,
+    forceScrollableHeight: Boolean(options.forceScrollableHeight),
+    visibleOnly: options.visibleOnly !== false
+  });
+};
+var prepareExpandedFullPageScreenshot = async (page, options = {}) => {
+  const originalViewport = await resolveCurrentViewportSize(page);
+  const defaultBuffer = Math.round((originalViewport.height || 1080) / 2);
+  const buffer = options.buffer ?? defaultBuffer;
+  const maxHeight = toPositiveInteger(options.maxHeight, DEFAULT_MAX_HEIGHT);
+  const settleMs = Math.max(0, Number(options.settleMs ?? DEFAULT_SETTLE_MS) || 0);
+  const maxScrollHeight = await expandScrollableContent(page, {
+    forceScrollableHeight: options.forceScrollableHeight,
+    visibleOnly: options.visibleOnly !== false
+  });
+  const targetHeight = Math.min(maxScrollHeight + buffer, maxHeight);
+  await page.setViewportSize({
+    width: originalViewport.width,
+    height: targetHeight
+  });
+  if (settleMs > 0) {
+    await delay(settleMs);
+  }
+  return {
+    originalViewport,
+    maxScrollHeight,
+    targetHeight
+  };
+};
+var restoreExpandedFullPageScreenshot = async (page, state = {}) => {
+  await page.evaluate((className) => {
+    document.querySelectorAll(`.${className}`).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 (state?.originalViewport) {
+    await page.setViewportSize(state.originalViewport);
+  }
+};
 var capturePageScreenshot = async (page, options = {}) => {
   const fullPage = Boolean(options.fullPage);
   const type = fullPage ? FORCED_FULLPAGE_TYPE : normalizeType(options.type);
@@ -558,6 +700,22 @@ var capturePageScreenshot = async (page, options = {}) => {
     return await page.screenshot(fallbackOptions);
   }
 };
+var captureExpandedFullPageScreenshot = async (page, options = {}) => {
+  const state = await prepareExpandedFullPageScreenshot(page, options);
+  try {
+    return await capturePageScreenshot(page, {
+      fullPage: true,
+      type: options.type || "png",
+      quality: options.quality,
+      timeout: options.timeout,
+      maxClipHeight: state.targetHeight
+    });
+  } finally {
+    if (options.restore) {
+      await restoreExpandedFullPageScreenshot(page, state);
+    }
+  }
+};
 
 // src/errors.js
 var errors_exports = {};
@@ -2096,7 +2254,7 @@ var AntiCheat = {
 };
 
 // src/internals/humanize/desktop.js
-import delay from "delay";
+import delay2 from "delay";
 import { createCursor } from "ghost-cursor-playwright";
 var logger6 = createInternalLogger("Humanize");
 var $CursorWeakMap = /* @__PURE__ */ new WeakMap();
@@ -2328,7 +2486,7 @@ var Humanize = {
         }
         await page.mouse.wheel(0, deltaY);
         didScroll = true;
-        await delay(this.jitterMs(20 + Math.random() * 40, 0.2));
+        await delay2(this.jitterMs(20 + Math.random() * 40, 0.2));
       }
       logger6.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
       return { element, didScroll };
@@ -2357,7 +2515,7 @@ var Humanize = {
       restoreOnce.restored = true;
       if (typeof restoreOnce.do !== "function") return;
       try {
-        await delay(this.jitterMs(1e3));
+        await delay2(this.jitterMs(1e3));
         await restoreOnce.do();
       } catch (restoreError) {
         logger6.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
@@ -2365,7 +2523,7 @@ var Humanize = {
     };
     try {
       if (target == null) {
-        await delay(this.jitterMs(reactionDelay, 0.4));
+        await delay2(this.jitterMs(reactionDelay, 0.4));
         await cursor.actions.click();
         logger6.success("humanClick", "Clicked current position");
         return true;
@@ -2399,7 +2557,7 @@ var Humanize = {
       const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.3;
       const y = box.y + box.height / 2 + (Math.random() - 0.5) * box.height * 0.3;
       await cursor.actions.move({ x, y });
-      await delay(this.jitterMs(reactionDelay, 0.4));
+      await delay2(this.jitterMs(reactionDelay, 0.4));
       await cursor.actions.click();
       await restoreOnce();
       logger6.success("humanClick");
@@ -2418,7 +2576,7 @@ var Humanize = {
   async randomSleep(baseMs, jitterPercent = 0.3) {
     const ms = this.jitterMs(baseMs, jitterPercent);
     logger6.start("randomSleep", `base=${baseMs}, actual=${ms}ms`);
-    await delay(ms);
+    await delay2(ms);
     logger6.success("randomSleep");
   },
   /**
@@ -2436,7 +2594,7 @@ var Humanize = {
       const x = 100 + Math.random() * (viewportSize.width - 200);
       const y = 100 + Math.random() * (viewportSize.height - 200);
       await cursor.actions.move({ x, y });
-      await delay(this.jitterMs(600, 0.5));
+      await delay2(this.jitterMs(600, 0.5));
     }
     logger6.success("simulateGaze");
   },
@@ -2460,7 +2618,7 @@ var Humanize = {
     try {
       const locator = page.locator(selector);
       await Humanize.humanClick(page, locator);
-      await delay(this.jitterMs(200, 0.4));
+      await delay2(this.jitterMs(200, 0.4));
       for (let i = 0; i < text.length; i++) {
         const char = text[i];
         let charDelay;
@@ -2472,11 +2630,11 @@ var Humanize = {
           charDelay = this.jitterMs(baseDelay, 0.4);
         }
         await page.keyboard.type(char);
-        await delay(charDelay);
+        await delay2(charDelay);
         if (Math.random() < pauseProbability && i < text.length - 1) {
           const pauseTime = this.jitterMs(pauseBase, 0.5);
           logger6.debug(`\u505C\u987F ${pauseTime}ms...`);
-          await delay(pauseTime);
+          await delay2(pauseTime);
         }
       }
       logger6.success("humanType");
@@ -2485,6 +2643,43 @@ var Humanize = {
       throw error;
     }
   },
+  /**
+   * 人类化按键 - 模拟用户在当前焦点或指定目标上按下一次键。
+   * @param {import('playwright').Page} page
+   * @param {string|import('playwright').ElementHandle|import('playwright').Locator} targetOrKey - 目标或按键
+   * @param {string|Object} [maybeKey] - 按键或选项
+   * @param {Object} [options]
+   */
+  async humanPress(page, targetOrKey, maybeKey, options = {}) {
+    const hasTarget = typeof maybeKey === "string";
+    const key = hasTarget ? maybeKey : targetOrKey;
+    const pressOptions = hasTarget ? options : maybeKey || options;
+    const {
+      reactionDelay = 180,
+      holdDelay = 45,
+      focusDelay = 180,
+      scrollIfNeeded = true,
+      throwOnMissing = true,
+      keyboardOptions = {}
+    } = pressOptions || {};
+    const targetDesc = hasTarget ? typeof targetOrKey === "string" ? targetOrKey : "ElementHandle" : "current focus";
+    logger6.start("humanPress", `key=${key}, target=${targetDesc}`);
+    try {
+      if (hasTarget) {
+        await this.humanClick(page, targetOrKey, { reactionDelay: focusDelay, scrollIfNeeded, throwOnMissing });
+      }
+      await delay2(this.jitterMs(reactionDelay, 0.45));
+      await page.keyboard.press(key, {
+        ...keyboardOptions,
+        delay: this.jitterMs(holdDelay, 0.5)
+      });
+      logger6.success("humanPress");
+      return true;
+    } catch (error) {
+      logger6.fail("humanPress", error);
+      throw error;
+    }
+  },
   /**
    * 人类化清空输入框 - 模拟人类删除文本的行为
    * @param {import('playwright').Page} page
@@ -2495,14 +2690,14 @@ var Humanize = {
     try {
       const locator = page.locator(selector);
       await locator.click();
-      await delay(this.jitterMs(200, 0.4));
+      await delay2(this.jitterMs(200, 0.4));
       const currentValue = await locator.inputValue();
       if (!currentValue || currentValue.length === 0) {
         logger6.success("humanClear", "already empty");
         return;
       }
       await page.keyboard.press("Meta+A");
-      await delay(this.jitterMs(100, 0.4));
+      await delay2(this.jitterMs(100, 0.4));
       await page.keyboard.press("Backspace");
       logger6.success("humanClear");
     } catch (error) {
@@ -2528,13 +2723,13 @@ var Humanize = {
           const x = 100 + Math.random() * (viewportSize.width - 200);
           const y = 100 + Math.random() * (viewportSize.height - 200);
           await cursor.actions.move({ x, y });
-          await delay(this.jitterMs(350, 0.4));
+          await delay2(this.jitterMs(350, 0.4));
         } else if (action < 0.7) {
           const scrollY = (Math.random() - 0.5) * 200;
           await page.mouse.wheel(0, scrollY);
-          await delay(this.jitterMs(500, 0.4));
+          await delay2(this.jitterMs(500, 0.4));
         } else {
-          await delay(this.jitterMs(800, 0.5));
+          await delay2(this.jitterMs(800, 0.5));
         }
       }
       logger6.success("warmUpBrowsing");
@@ -2563,7 +2758,7 @@ var Humanize = {
         const scrollAmount = stepDistance * factor * sign * jitter;
         await page.mouse.wheel(0, scrollAmount);
         const baseDelay = 60 + i * 25;
-        await delay(this.jitterMs(baseDelay, 0.3));
+        await delay2(this.jitterMs(baseDelay, 0.3));
       }
       logger6.success("naturalScroll");
     } catch (error) {
@@ -2573,8 +2768,143 @@ var Humanize = {
   }
 };
 
+// src/internals/humanize/machine.js
+var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
+var isPoint = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
+var resolveNativeTarget = (page, target) => {
+  if (!target) return null;
+  if (typeof target === "string") {
+    return page.locator(target);
+  }
+  return target;
+};
+var normalizeSelectorOptions = (options = {}) => ({
+  targetParent: Boolean(options.targetParent ?? options.parent ?? false),
+  pick: options.pick === "last" || options.last ? "last" : "first",
+  visibleOnly: options.visibleOnly !== false,
+  fallbackDomClick: Boolean(options.fallbackDomClick),
+  forceMouse: Boolean(options.forceMouse)
+});
+var MachineHumanize = {
+  async clickPoint(page, pointOrX, maybeY, options = {}) {
+    const clickOptions = isPoint(pointOrX) && maybeY && typeof maybeY === "object" ? maybeY : options;
+    const point = isPoint(pointOrX) ? pointOrX : { x: pointOrX, y: maybeY };
+    const x = Number(point.x);
+    const y = Number(point.y);
+    if (!Number.isFinite(x) || !Number.isFinite(y)) {
+      throw new Error(`Invalid click point: ${JSON.stringify(point)}`);
+    }
+    const resolvedDevice = resolveDeviceFromPage(page);
+    if (resolvedDevice === Device.Mobile && !clickOptions.forceMouse && page.touchscreen && typeof page.touchscreen.tap === "function") {
+      await page.touchscreen.tap(x, y);
+      return true;
+    }
+    await page.mouse.click(x, y, clickOptions.mouseOptions || {});
+    return true;
+  },
+  async click(page, target, options = {}) {
+    if (isPoint(target)) {
+      return MachineHumanize.clickPoint(page, target, void 0, options);
+    }
+    const nativeTarget = resolveNativeTarget(page, target);
+    if (!nativeTarget || typeof nativeTarget.click !== "function") {
+      throw new Error("Machine click target does not expose click()");
+    }
+    await nativeTarget.click(options.clickOptions || options);
+    return true;
+  },
+  async focus(page, target, options = {}) {
+    const nativeTarget = resolveNativeTarget(page, target);
+    if (!nativeTarget || typeof nativeTarget.focus !== "function") {
+      throw new Error("Machine focus target does not expose focus()");
+    }
+    await nativeTarget.focus(options);
+    return true;
+  },
+  async fill(page, target, value, options = {}) {
+    const nativeTarget = resolveNativeTarget(page, target);
+    if (!nativeTarget || typeof nativeTarget.fill !== "function") {
+      throw new Error("Machine fill target does not expose fill()");
+    }
+    await nativeTarget.fill(value, options);
+    return true;
+  },
+  async keyboardType(page, text, options = {}) {
+    await page.keyboard.type(text, options);
+    return true;
+  },
+  async type(page, targetOrText, maybeText, options = {}) {
+    if (maybeText == null || typeof maybeText === "object" && !Array.isArray(maybeText)) {
+      return MachineHumanize.keyboardType(page, targetOrText, maybeText || options);
+    }
+    const nativeTarget = resolveNativeTarget(page, targetOrText);
+    if (!nativeTarget || typeof nativeTarget.type !== "function") {
+      throw new Error("Machine type target does not expose type()");
+    }
+    await nativeTarget.type(maybeText, options);
+    return true;
+  },
+  async selectorCenterPoint(page, selector, options = {}) {
+    const normalizedOptions = normalizeSelectorOptions(options);
+    return page.evaluate(({ innerSelector, innerOptions }) => {
+      const nodes = Array.from(document.querySelectorAll(innerSelector));
+      const ordered = innerOptions.pick === "last" ? nodes.reverse() : nodes;
+      let rect = null;
+      for (const node of ordered) {
+        if (!node) continue;
+        const target = innerOptions.targetParent ? node.parentElement || node : node;
+        rect = target.getBoundingClientRect?.() || null;
+        const isVisible = Boolean(rect && rect.width > 0 && rect.height > 0);
+        if (innerOptions.visibleOnly && !isVisible) continue;
+        break;
+      }
+      if (!rect || rect.width <= 0 || rect.height <= 0) return null;
+      return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2
+      };
+    }, { innerSelector: selector, innerOptions: normalizedOptions });
+  },
+  async domClick(page, selector, options = {}) {
+    const normalizedOptions = normalizeSelectorOptions(options);
+    return page.evaluate(({ innerSelector, innerOptions }) => {
+      const nodes = Array.from(document.querySelectorAll(innerSelector));
+      const ordered = innerOptions.pick === "last" ? nodes.reverse() : nodes;
+      let target = null;
+      for (const node of ordered) {
+        if (!node) continue;
+        const candidate = innerOptions.targetParent ? node.parentElement || node : node;
+        const rect = candidate.getBoundingClientRect?.() || null;
+        const isVisible = Boolean(rect && rect.width > 0 && rect.height > 0);
+        if (innerOptions.visibleOnly && !isVisible) continue;
+        target = candidate;
+        break;
+      }
+      if (!target || typeof target.click !== "function") return false;
+      target.click();
+      return true;
+    }, { innerSelector: selector, innerOptions: normalizedOptions });
+  },
+  async clickSelectorCenter(page, selector, options = {}) {
+    const normalizedOptions = normalizeSelectorOptions(options);
+    try {
+      const point = await MachineHumanize.selectorCenterPoint(page, selector, normalizedOptions);
+      if (point) {
+        await MachineHumanize.clickPoint(page, point, void 0, normalizedOptions);
+        return true;
+      }
+    } catch (error) {
+      if (!normalizedOptions.fallbackDomClick) throw error;
+    }
+    if (normalizedOptions.fallbackDomClick) {
+      return MachineHumanize.domClick(page, selector, normalizedOptions);
+    }
+    return false;
+  }
+};
+
 // src/internals/humanize/shared.js
-import delay2 from "delay";
+import delay3 from "delay";
 var jitterMs = (base, jitterPercent = 0.3) => {
   const jitter = Number(base || 0) * Number(jitterPercent || 0) * (Math.random() * 2 - 1);
   return Math.max(10, Math.round(Number(base || 0) + jitter));
@@ -2600,7 +2930,7 @@ var resolveElement = async (page, target, { throwOnMissing = true } = {}) => {
   }
   return element;
 };
-var waitJitter = (base, jitterPercent = 0.3) => delay2(jitterMs(base, jitterPercent));
+var waitJitter = (base, jitterPercent = 0.3) => delay3(jitterMs(base, jitterPercent));
 
 // src/internals/humanize/mobile.js
 var logger7 = createInternalLogger("Humanize.Mobile");
@@ -2902,6 +3232,49 @@ var scrollScrollableAncestor = async (element, deltaY) => {
     };
   }, deltaY);
 };
+var scrollAwayFromObstruction = async (element, status) => {
+  return element.evaluate((el, innerStatus) => {
+    const isScrollable = (node) => {
+      const style = window.getComputedStyle(node);
+      if (!style) return false;
+      const overflowY = style.overflowY;
+      if (!["auto", "scroll", "overlay"].includes(overflowY)) return false;
+      return node.scrollHeight > node.clientHeight + 1;
+    };
+    let scroller = el;
+    while (scroller && scroller !== document.body) {
+      if (isScrollable(scroller)) break;
+      scroller = scroller.parentElement;
+    }
+    if (!scroller || scroller === document.body) {
+      return { moved: false, scrollTop: 0, deltaY: 0 };
+    }
+    const rect = el.getBoundingClientRect();
+    const scrollerRect = scroller.getBoundingClientRect();
+    const obstruction = innerStatus?.obstruction || {};
+    const obstructionTop = Number(obstruction.top);
+    const obstructionBottom = Number(obstruction.bottom);
+    const obstructionMiddle = Number.isFinite(obstructionTop) && Number.isFinite(obstructionBottom) ? (obstructionTop + obstructionBottom) / 2 : scrollerRect.top + scrollerRect.height / 2;
+    const scrollerMiddle = scrollerRect.top + scrollerRect.height / 2;
+    const padding = 18;
+    let deltaY = 0;
+    if (Number.isFinite(obstructionTop) && rect.bottom > obstructionTop && obstructionTop >= scrollerRect.top && obstructionTop <= scrollerRect.bottom && obstructionMiddle >= scrollerMiddle) {
+      deltaY = rect.bottom - obstructionTop + padding;
+    } else if (Number.isFinite(obstructionBottom) && rect.top < obstructionBottom && obstructionBottom >= scrollerRect.top && obstructionBottom <= scrollerRect.bottom && obstructionMiddle < scrollerMiddle) {
+      deltaY = rect.top - obstructionBottom - padding;
+    } else {
+      const fallbackDistance = Math.max(48, Math.min(180, scrollerRect.height * 0.45));
+      deltaY = obstructionMiddle >= scrollerMiddle ? fallbackDistance : -fallbackDistance;
+    }
+    const beforeTop = scroller.scrollTop;
+    scroller.scrollTop = beforeTop + deltaY;
+    return {
+      moved: Math.abs(scroller.scrollTop - beforeTop) > 2,
+      scrollTop: scroller.scrollTop,
+      deltaY
+    };
+  }, status);
+};
 var dispatchTouchSwipe = async (page, deltaY, options = {}) => {
   const viewport = resolveViewport(page);
   const rawRect = options.rect || null;
@@ -3065,6 +3438,15 @@ var MobileHumanize = {
         logger7.warn(`humanScroll | fixed/sticky \u76EE\u6807\u88AB\u906E\u6321\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u89E3\u9664 (${status.obstruction?.tag || "unknown"})`);
         return { element, didScroll, restore: null };
       }
+      if (scrollRect && status.code === "OBSTRUCTED" && status.obstruction?.isFixed) {
+        const moved = await scrollAwayFromObstruction(element, status);
+        if (moved.moved) {
+          logger7.debug(`humanScroll | sticky/fixed \u906E\u6321\u8865\u507F\u6EDA\u52A8 top=${Math.round(moved.scrollTop || 0)}`);
+          await waitJitter(90, 0.3);
+          didScroll = true;
+          continue;
+        }
+      }
       if (Date.now() - startTime > maxDurationMs) {
         logger7.warn(`humanScroll | mobile timeout (${maxDurationMs}ms, status=${status.code}, direction=${status.direction || "unknown"}, fixed=${Boolean(status.isFixed)})`);
         return { element, didScroll, restore: null };
@@ -3196,7 +3578,7 @@ var MobileHumanize = {
         await MobileHumanize.humanScroll(page, element, { throwOnMissing });
       }
       const status = await checkElementVisibility(element).catch(() => null);
-      if (status && (status.code === "ZERO_DIMENSIONS" || status.code === "NOT_INTERACTABLE")) {
+      if (status && status.code !== "VISIBLE") {
         const message = `\u5143\u7D20\u4E0D\u53EF\u70B9\u51FB: ${status.reason || status.code}`;
         if (throwOnMissing) throw new Error(message);
         logger7.warn(`humanClick: ${message}\uFF0C\u8DF3\u8FC7\u70B9\u51FB`);
@@ -3256,6 +3638,40 @@ var MobileHumanize = {
       }
     }
   },
+  async humanPress(page, targetOrKey, maybeKey, options = {}) {
+    const hasTarget = typeof maybeKey === "string";
+    const key = hasTarget ? maybeKey : targetOrKey;
+    const pressOptions = hasTarget ? options : maybeKey || options;
+    const {
+      reactionDelay = 170,
+      holdDelay = 42,
+      focusDelay = 180,
+      scrollIfNeeded = true,
+      throwOnMissing = true,
+      keyboardOptions = {}
+    } = pressOptions || {};
+    const targetDesc = hasTarget ? describeTarget(targetOrKey) : "current focus";
+    logger7.start("humanPress", `key=${key}, target=${targetDesc}`);
+    try {
+      if (hasTarget) {
+        await MobileHumanize.humanClick(page, targetOrKey, {
+          reactionDelay: focusDelay,
+          scrollIfNeeded,
+          throwOnMissing
+        });
+      }
+      await waitJitter(reactionDelay, 0.45);
+      await page.keyboard.press(key, {
+        ...keyboardOptions,
+        delay: jitterMs(holdDelay, 0.5)
+      });
+      logger7.success("humanPress");
+      return true;
+    } catch (error) {
+      logger7.fail("humanPress", error);
+      throw error;
+    }
+  },
   async humanClear(page, selector) {
     const locator = page.locator(selector);
     await MobileHumanize.humanClick(page, locator, { scrollIfNeeded: true });
@@ -3306,15 +3722,18 @@ var MobileHumanize = {
 };
 
 // src/humanize.js
-var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
+var resolveDeviceFromPage2 = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
 var resolveDelegate = (page) => {
-  return resolveDeviceFromPage(page) === Device.Mobile ? MobileHumanize : Humanize;
+  return resolveDeviceFromPage2(page) === Device.Mobile ? MobileHumanize : Humanize;
 };
 var callDelegate = (method, page, args) => {
   const delegate = resolveDelegate(page);
   return delegate[method](page, ...args);
 };
 var Humanize2 = {
+  // M = Machine: native/mechanical operations for兼容路径。
+  // 这组 API 不做人类化处理，只保留原生 click / focus / fill / type 等语义。
+  M: MachineHumanize,
   jitterMs(base, jitterPercent = 0.3) {
     return Humanize.jitterMs(base, jitterPercent);
   },
@@ -3343,6 +3762,12 @@ var Humanize2 = {
   humanType(page, selector, text, options = {}) {
     return callDelegate("humanType", page, [selector, text, options]);
   },
+  humanPress(page, targetOrKey, maybeKey, options = {}) {
+    if (typeof maybeKey === "string") {
+      return callDelegate("humanPress", page, [targetOrKey, maybeKey, options]);
+    }
+    return callDelegate("humanPress", page, [targetOrKey, maybeKey || options]);
+  },
   humanClear(page, selector) {
     return callDelegate("humanClear", page, [selector]);
   },
@@ -5814,7 +6239,7 @@ var Logger = {
 };
 
 // src/share.js
-import delay3 from "delay";
+import delay4 from "delay";
 
 // src/internals/watermarkify.js
 var DEFAULT_TIMEZONE_OFFSET = 8;
@@ -5848,6 +6273,18 @@ var DEFAULT_STRIP_PROMPT_MAX_LINES = 3;
 var DEFAULT_STRIP_CONTENT_SAFE_PADDING_X = 12;
 var DEFAULT_STRIP_TEXT_WIDTH_SAFETY = 10;
 var DEFAULT_BROWSER_COMPOSITOR_VIEWPORT_HEIGHT = 1200;
+var MOBILE_STRIP_HEIGHT = 104;
+var MOBILE_STRIP_PADDING_X = 14;
+var MOBILE_STRIP_PADDING_Y = 13;
+var MOBILE_STRIP_ROW_HEIGHT = 22;
+var MOBILE_STRIP_ROW_GAP = 7;
+var MOBILE_STRIP_LABEL_FONT_SIZE = 12.5;
+var MOBILE_STRIP_VALUE_FONT_SIZE = 13.5;
+var MOBILE_STRIP_LABEL_WIDTH = 45;
+var MOBILE_STRIP_PROMPT_LABEL_WIDTH = 60;
+var MOBILE_STRIP_LOC_LABEL_WIDTH = 30;
+var MOBILE_STRIP_IP_LABEL_WIDTH = 22;
+var MOBILE_STRIP_META_GAP = 12;
 var WEAK_LOCATION_VALUES = /* @__PURE__ */ new Set(["cn", "\u4E2D\u56FD"]);
 var LOCATION_NETWORK_SUFFIX_PATTERNS = [
   /(?:中国)?移动$/i,
@@ -6632,10 +7069,16 @@ var resolveScreenshotWatermarkifyMeta = async (page, options = {}) => {
     }),
     watermark: options.watermark,
     strip: options.strip,
-    stripLogoSrc
+    stripLogoSrc,
+    device: resolvePageDevice(page)
   };
 };
 var buildFontFamily = () => 'MiSans, "SF Pro Display", "PingFang SC", "Helvetica Neue", Arial, sans-serif';
+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 : {};
+};
 var buildStripSegmentLayout = (segment, options = {}) => {
   const label = normalizeWhitespace(segment?.label || "");
   const rawValue = normalizeWhitespace(segment?.rawValue || segment?.value || "-") || "-";
@@ -6963,6 +7406,116 @@ var renderStripDivider = (x, centerY, height) => {
         />
     `;
 };
+var renderMobileStripText = ({
+  label,
+  value,
+  labelX,
+  y,
+  valueWidth,
+  labelWidth = MOBILE_STRIP_LABEL_WIDTH,
+  fontFamily
+}) => {
+  const safeLabel = normalizeWhitespace(label) || "-";
+  const safeValue = fitTextWithEllipsis(
+    Array.from(normalizeWhitespace(value) || "-"),
+    Math.max(18, valueWidth),
+    MOBILE_STRIP_VALUE_FONT_SIZE
+  );
+  return `
+        <text
+            x="${labelX}"
+            y="${y}"
+            fill="#111111"
+            fill-opacity="0.54"
+            font-family="${fontFamily}"
+            font-size="${MOBILE_STRIP_LABEL_FONT_SIZE}"
+            font-weight="650"
+            dominant-baseline="middle"
+        >${escapeXml(safeLabel)}</text>
+        <text
+            x="${labelX + labelWidth}"
+            y="${y}"
+            fill="#111111"
+            font-family="${fontFamily}"
+            font-size="${MOBILE_STRIP_VALUE_FONT_SIZE}"
+            font-weight="730"
+            dominant-baseline="middle"
+        >${escapeXml(safeValue)}</text>
+    `;
+};
+var renderMobileStrip = ({ meta, width, height, fontFamily }) => {
+  const stripHeight = MOBILE_STRIP_HEIGHT;
+  const stripY = height - stripHeight;
+  const contentX = MOBILE_STRIP_PADDING_X;
+  const contentWidth = Math.max(1, width - MOBILE_STRIP_PADDING_X * 2);
+  const prompt = findStripSegment(meta.stripSegments, "prompt");
+  const time = findStripSegment(meta.stripSegments, "time");
+  const location = findStripSegment(meta.stripSegments, "location");
+  const ip = findStripSegment(meta.stripSegments, "ip");
+  const row1Y = stripY + MOBILE_STRIP_PADDING_Y + MOBILE_STRIP_ROW_HEIGHT / 2;
+  const row2Y = row1Y + MOBILE_STRIP_ROW_HEIGHT + MOBILE_STRIP_ROW_GAP;
+  const row3Y = row2Y + MOBILE_STRIP_ROW_HEIGHT + MOBILE_STRIP_ROW_GAP;
+  const promptValueWidth = contentWidth - MOBILE_STRIP_PROMPT_LABEL_WIDTH;
+  const locValueX = contentX + MOBILE_STRIP_LOC_LABEL_WIDTH;
+  const ipLabelX = Math.min(
+    width - MOBILE_STRIP_PADDING_X - MOBILE_STRIP_IP_LABEL_WIDTH - 70,
+    Math.max(
+      locValueX + 80 + MOBILE_STRIP_META_GAP,
+      contentX + Math.round(contentWidth * 0.52)
+    )
+  );
+  const locValueWidth = Math.max(
+    28,
+    ipLabelX - locValueX - MOBILE_STRIP_META_GAP
+  );
+  const ipValueWidth = Math.max(
+    28,
+    width - MOBILE_STRIP_PADDING_X - (ipLabelX + MOBILE_STRIP_IP_LABEL_WIDTH)
+  );
+  return `
+        <g id="strip">
+            <rect x="0" y="${stripY}" width="${width}" height="${stripHeight}" fill="#ffffff" fill-opacity="0.985" />
+            <rect x="0" y="${stripY}" width="${width}" height="1" fill="#111111" fill-opacity="0.10" />
+            <rect x="${contentX}" y="${stripY}" width="${Math.max(96, Math.round(width * 0.36))}" height="2" fill="url(#stripAccent)" />
+            ${renderMobileStripText({
+    label: "Prompt",
+    value: prompt.rawValue || prompt.value || "-",
+    labelX: contentX,
+    y: row1Y,
+    valueWidth: promptValueWidth,
+    labelWidth: MOBILE_STRIP_PROMPT_LABEL_WIDTH,
+    fontFamily
+  })}
+            ${renderMobileStripText({
+    label: "Time",
+    value: time.rawValue || time.value || "-",
+    labelX: contentX,
+    y: row2Y,
+    valueWidth: promptValueWidth,
+    labelWidth: MOBILE_STRIP_LABEL_WIDTH,
+    fontFamily
+  })}
+            ${renderMobileStripText({
+    label: "Loc",
+    value: location.rawValue || location.value || "-",
+    labelX: contentX,
+    y: row3Y,
+    valueWidth: locValueWidth,
+    labelWidth: MOBILE_STRIP_LOC_LABEL_WIDTH,
+    fontFamily
+  })}
+            ${renderMobileStripText({
+    label: "IP",
+    value: ip.rawValue || ip.value || "-",
+    labelX: ipLabelX,
+    y: row3Y,
+    valueWidth: ipValueWidth,
+    labelWidth: MOBILE_STRIP_IP_LABEL_WIDTH,
+    fontFamily
+  })}
+        </g>
+    `;
+};
 var buildWatermarkifySvg = (meta, imageWidth, imageHeight) => {
   const hasWatermark = meta?.watermark?.enabled !== false && normalizeText(meta?.watermarkText);
   const hasStrip = meta?.strip?.enabled !== false && Array.isArray(meta?.stripSegments) && meta.stripSegments.length > 0;
@@ -7011,6 +7564,27 @@ var buildWatermarkifySvg = (meta, imageWidth, imageHeight) => {
     parts.push(`<g id="watermarks">${stamps.join("")}</g>`);
   }
   if (hasStrip) {
+    if (normalizeDevice(meta.device) === Device.Mobile) {
+      parts.push(renderMobileStrip({
+        meta,
+        width,
+        height,
+        fontFamily
+      }));
+      return `
+                <svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+                    <defs>
+                        <linearGradient id="stripAccent" x1="0%" y1="0%" x2="100%" y2="0%">
+                            <stop offset="0%" stop-color="#111111" stop-opacity="0.98" />
+                            <stop offset="24%" stop-color="#111111" stop-opacity="0.68" />
+                            <stop offset="58%" stop-color="#111111" stop-opacity="0.08" />
+                            <stop offset="100%" stop-color="#111111" stop-opacity="0" />
+                        </linearGradient>
+                    </defs>
+                    ${parts.join("")}
+                </svg>
+            `;
+    }
     const logoSize = 28;
     const logoX = DEFAULT_STRIP_PADDING_LEFT;
     const contentStartX = logoX + logoSize + DEFAULT_STRIP_GAP;
@@ -7137,16 +7711,16 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null) => {
   return await composeScreenshotBufferWithBrowser(page, buffer, overlaySvg, imageInfo);
 };
 
-// src/internals/screenshot-compression.js
+// src/internals/compression.js
 import { Jimp, JimpMime, ResizeStrategy } from "jimp";
-var logger14 = createInternalLogger("ScreenshotCompression");
+var logger14 = createInternalLogger("Compression");
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_SCREENSHOT_OUTPUT_TYPE = "jpeg";
 var DEFAULT_SCREENSHOT_QUALITY = 0.72;
 var DEFAULT_SCREENSHOT_MIN_QUALITY = 0.38;
 var DEFAULT_SCREENSHOT_MIN_SCALE = 0.25;
 var SUPPORTED_SCREENSHOT_OUTPUT_TYPES = /* @__PURE__ */ new Set(["jpeg"]);
-var toPositiveInteger = (value, fallback = 0) => {
+var toPositiveInteger2 = (value, fallback = 0) => {
   const number = Math.floor(Number(value) || 0);
   return number > 0 ? number : fallback;
 };
@@ -7168,7 +7742,7 @@ var normalizeScreenshotOutputType = (value) => {
 };
 var getBase64BytesFromBuffer = (buffer) => Math.ceil(buffer.length / 3) * 4;
 var toJpegQuality = (value) => Math.round(normalizeQuality2(value, DEFAULT_SCREENSHOT_QUALITY) * 100);
-var resolveCaptureScreenCompression = (options = {}) => {
+var resolveImageCompression = (options = {}) => {
   const explicit = options.compression;
   const source = explicit && typeof explicit === "object" && !Array.isArray(explicit) ? explicit : {};
   const enabled = explicit !== false && source.enabled !== false && options.compress !== false;
@@ -7182,7 +7756,7 @@ var resolveCaptureScreenCompression = (options = {}) => {
   );
   return {
     enabled,
-    maxBytes: toPositiveInteger(
+    maxBytes: toPositiveInteger2(
       source.maxBytes ?? source.maxBase64Bytes ?? options.maxBytes ?? options.maxBase64Bytes,
       DEFAULT_SCREENSHOT_MAX_BYTES
     ),
@@ -7219,7 +7793,7 @@ var encodeJpeg = async (sourceImage, compression, scale, quality) => {
     format: compression.outputType
   };
 };
-var compressScreenshotBuffer = async (buffer, compression) => {
+var compressImageBuffer = async (buffer, compression) => {
   const sourceImage = await Jimp.read(buffer);
   const maxQuality = toJpegQuality(compression.quality);
   const minQuality = Math.min(maxQuality, toJpegQuality(compression.minQuality));
@@ -7252,12 +7826,12 @@ var compressScreenshotBuffer = async (buffer, compression) => {
   const fallback = !smallest || finalCandidate.bytes < smallest.bytes ? finalCandidate : smallest;
   return { ...fallback, withinLimit: fallback.bytes <= compression.maxBytes };
 };
-var compressScreenshotBufferToBase64 = async (buffer, compression) => {
+var compressImageBufferToBase64 = async (buffer, compression) => {
   const originalBytes = getBase64BytesFromBuffer(buffer);
   if (!compression.enabled || originalBytes <= compression.maxBytes) {
     return buffer.toString("base64");
   }
-  const result = await compressScreenshotBuffer(buffer, compression).catch((error) => {
+  const result = await compressImageBuffer(buffer, compression).catch((error) => {
     logger14.warning(`captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   });
@@ -7656,7 +8230,7 @@ var Share = {
           );
           nextProgressLogTs = now + 5e3;
         }
-        await delay3(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
+        await delay4(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
       }
       if (share.mode === "response" && stats.responseMatched === 0) {
         logger15.warning(
@@ -7694,71 +8268,27 @@ var Share = {
    * @returns {Promise<string>} base64 image
    */
   async captureScreen(page, options = {}) {
-    const originalViewport = await resolveCurrentViewportSize(page);
-    const defaultBuffer = Math.round((originalViewport.height || 1080) / 2);
-    const buffer = options.buffer ?? defaultBuffer;
     const restore = options.restore ?? false;
-    const maxHeight = options.maxHeight ?? 8e3;
     const screenshotWatermarkify = resolveCaptureScreenWatermarkify(page, options.watermarkify);
-    const compression = resolveCaptureScreenCompression(options);
-    try {
-      const maxScrollHeight = await page.evaluate(() => {
-        let maxHeight2 = document.body.scrollHeight;
-        document.querySelectorAll("*").forEach((el) => {
-          const style = window.getComputedStyle(el);
-          const overflowY = style.overflowY;
-          if ((overflowY === "auto" || overflowY === "scroll") && el.scrollHeight > el.clientHeight) {
-            if (el.scrollHeight > maxHeight2) {
-              maxHeight2 = el.scrollHeight;
-            }
-            el.dataset.pkOrigOverflow = el.style.overflow;
-            el.dataset.pkOrigHeight = el.style.height;
-            el.dataset.pkOrigMaxHeight = el.style.maxHeight;
-            el.classList.add("__pk_expanded__");
-            el.style.overflow = "visible";
-            el.style.height = "auto";
-            el.style.maxHeight = "none";
-          }
-        });
-        return maxHeight2;
-      });
-      const targetHeight = Math.min(maxScrollHeight + buffer, maxHeight);
-      await page.setViewportSize({
-        width: originalViewport.width,
-        height: targetHeight
-      });
-      await delay3(1e3);
-      const capturedAt = /* @__PURE__ */ new Date();
-      const rawBuffer = await capturePageScreenshot(page, {
-        fullPage: true,
-        type: "png",
-        maxClipHeight: targetHeight
+    const compression = resolveImageCompression(options);
+    const captureOptions = {
+      buffer: options.buffer ?? 0,
+      restore,
+      maxHeight: options.maxHeight,
+      type: "png",
+      visibleOnly: true
+    };
+    const capturedAt = /* @__PURE__ */ new Date();
+    const rawBuffer = await captureExpandedFullPageScreenshot(page, captureOptions);
+    let outputBuffer = rawBuffer;
+    if (screenshotWatermarkify.enabled) {
+      const watermarkifyMeta = await resolveScreenshotWatermarkifyMeta(page, {
+        ...screenshotWatermarkify,
+        capturedAt
       });
-      let outputBuffer = rawBuffer;
-      if (screenshotWatermarkify.enabled) {
-        const watermarkifyMeta = await resolveScreenshotWatermarkifyMeta(page, {
-          ...screenshotWatermarkify,
-          capturedAt
-        });
-        outputBuffer = await watermarkifyScreenshotBuffer(rawBuffer, watermarkifyMeta, page);
-      }
-      return await compressScreenshotBufferToBase64(outputBuffer, compression);
-    } finally {
-      if (restore) {
-        await page.evaluate(() => {
-          document.querySelectorAll(".__pk_expanded__").forEach((el) => {
-            el.style.overflow = el.dataset.pkOrigOverflow || "";
-            el.style.height = el.dataset.pkOrigHeight || "";
-            el.style.maxHeight = el.dataset.pkOrigMaxHeight || "";
-            delete el.dataset.pkOrigOverflow;
-            delete el.dataset.pkOrigHeight;
-            delete el.dataset.pkOrigMaxHeight;
-            el.classList.remove("__pk_expanded__");
-          });
-        });
-        await page.setViewportSize(originalViewport);
-      }
+      outputBuffer = await watermarkifyScreenshotBuffer(rawBuffer, watermarkifyMeta, page);
     }
+    return await compressImageBufferToBase64(outputBuffer, compression);
   }
 };