@skrillex1224/playwright-toolkit 2.1.246 → 2.1.247

package/dist/index.cjs

@@ -133,10 +133,10 @@ var createActorInfo = (info) => {
       xurl
     };
   };
-  const buildLandingUrl = ({ protocol: protocol2, domain: domain2, path: path4 }) => {
+  const buildLandingUrl = ({ protocol: protocol2, domain: domain2, path: path3 }) => {
     const safeProtocol = String(protocol2).trim();
     const safeDomain = normalizeDomain(domain2);
-    const safePath = normalizePath(path4);
+    const safePath = normalizePath(path3);
     return `${safeProtocol}://${safeDomain}${safePath}`;
   };
   const buildIcon = ({ key }) => {
@@ -144,14 +144,14 @@ var createActorInfo = (info) => {
   };
   const protocol = info.protocol || "https";
   const domain = normalizeDomain(info.domain);
-  const path3 = normalizePath(info.path);
+  const path2 = normalizePath(info.path);
   const share = normalizeShare2(info.share);
   const device = normalizeDevice(info.device);
   return {
     ...info,
     protocol,
     domain,
-    path: path3,
+    path: path2,
     share,
     device,
     get icon() {
@@ -1512,7 +1512,7 @@ var normalizeCookies = (value) => {
     if (!name || !cookieValue || cookieValue === "<nil>") return null;
     const domain = String(raw.domain || "").trim();
     const url = normalizeHttpUrl(raw.url);
-    const path3 = String(raw.path || "").trim() || "/";
+    const path2 = String(raw.path || "").trim() || "/";
     const sameSite = normalizeCookieSameSite(raw.sameSite);
     const expires = normalizeCookieExpires(raw);
     const secure = Boolean(raw.secure);
@@ -1521,7 +1521,7 @@ var normalizeCookies = (value) => {
     const normalized = {
       name,
       value: cookieValue,
-      path: path3,
+      path: path2,
       ...domain ? { domain } : {},
       ...!domain && url ? { url } : {},
       ...sameSite ? { sameSite } : {},
@@ -2592,10 +2592,6 @@ var assertPoint = (point) => {
     throw new Error(`Invalid input point: ${JSON.stringify(point)}`);
   }
 };
-var toFiniteNumber = (value, fallback = 0) => {
-  const number = Number(value);
-  return Number.isFinite(number) ? number : fallback;
-};
 var dispatchMouseMove = (page, point, options = {}) => page.mouse.move(point.x, point.y, options);
 var dispatchMouseStart = (page, options = {}) => page.mouse.down(options);
 var dispatchMouseEnd = (page, options = {}) => page.mouse.up(options);
@@ -2615,11 +2611,6 @@ var dragWithMouse = async (page, points, options = {}) => {
     }, { steps: 2 });
     await waitFor(page, options.stepDelayMs ?? 90);
   }
-  const finalMoveRepeats = Math.max(0, Math.floor(toFiniteNumber(options.finalMoveRepeats)));
-  for (let repeat = 0; repeat < finalMoveRepeats; repeat += 1) {
-    await dispatchMouseMove(page, points.end, { steps: 1 });
-    await waitFor(page, options.finalMoveDelayMs ?? 35);
-  }
   await waitFor(page, options.beforeReleaseDelayMs ?? 100);
   await dispatchMouseEnd(page);
   await waitFor(page, options.afterReleaseDelayMs ?? 100);
@@ -2629,7 +2620,6 @@ var dragWithTouch = async (page, points, options = {}) => {
   let client = null;
   try {
     client = await page.context().newCDPSession(page);
-    await waitFor(page, options.initialDelayMs ?? 250);
     await client.send("Input.dispatchTouchEvent", {
       type: "touchStart",
       touchPoints: [{ x: points.start.x, y: points.start.y, id: 1 }]
@@ -2651,14 +2641,6 @@ var dragWithTouch = async (page, points, options = {}) => {
       });
       await waitFor(page, options.stepDelayMs ?? 90);
     }
-    const finalMoveRepeats = Math.max(0, Math.floor(toFiniteNumber(options.finalMoveRepeats)));
-    for (let repeat = 0; repeat < finalMoveRepeats; repeat += 1) {
-      await client.send("Input.dispatchTouchEvent", {
-        type: "touchMove",
-        touchPoints: [{ x: points.end.x, y: points.end.y, id: 1 }]
-      });
-      await waitFor(page, options.finalMoveDelayMs ?? 35);
-    }
     await waitFor(page, options.beforeReleaseDelayMs ?? 100);
     await client.send("Input.dispatchTouchEvent", {
       type: "touchEnd",
@@ -2676,7 +2658,7 @@ var dragWithTouch = async (page, points, options = {}) => {
 var clickTargetWithDevice = async (page, target, options = {}) => {
   const normalizedOptions = normalizeSelectorOptions(options);
   const resolvedDevice = resolveDeviceFromPage(page);
-  if (target && resolvedDevice === Device.Mobile && !normalizedOptions.forceClick && !normalizedOptions.forceMouse) {
+  if (target && resolvedDevice === Device.Mobile && !normalizedOptions.forceClick) {
     if (typeof target.tap === "function") {
       await target.tap(normalizedOptions.tapOptions);
       return true;
@@ -2876,26 +2858,20 @@ var DeviceInput = {
       throw new Error("Unable to resolve drag coordinates.");
     }
     const steps = options.steps || 10;
-    const sourceOffsetX = toFiniteNumber(options.sourceOffsetX);
-    const sourceOffsetY = toFiniteNumber(options.sourceOffsetY);
-    const targetOffsetX = toFiniteNumber(options.targetOffsetX);
-    const targetOffsetY = toFiniteNumber(options.targetOffsetY);
-    const sourceCenterX = sourceBox.x + sourceBox.width / 2 + sourceOffsetX;
-    const sourceCenterY = sourceBox.y + sourceBox.height / 2 + sourceOffsetY;
     const liftOffsetX = Math.min(18, Math.max(8, sourceBox.width * 0.12));
     const liftOffsetY = Math.min(12, Math.max(4, sourceBox.height * 0.08));
     const points = {
       start: {
-        x: sourceCenterX,
-        y: sourceCenterY
+        x: sourceBox.x + sourceBox.width / 2,
+        y: sourceBox.y + sourceBox.height / 2
       },
       lift: {
-        x: sourceCenterX + liftOffsetX,
-        y: sourceCenterY + liftOffsetY
+        x: sourceBox.x + sourceBox.width / 2 + liftOffsetX,
+        y: sourceBox.y + sourceBox.height / 2 + liftOffsetY
       },
       end: {
-        x: targetBox.x + targetBox.width / 2 + targetOffsetX,
-        y: targetBox.y + targetBox.height / 2 + targetOffsetY
+        x: targetBox.x + targetBox.width / 2,
+        y: targetBox.y + targetBox.height / 2
       },
       steps
     };
@@ -3460,23 +3436,6 @@ var initializedPages = /* @__PURE__ */ new WeakSet();
 var DEFAULT_TAP_TIMEOUT_MS = 2500;
 var DEFAULT_MOUSE_TAP_FALLBACK_TIMEOUT_MS = 1200;
 var DEFAULT_ACTIVATE_FALLBACK_TIMEOUT_MS = 900;
-var INTERACTIVE_SELECTOR = [
-  "button",
-  '[role="button"]',
-  "a[href]",
-  "label",
-  "input",
-  "textarea",
-  "select",
-  "summary",
-  '[contenteditable="true"]',
-  '[tabindex]:not([tabindex="-1"])'
-].join(",");
-var EDITABLE_SELECTOR = [
-  "input",
-  "textarea",
-  '[contenteditable="true"]'
-].join(",");
 var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
 var resolveViewport = (page) => page?.viewportSize?.() || { width: 390, height: 844 };
 var describeTarget = (target) => {
@@ -3516,7 +3475,7 @@ var withTimeout = async (operation, timeoutMs, label) => {
   }
 };
 var checkElementVisibility = async (element) => {
-  return element.evaluate((el, interactiveSelector) => {
+  return element.evaluate((el) => {
     const targetStyle = window.getComputedStyle(el);
     if (!targetStyle || targetStyle.display === "none" || targetStyle.visibility === "hidden" || targetStyle.visibility === "collapse") {
       return { code: "NOT_INTERACTABLE", reason: "\u5143\u7D20\u4E0D\u53EF\u89C1", direction: "down" };
@@ -3578,16 +3537,30 @@ var checkElementVisibility = async (element) => {
         positioning
       };
     }
-    const targetInteractive = typeof el.closest === "function" ? el.closest(interactiveSelector) : null;
-    const sameInteractiveTarget = (pointElement) => {
+    const isRootNode = (node) => !node || node === document || node === document.body || node === document.documentElement;
+    const commonAncestor = (a, b) => {
+      for (let current = a; current && !isRootNode(current); current = current.parentElement) {
+        if (current.contains(b)) return current;
+      }
+      return null;
+    };
+    const sameTapTarget = (pointElement) => {
       if (!pointElement) return false;
       if (pointElement === el || el.contains(pointElement) || pointElement.contains(el)) {
         return true;
       }
-      if (!targetInteractive || typeof pointElement.closest !== "function") {
+      const common = commonAncestor(el, pointElement);
+      if (!common) return false;
+      const commonRect = common.getBoundingClientRect?.();
+      if (!commonRect || commonRect.width <= 0 || commonRect.height <= 0) return false;
+      const commonArea = commonRect.width * commonRect.height;
+      const targetArea = Math.max(1, rect.width * rect.height);
+      const maxSharedRegionArea = Math.max(targetArea * 12, 4096);
+      if (commonArea > maxSharedRegionArea) return false;
+      if (commonRect.width > Math.max(rect.width * 8, 120) || commonRect.height > Math.max(rect.height * 8, 120)) {
         return false;
       }
-      return pointElement.closest(interactiveSelector) === targetInteractive;
+      return common.contains(el) && common.contains(pointElement);
     };
     const describeElement = (node) => {
       if (!node) return null;
@@ -3616,7 +3589,7 @@ var checkElementVisibility = async (element) => {
     let obstruction = null;
     for (const point of samplePoints) {
       const pointElement = document.elementFromPoint(point.x, point.y);
-      if (sameInteractiveTarget(pointElement)) {
+      if (sameTapTarget(pointElement)) {
         return { code: "VISIBLE", isFixed, positioning };
       }
       obstruction = obstruction || describeElement(pointElement);
@@ -3634,10 +3607,10 @@ var checkElementVisibility = async (element) => {
       };
     }
     return { code: "VISIBLE", isFixed, positioning };
-  }, INTERACTIVE_SELECTOR);
+  });
 };
 var resolveSafeTapPoint = async (element) => {
-  return element.evaluate((el, interactiveSelector) => {
+  return element.evaluate((el) => {
     const rect = el.getBoundingClientRect();
     if (!rect || rect.width <= 0 || rect.height <= 0) {
       return null;
@@ -3674,16 +3647,30 @@ var resolveSafeTapPoint = async (element) => {
     if (visibleWidth <= 1 || visibleHeight <= 1) {
       return null;
     }
-    const targetInteractive = typeof el.closest === "function" ? el.closest(interactiveSelector) : null;
-    const sameInteractiveTarget = (pointElement) => {
+    const isRootNode = (node) => !node || node === document || node === document.body || node === document.documentElement;
+    const commonAncestor = (a, b) => {
+      for (let current = a; current && !isRootNode(current); current = current.parentElement) {
+        if (current.contains(b)) return current;
+      }
+      return null;
+    };
+    const sameTapTarget = (pointElement) => {
       if (!pointElement) return false;
       if (pointElement === el || el.contains(pointElement) || pointElement.contains(el)) {
         return true;
       }
-      if (!targetInteractive || typeof pointElement.closest !== "function") {
+      const common = commonAncestor(el, pointElement);
+      if (!common) return false;
+      const commonRect = common.getBoundingClientRect?.();
+      if (!commonRect || commonRect.width <= 0 || commonRect.height <= 0) return false;
+      const commonArea = commonRect.width * commonRect.height;
+      const targetArea = Math.max(1, rect.width * rect.height);
+      const maxSharedRegionArea = Math.max(targetArea * 12, 4096);
+      if (commonArea > maxSharedRegionArea) return false;
+      if (commonRect.width > Math.max(rect.width * 8, 120) || commonRect.height > Math.max(rect.height * 8, 120)) {
         return false;
       }
-      return pointElement.closest(interactiveSelector) === targetInteractive;
+      return common.contains(el) && common.contains(pointElement);
     };
     const cx = visibleLeft + visibleWidth / 2;
     const cy = visibleTop + visibleHeight / 2;
@@ -3702,7 +3689,7 @@ var resolveSafeTapPoint = async (element) => {
     ];
     const safePoints = points.filter((point) => {
       const pointElement = document.elementFromPoint(point.x, point.y);
-      return sameInteractiveTarget(pointElement);
+      return sameTapTarget(pointElement);
     });
     const candidates = safePoints.length ? safePoints : points;
     const chosen = candidates[Math.floor(Math.random() * candidates.length)];
@@ -3711,46 +3698,57 @@ var resolveSafeTapPoint = async (element) => {
       x: chosen.x,
       y: chosen.y
     };
-  }, INTERACTIVE_SELECTOR);
+  });
 };
 var activateElementFallback = async (element, point = null, options = {}) => {
-  return element.evaluate((el, { innerPoint, innerOptions, interactiveSelector, editableSelector }) => {
-    const pointElement = innerPoint ? document.elementFromPoint(innerPoint.x, innerPoint.y) : null;
-    const nearestInteractive = (node) => {
-      if (!node || typeof node.closest !== "function") return null;
-      return node.closest(interactiveSelector);
+  return element.evaluate((el, { innerOptions }) => {
+    const isEditable = (node) => {
+      if (!node || node.nodeType !== Node.ELEMENT_NODE) return false;
+      if (node.isContentEditable) return true;
+      if (node instanceof HTMLTextAreaElement) return !node.disabled && !node.readOnly;
+      if (node instanceof HTMLInputElement) {
+        return !node.disabled && !node.readOnly && typeof node.select === "function";
+      }
+      return false;
     };
-    const targetInteractive = nearestInteractive(el);
-    const pointInteractive = nearestInteractive(pointElement);
-    let target = null;
-    if (pointInteractive && (pointInteractive === targetInteractive || pointInteractive === el || pointInteractive.contains(el) || el.contains(pointInteractive))) {
-      target = pointInteractive;
-    }
-    target = target || targetInteractive || el;
-    const editable = typeof target.closest === "function" ? target.closest(editableSelector) : null;
+    const findEditable = (node) => {
+      for (let current = node; current && current !== document.body; current = current.parentElement) {
+        if (isEditable(current)) return current;
+      }
+      return null;
+    };
+    const editable = findEditable(el);
     if (editable && typeof editable.focus === "function") {
       editable.focus({ preventScroll: true });
       if (innerOptions.editableOnly) {
         return { activated: true, method: "focus", tag: editable.tagName || "" };
       }
     }
-    if (typeof target.focus === "function") {
-      target.focus({ preventScroll: true });
+    if (innerOptions.editableOnly) {
+      return { activated: false, method: "none", tag: el?.tagName || "" };
     }
-    if (!innerOptions.editableOnly && typeof target.click === "function") {
-      target.click();
-      return { activated: true, method: "dom-click", tag: target.tagName || "" };
+    if (typeof el.focus === "function") {
+      el.focus({ preventScroll: true });
+    }
+    if (typeof el.click === "function") {
+      el.click();
+      return { activated: true, method: "dom-click", tag: el.tagName || "" };
+    }
+    if (typeof el.dispatchEvent === "function") {
+      el.dispatchEvent(new MouseEvent("click", {
+        bubbles: true,
+        cancelable: true,
+        view: window
+      }));
+      return { activated: true, method: "dispatch-click", tag: el.tagName || "" };
     }
     return {
       activated: Boolean(editable),
       method: editable ? "focus" : "none",
-      tag: target?.tagName || ""
+      tag: el?.tagName || ""
     };
   }, {
-    innerPoint: point,
-    innerOptions: options || {},
-    interactiveSelector: INTERACTIVE_SELECTOR,
-    editableSelector: EDITABLE_SELECTOR
+    innerOptions: options || {}
   });
 };
 var getScrollableRect = async (element) => {
@@ -3854,6 +3852,47 @@ var scrollAwayFromObstruction = async (element, status) => {
     };
   }, status);
 };
+var getElementViewportSnapshot = async (element) => {
+  return element.evaluate((el) => {
+    const rect = el.getBoundingClientRect();
+    return {
+      top: rect.top,
+      bottom: rect.bottom,
+      left: rect.left,
+      right: rect.right,
+      width: rect.width,
+      height: rect.height,
+      scrollX: window.scrollX,
+      scrollY: window.scrollY
+    };
+  });
+};
+var isTargetImmobileAfterScroll = (before, after) => {
+  if (!before || !after) return false;
+  const rectDeltaY = Number(after.top || 0) - Number(before.top || 0);
+  const rectDeltaX = Number(after.left || 0) - Number(before.left || 0);
+  const scrollDeltaY = Number(after.scrollY || 0) - Number(before.scrollY || 0);
+  const scrollDeltaX = Number(after.scrollX || 0) - Number(before.scrollX || 0);
+  const rectMoved = Math.abs(rectDeltaY) > 3 || Math.abs(rectDeltaX) > 3;
+  const pageMoved = Math.abs(scrollDeltaY) > 3 || Math.abs(scrollDeltaX) > 3;
+  if (!rectMoved && !pageMoved) return true;
+  if (pageMoved && !rectMoved) return true;
+  if (Math.abs(scrollDeltaY) > 12 && Math.abs(rectDeltaY) < Math.min(12, Math.abs(scrollDeltaY) * 0.2)) {
+    return true;
+  }
+  return false;
+};
+var restoreWindowFromSnapshot = async (page, before, after) => {
+  if (!before || !after) return;
+  if (Math.abs(Number(after.scrollX || 0) - Number(before.scrollX || 0)) <= 2 && Math.abs(Number(after.scrollY || 0) - Number(before.scrollY || 0)) <= 2) {
+    return;
+  }
+  await page.evaluate(
+    (state) => window.scrollTo(state.x, state.y),
+    { x: Number(before.scrollX || 0), y: Number(before.scrollY || 0) }
+  ).catch(() => {
+  });
+};
 var dispatchTouchSwipe = async (page, deltaY, options = {}) => {
   const viewport = resolveViewport(page);
   const rawRect = options.rect || null;
@@ -4034,11 +4073,11 @@ var MobileHumanize = {
       const scrollRect = await getScrollableRect(element);
       if (!scrollRect && status.isFixed && status.code === "OUT_OF_VIEWPORT") {
         logger7.warn(`humanScroll | fixed/sticky \u76EE\u6807\u4E0D\u5728\u89C6\u53E3\u5185\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (direction=${status.direction || "unknown"})`);
-        return { element, didScroll, restore: null };
+        return { element, didScroll, restore: null, unscrollable: true };
       }
       if (!scrollRect && status.isFixed && status.code === "OBSTRUCTED") {
         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 };
+        return { element, didScroll, restore: null, unscrollable: true };
       }
       if (scrollRect && status.code === "OBSTRUCTED" && status.obstruction?.isFixed) {
         const moved = await scrollAwayFromObstruction(element, status);
@@ -4069,6 +4108,7 @@ var MobileHumanize = {
         }
       }
       const beforeWindowState = scrollRect ? await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })) : null;
+      const beforeElementSnapshot = await getElementViewportSnapshot(element).catch(() => null);
       const beforeState = scrollRect ? await element.evaluate((el) => {
         const isScrollable = (node) => {
           const style = window.getComputedStyle(node);
@@ -4098,6 +4138,21 @@ var MobileHumanize = {
           logger7.debug(`humanScroll | \u7A97\u53E3\u6EDA\u52A8\u56DE\u6536 from=${Math.round(afterWindowState.y)} to=${Math.round(beforeWindowState.y)}`);
         }
       }
+      let afterElementSnapshot = null;
+      const readAfterElementSnapshot = async () => {
+        if (!afterElementSnapshot) {
+          afterElementSnapshot = await getElementViewportSnapshot(element).catch(() => null);
+        }
+        return afterElementSnapshot;
+      };
+      if (!scrollRect && beforeElementSnapshot) {
+        const afterSnapshot = await readAfterElementSnapshot();
+        if (isTargetImmobileAfterScroll(beforeElementSnapshot, afterSnapshot)) {
+          await restoreWindowFromSnapshot(page, beforeElementSnapshot, afterSnapshot);
+          logger7.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u9875\u9762\u6EDA\u52A8\u79FB\u52A8\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
+          return { element, didScroll, restore: null, unscrollable: true };
+        }
+      }
       if (scrollRect && beforeState) {
         const afterState = await element.evaluate((el) => {
           const isScrollable = (node) => {
@@ -4135,6 +4190,14 @@ var MobileHumanize = {
           }
         }
       }
+      if (scrollRect && beforeElementSnapshot) {
+        const afterSnapshot = await getElementViewportSnapshot(element).catch(() => null);
+        if (isTargetImmobileAfterScroll(beforeElementSnapshot, afterSnapshot)) {
+          await restoreWindowFromSnapshot(page, beforeElementSnapshot, afterSnapshot);
+          logger7.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u6EDA\u52A8\u5BB9\u5668\u79FB\u52A8\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
+          return { element, didScroll, restore: null, unscrollable: true };
+        }
+      }
       didScroll = true;
     }
     try {
@@ -4184,21 +4247,28 @@ var MobileHumanize = {
         logger7.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${targetDesc}`);
         return false;
       }
-      if (scrollIfNeeded) {
-        await MobileHumanize.humanScroll(page, element, { throwOnMissing });
-      }
+      const scrollResult = scrollIfNeeded ? await MobileHumanize.humanScroll(page, element, { throwOnMissing }) : null;
       const status = await checkElementVisibility(element).catch(() => null);
       if (status && status.code !== "VISIBLE") {
-        if (fallbackDomClick && status.isFixed && status.code === "OUT_OF_VIEWPORT") {
-          const fallback = await withTimeout(
+        if (fallbackDomClick && (status.code === "OUT_OF_VIEWPORT" || status.code === "OBSTRUCTED") && (status.isFixed || scrollResult?.unscrollable)) {
+          let fallback = await withTimeout(
             () => activateElementFallback(element, null, {
               editableOnly: true
             }),
             activateFallbackTimeoutMs,
             "focus fallback"
           ).catch(() => null);
+          if (!fallback?.activated) {
+            fallback = await withTimeout(
+              () => activateElementFallback(element, null, {
+                editableOnly: false
+              }),
+              activateFallbackTimeoutMs,
+              "activation fallback"
+            ).catch(() => null);
+          }
           if (fallback?.activated) {
-            logger7.warn(`humanClick: fixed/sticky \u76EE\u6807\u4E0D\u5728\u89C6\u53E3\u5185\uFF0C\u5DF2\u7528 ${fallback.method} \u6FC0\u6D3B`);
+            logger7.warn(`humanClick: \u4E0D\u53EF\u6EDA\u52A8\u76EE\u6807\u4E0D\u53EF\u7269\u7406\u70B9\u51FB\uFF0C\u5DF2\u7528 ${fallback.method} \u6FC0\u6D3B`);
             return true;
           }
         }
@@ -4315,6 +4385,20 @@ var MobileHumanize = {
     const locator = page.locator(selector);
     await MobileHumanize.humanClick(page, locator, { scrollIfNeeded: true });
     await waitJitter(160, 0.4);
+    const readValue = async () => {
+      try {
+        return await locator.inputValue({ timeout: 600 });
+      } catch {
+        return await locator.evaluate((el) => "value" in el ? String(el.value || "") : String(el.textContent || "")).catch(() => "");
+      }
+    };
+    const currentValue = await readValue();
+    if (!currentValue) return;
+    await page.keyboard.press("ControlOrMeta+A");
+    await waitJitter(90, 0.35);
+    await page.keyboard.press("Backspace");
+    await waitJitter(120, 0.35);
+    if (!await readValue()) return;
     await locator.evaluate((el) => {
       if ("value" in el) {
         el.value = "";
@@ -4904,10 +4988,6 @@ var LiveView = {
 // src/chaptcha.js
 var import_uuid = require("uuid");
 
-// src/internals/captcha/bytedance.js
-var import_promises = require("fs/promises");
-var import_path2 = __toESM(require("path"), 1);
-
 // src/internals/captcha/shared.js
 var waitForVisible = async (locator, timeout) => {
   try {
@@ -4925,71 +5005,38 @@ var isAnyCaptchaTextVisible = async (frame, texts, timeout) => {
     if (!text) {
       continue;
     }
-    const textLocator = frame.getByText(text, { exact: false });
-    const locatorText = frame.locator(`text=${text}`);
-    const candidateGroups = [textLocator, locatorText];
-    for (const candidateGroup of candidateGroups) {
-      const candidateCount = await candidateGroup.count().catch(() => 0);
-      for (let index = 0; index < candidateCount; index += 1) {
-        const candidate = candidateGroup.nth(index);
-        const isVisible = await candidate.isVisible({ timeout }).catch(() => false);
-        if (isVisible) {
-          return true;
-        }
+    const candidates = [
+      frame.getByText(text, { exact: false }).first(),
+      frame.locator(`text=${text}`).first()
+    ];
+    for (const candidate of candidates) {
+      const isVisible = await candidate.isVisible({ timeout }).catch(() => false);
+      if (isVisible) {
+        return true;
       }
     }
   }
   return false;
 };
-var collectVisibleCandidateIndexes = async (candidateGroup, count, timeout) => {
-  const visibleIndexes = [];
-  for (let index = 0; index < count; index += 1) {
-    const candidate = candidateGroup.nth(index);
-    const isVisible = await candidate.isVisible({ timeout }).catch(() => false);
-    if (isVisible) {
-      visibleIndexes.push(index);
-    }
-  }
-  return visibleIndexes;
-};
 var clickCaptchaAction = async (frame, texts, options) => {
   for (const text of texts || []) {
-    const textLocator = frame.getByText(text, { exact: false });
-    const locatorText = frame.locator(`text=${text}`);
-    const [getByTextCount, locatorTextCount] = await Promise.all([
-      textLocator.count().catch(() => 0),
-      locatorText.count().catch(() => 0)
-    ]);
-    const [getByTextVisibleIndexes, locatorTextVisibleIndexes] = await Promise.all([
-      collectVisibleCandidateIndexes(textLocator, getByTextCount, options.actionVisibleTimeoutMs),
-      collectVisibleCandidateIndexes(locatorText, locatorTextCount, options.actionVisibleTimeoutMs)
-    ]);
-    options.logger?.info(
-      `[CaptchaAction] \u6587\u672C "${text}" \u547D\u4E2D\u6570\u91CF\uFF1AgetByText=${getByTextCount} (visible=${getByTextVisibleIndexes.length}), locator=${locatorTextCount} (visible=${locatorTextVisibleIndexes.length})`
-    );
-    const candidateGroups = [
-      { label: "getByText", locator: textLocator, count: getByTextCount },
-      { label: "locator", locator: locatorText, count: locatorTextCount }
+    const candidates = [
+      frame.getByText(text, { exact: false }).first(),
+      frame.locator(`text=${text}`).first()
     ];
-    for (const candidateGroup of candidateGroups) {
-      for (let index = 0; index < candidateGroup.count; index += 1) {
-        const candidate = candidateGroup.locator.nth(index);
-        const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
-        if (!isVisible) {
-          continue;
-        }
-        options.logger?.info(
-          `[CaptchaAction] \u6587\u672C "${text}" \u9009\u62E9 ${candidateGroup.label}[${index}] \u4F5C\u4E3A\u7B2C\u4E00\u4E2A\u53EF\u89C1\u8282\u70B9\u6267\u884C\u70B9\u51FB\u3002`
-        );
-        await DeviceInput.click(options.page, candidate, options);
-        return true;
+    for (const candidate of candidates) {
+      const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
+      if (!isVisible) {
+        continue;
       }
+      await DeviceInput.click(options.page, candidate);
+      return true;
     }
   }
   return false;
 };
-var dragCaptchaAction = async (page, sourceLocator, targetLocator, options = {}) => {
-  await DeviceInput.drag(page, sourceLocator, targetLocator, options);
+var dragCaptchaAction = async (page, sourceLocator, targetLocator) => {
+  await DeviceInput.drag(page, sourceLocator, targetLocator);
 };
 
 // src/internals/captcha/bytedance.js
@@ -5000,12 +5047,11 @@ var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
   containerSelector: "#captcha_container",
   iframeSelector: 'iframe[src*="verifycenter"]',
   iframeFallbackSelector: "iframe",
-  sourceImageSelector: ".img-container .canvas-container",
-  dropTargetContainerSelector: ".drag-area",
+  sourceImageSelector: "div.canvas-container",
+  dropTargetContainerSelector: "#captcha_verify_image div",
   dropTargetTexts: ["\u62D6\u62FD\u5230\u8FD9\u91CC"],
   refreshTexts: ["\u5237\u65B0"],
   submitTexts: ["\u63D0\u4EA4"],
-  guideMaskSelector: ".play-guide-mask",
   recognitionSuccessCode: 1e4,
   containerVisibleTimeoutMs: 2e3,
   iframeVisibleTimeoutMs: 12e3,
@@ -5028,111 +5074,10 @@ var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
   ],
   recognitionDelayMs: 2e3,
   refreshWaitMs: 3e3,
-  submitWaitMs: 5e3,
-  submitReadyTimeoutMs: 2500,
+  submitWaitMs: 3e3,
   retryDelayBaseMs: 2e3,
-  retryDelayStepMs: 1e3,
-  sourceImageRowTolerancePx: 24,
-  dragBetweenWaitMs: 250,
-  promptBadgeCountSelector: ".drag-area .photo-badge .badge span",
-  promptSubmitButtonSelector: ".vc-captcha-verify-mobile-button",
-  promptSelectedSourceSelector: ".img-container .canvas-container.selected",
-  promptActiveSourceSelector: ".img-container .canvas-container.active",
-  promptDragMoveSteps: 16,
-  promptDragStepDelayMs: 55,
-  promptDragHoldDelayMs: 240,
-  promptDragBeforeReleaseDelayMs: 180,
-  promptDragAfterReleaseDelayMs: 240,
-  promptDragFinalMoveRepeats: 3,
-  promptDragRetryDelayMs: 250,
-  debugArtifacts: false
+  retryDelayStepMs: 1e3
 });
-var PROMPT_CAPTCHA_DRAG_PLANS = Object.freeze([
-  { name: "lower-middle", endXRatio: 0.5, endYRatio: 0.72 },
-  { name: "center-middle", endXRatio: 0.5, endYRatio: 0.56 },
-  { name: "upper-middle", endXRatio: 0.5, endYRatio: 0.4 }
-]);
-var resolveCaptchaDebugDir = () => import_path2.default.resolve(process.cwd(), "storage", "captcha-debug");
-var rectOf = (rect) => {
-  if (!rect) {
-    return null;
-  }
-  return {
-    x: Number(rect.x.toFixed(2)),
-    y: Number(rect.y.toFixed(2)),
-    width: Number(rect.width.toFixed(2)),
-    height: Number(rect.height.toFixed(2))
-  };
-};
-var collectCaptchaDebugInfo = async (page, frame, iframeLocator, attempt, phase, extra = null) => {
-  const timestamp = Date.now();
-  const debugDir = resolveCaptchaDebugDir();
-  await (0, import_promises.mkdir)(debugDir, { recursive: true });
-  const baseName = `bytedance-${timestamp}-attempt${attempt}-${phase}`;
-  const iframeScreenshotPath = import_path2.default.join(debugDir, `${baseName}-iframe.png`);
-  const pageScreenshotPath = import_path2.default.join(debugDir, `${baseName}-page.png`);
-  const htmlPath = import_path2.default.join(debugDir, `${baseName}-iframe.html`);
-  const infoPath = import_path2.default.join(debugDir, `${baseName}-info.json`);
-  await iframeLocator.screenshot({ path: iframeScreenshotPath }).catch(() => {
-  });
-  await page.screenshot({ path: pageScreenshotPath, fullPage: true }).catch(() => {
-  });
-  const html = await frame.evaluate(() => document.documentElement.outerHTML).catch(() => "");
-  if (html) {
-    await (0, import_promises.writeFile)(htmlPath, html, "utf8");
-  }
-  const info = await frame.evaluate(() => {
-    const toRect = (element) => {
-      const rect = element.getBoundingClientRect();
-      return {
-        x: Number(rect.x.toFixed(2)),
-        y: Number(rect.y.toFixed(2)),
-        width: Number(rect.width.toFixed(2)),
-        height: Number(rect.height.toFixed(2))
-      };
-    };
-    const toItem = (element, index) => ({
-      index,
-      tag: element.tagName,
-      id: element.id || "",
-      className: typeof element.className === "string" ? element.className : "",
-      text: String(element.textContent || "").trim(),
-      rect: toRect(element)
-    });
-    const visibleNodes = Array.from(document.querySelectorAll("body *")).map(toItem).filter((item) => item.rect.width > 0 && item.rect.height > 0);
-    return {
-      title: document.title,
-      bodyText: String(document.body?.innerText || "").trim(),
-      canvasContainers: visibleNodes.filter((item) => item.className.includes("canvas-container")),
-      canvasNodes: visibleNodes.filter((item) => item.tag === "CANVAS"),
-      captchaNodes: visibleNodes.filter((item) => item.id.startsWith("captcha_") || item.className.includes("captcha") || item.className.includes("verify") || /拖拽到这里|刷新|提交/.test(item.text)),
-      visibleTextNodes: visibleNodes.filter((item) => item.text).slice(0, 300)
-    };
-  }).catch(() => null);
-  if (info) {
-    const payload = {
-      capturedAt: new Date(timestamp).toISOString(),
-      pageUrl: page.url(),
-      attempt,
-      phase,
-      iframeScreenshotPath,
-      pageScreenshotPath,
-      htmlPath,
-      info
-    };
-    if (extra != null) {
-      payload.extra = extra;
-    }
-    await (0, import_promises.writeFile)(infoPath, JSON.stringify(payload, null, 2), "utf8");
-  }
-  logger10.info(`\u5DF2\u5199\u51FA\u9A8C\u8BC1\u7801\u8C03\u8BD5\u4EA7\u7269\uFF1A${debugDir}`);
-};
-var maybeCollectCaptchaDebugInfo = async (page, frame, iframeLocator, attempt, phase, options, extra = null) => {
-  if (!options.debugArtifacts) {
-    return;
-  }
-  await collectCaptchaDebugInfo(page, frame, iframeLocator, attempt, phase, extra);
-};
 var extractCaptchaSerialNumbers = (apiResponse) => {
   const serialNumbers = apiResponse?.data?.data?.serial_number;
   if (!Array.isArray(serialNumbers)) {
@@ -5141,7 +5086,7 @@ var extractCaptchaSerialNumbers = (apiResponse) => {
   return serialNumbers.map((value) => Number(value)).filter((value) => Number.isInteger(value) && value >= 0);
 };
 var resolveContentFrame = async (page, iframeLocator, options) => {
-  for (let attempt = 1; attempt <= options.contentFrameResolveRetries; attempt += 1) {
+  for (let attempt = 1; attempt <= options.contentFrameResolveRetries; attempt++) {
     const iframeHandle = await iframeLocator.elementHandle();
     const frame = await iframeHandle?.contentFrame();
     if (frame) {
@@ -5186,15 +5131,20 @@ var getVerifycenterCaptchaContext = async (page, options) => {
   }
   return { iframeLocator, frame };
 };
-var findCaptchaDropTarget = async (frame, options) => {
-  const directTarget = frame.locator(options.dropTargetContainerSelector).first();
-  if (await waitForVisible(directTarget, options.actionVisibleTimeoutMs)) {
-    return directTarget;
+var refreshCaptcha = async (page, frame, options) => {
+  const clicked = await clickCaptchaAction(frame, options.refreshTexts, { ...options, page }).catch(() => false);
+  if (!clicked) {
+    logger10.warn("Refresh button not found.");
+    return false;
   }
+  await page.waitForTimeout(options.refreshWaitMs);
+  return true;
+};
+var findCaptchaDropTarget = async (frame, options) => {
   for (const text of options.dropTargetTexts) {
     const candidates = [
-      frame.getByText(text, { exact: false }).first(),
-      frame.locator(`text=${text}`).first()
+      frame.locator(options.dropTargetContainerSelector).filter({ hasText: text }).first(),
+      frame.getByText(text, { exact: false }).first()
     ];
     for (const candidate of candidates) {
       const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
@@ -5205,112 +5155,10 @@ var findCaptchaDropTarget = async (frame, options) => {
   }
   return null;
 };
-var readPromptCaptchaState = async (frame, options) => frame.evaluate((selectors) => {
-  const toRect = (element) => {
-    if (!element) {
-      return null;
-    }
-    const rect = element.getBoundingClientRect();
-    return {
-      x: Number(rect.x.toFixed(2)),
-      y: Number(rect.y.toFixed(2)),
-      width: Number(rect.width.toFixed(2)),
-      height: Number(rect.height.toFixed(2))
-    };
-  };
-  const badgeNode = document.querySelector(selectors.badgeCountSelector);
-  const submitButton = document.querySelector(selectors.submitButtonSelector);
-  const dragArea = document.querySelector(selectors.dragAreaSelector);
-  const badgeCount = badgeNode ? Number.parseInt(String(badgeNode.textContent || "").trim(), 10) : 0;
-  return {
-    badgeCount: Number.isFinite(badgeCount) ? badgeCount : 0,
-    selectedCount: document.querySelectorAll(selectors.selectedSourceSelector).length,
-    activeCount: document.querySelectorAll(selectors.activeSourceSelector).length,
-    submitDisabled: submitButton ? submitButton.classList.contains("disable") : null,
-    dragAreaActive: dragArea ? dragArea.classList.contains("active") : false,
-    dragAreaRect: toRect(dragArea)
-  };
-}, {
-  badgeCountSelector: options.promptBadgeCountSelector,
-  submitButtonSelector: options.promptSubmitButtonSelector,
-  selectedSourceSelector: options.promptSelectedSourceSelector,
-  activeSourceSelector: options.promptActiveSourceSelector,
-  dragAreaSelector: options.dropTargetContainerSelector
-}).catch(() => ({
-  badgeCount: 0,
-  selectedCount: 0,
-  activeCount: 0,
-  submitDisabled: null,
-  dragAreaActive: false,
-  dragAreaRect: null
-}));
-var normalizeCaptchaImageIndexes = (serialNumbers, imageCount) => {
-  if (!Array.isArray(serialNumbers) || imageCount <= 0) {
-    return [];
-  }
-  const areAllOneBased = serialNumbers.every((value) => value >= 1 && value <= imageCount);
-  if (areAllOneBased) {
-    return serialNumbers.map((value) => value - 1);
-  }
-  const areAllZeroBased = serialNumbers.every((value) => value >= 0 && value < imageCount);
-  if (areAllZeroBased) {
-    return [...serialNumbers];
-  }
-  return serialNumbers.map((value) => {
-    if (value >= 1 && value <= imageCount) {
-      return value - 1;
-    }
-    if (value >= 0 && value < imageCount) {
-      return value;
-    }
-    return null;
-  }).filter((value) => Number.isInteger(value));
-};
-var resolveCaptchaSourceImagesInVisualOrder = async (frame, options) => {
-  const sourceImages = frame.locator(options.sourceImageSelector);
-  const imageCount = await sourceImages.count().catch(() => 0);
-  const sources = [];
-  for (let domIndex = 0; domIndex < imageCount; domIndex += 1) {
-    const locator = sourceImages.nth(domIndex);
-    const box = await locator.boundingBox().catch(() => null);
-    if (!box || box.width <= 0 || box.height <= 0) {
-      continue;
-    }
-    sources.push({
-      domIndex,
-      locator,
-      box
-    });
-  }
-  sources.sort((left, right) => {
-    const deltaY = left.box.y - right.box.y;
-    if (Math.abs(deltaY) > options.sourceImageRowTolerancePx) {
-      return deltaY;
-    }
-    return left.box.x - right.box.x;
-  });
-  return sources;
-};
-var refreshCaptcha = async (page, frame, options) => {
-  const clicked = await clickCaptchaAction(frame, options.refreshTexts, {
-    ...options,
-    page,
-    logger: logger10,
-    forceMouse: true
-  }).catch(() => false);
-  if (!clicked) {
-    logger10.warn("Refresh button not found.");
-    return false;
-  }
-  await page.waitForTimeout(options.refreshWaitMs);
-  return true;
-};
 var waitForCaptchaChallengeReady = async (page, frame, options) => {
   const deadline = Date.now() + options.challengeReadyTimeoutMs;
   let refreshDeadline = Date.now() + options.challengeReadyRefreshTimeoutMs;
   let hasSeenLoading = false;
-  let hasSeenGuideMask = false;
-  let hasLoggedGuideMask = false;
   while (Date.now() < deadline) {
     const isLoadingVisible = await isAnyCaptchaTextVisible(
       frame,
@@ -5326,17 +5174,8 @@ var waitForCaptchaChallengeReady = async (page, frame, options) => {
     const sourceImages = frame.locator(options.sourceImageSelector);
     const imageCount = await sourceImages.count().catch(() => 0);
     const hasVisibleSourceImage = imageCount > 0 ? await sourceImages.first().isVisible({ timeout: options.loadingIndicatorVisibleTimeoutMs }).catch(() => false) : false;
-    const hasVisibleDropTarget = await frame.locator(options.dropTargetContainerSelector).first().isVisible({ timeout: options.loadingIndicatorVisibleTimeoutMs }).catch(() => false);
-    const hasGuideMaskVisible = options.guideMaskSelector ? await frame.locator(options.guideMaskSelector).first().isVisible({ timeout: options.loadingIndicatorVisibleTimeoutMs }).catch(() => false) : false;
-    hasSeenGuideMask = hasSeenGuideMask || hasGuideMaskVisible;
-    if (hasGuideMaskVisible && !hasLoggedGuideMask) {
-      logger10.info("\u68C0\u6D4B\u5230\u9A8C\u8BC1\u7801\u64CD\u4F5C\u5F15\u5BFC\u5C42\uFF0C\u7B49\u5F85\u5176\u6D88\u5931\u540E\u518D\u5F00\u59CB\u8BC6\u522B\u3002");
-      hasLoggedGuideMask = true;
-    }
-    if (!isLoadingVisible && hasVisibleSourceImage && hasVisibleDropTarget && !hasGuideMaskVisible) {
-      logger10.info(
-        hasSeenGuideMask ? "\u9A8C\u8BC1\u7801\u56FE\u7247\u548C\u62D6\u62FD\u533A\u57DF\u5DF2\u5C31\u7EEA\uFF0C\u5F15\u5BFC\u5C42\u5DF2\u6D88\u5931\u3002" : hasSeenLoading ? "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u52A0\u8F7D\u5B8C\u6210\u3002" : "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u5C31\u7EEA\u3002"
-      );
+    if (!isLoadingVisible && hasVisibleSourceImage) {
+      logger10.info(hasSeenLoading ? "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u52A0\u8F7D\u5B8C\u6210\u3002" : "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u5C31\u7EEA\u3002");
       return;
     }
     if (hasErrorTextVisible) {
@@ -5346,8 +5185,8 @@ var waitForCaptchaChallengeReady = async (page, frame, options) => {
       hasSeenLoading = false;
       continue;
     }
-    if ((!hasVisibleSourceImage || !hasVisibleDropTarget) && Date.now() >= refreshDeadline) {
-      logger10.warn(`\u9A8C\u8BC1\u7801\u9898\u76EE\u8D85\u8FC7 ${options.challengeReadyRefreshTimeoutMs}ms \u4ECD\u672A\u51C6\u5907\u597D\uFF0C\u5C1D\u8BD5\u5237\u65B0\u9898\u76EE\u3002`);
+    if (!hasVisibleSourceImage && Date.now() >= refreshDeadline) {
+      logger10.warn(`\u9A8C\u8BC1\u7801\u56FE\u7247\u8D85\u8FC7 ${options.challengeReadyRefreshTimeoutMs}ms \u4ECD\u672A\u51FA\u73B0\uFF0C\u5C1D\u8BD5\u5237\u65B0\u9898\u76EE\u3002`);
       await refreshCaptcha(page, frame, options);
       refreshDeadline = Date.now() + options.challengeReadyRefreshTimeoutMs;
       hasSeenLoading = false;
@@ -5357,69 +5196,6 @@ var waitForCaptchaChallengeReady = async (page, frame, options) => {
   }
   throw new Error("Captcha challenge is still loading and did not become ready in time.");
 };
-var dragPromptCaptchaImage = async (page, frame, iframeLocator, sourceLocator, dropTarget, options, {
-  attempt,
-  visualIndex
-}) => {
-  const baselineState = await readPromptCaptchaState(frame, options);
-  const dragAttempts = [];
-  for (const plan of PROMPT_CAPTCHA_DRAG_PLANS) {
-    const sourceBox = await sourceLocator.boundingBox().catch(() => null);
-    const targetBox = await dropTarget.boundingBox().catch(() => null);
-    if (!sourceBox || !targetBox) {
-      throw new Error("Unable to resolve prompt captcha drag coordinates.");
-    }
-    const targetOffsetX = (plan.endXRatio - 0.5) * targetBox.width;
-    const targetOffsetY = (plan.endYRatio - 0.5) * targetBox.height;
-    await dragCaptchaAction(page, sourceLocator, dropTarget, {
-      forceMouse: true,
-      targetOffsetX,
-      targetOffsetY,
-      steps: options.promptDragMoveSteps,
-      holdDelayMs: options.promptDragHoldDelayMs,
-      stepDelayMs: options.promptDragStepDelayMs,
-      beforeReleaseDelayMs: options.promptDragBeforeReleaseDelayMs,
-      afterReleaseDelayMs: options.promptDragAfterReleaseDelayMs,
-      finalMoveRepeats: options.promptDragFinalMoveRepeats
-    });
-    const afterState = await readPromptCaptchaState(frame, options);
-    const accepted = afterState.badgeCount > baselineState.badgeCount || afterState.selectedCount > baselineState.selectedCount;
-    const attemptInfo = {
-      planName: plan.name,
-      sourceRect: rectOf(sourceBox),
-      targetRect: rectOf(targetBox),
-      targetOffsetX: Number(targetOffsetX.toFixed(2)),
-      targetOffsetY: Number(targetOffsetY.toFixed(2)),
-      beforeState: baselineState,
-      afterState,
-      accepted
-    };
-    dragAttempts.push(attemptInfo);
-    logger10.info(
-      `\u9A8C\u8BC1\u7801\u62D6\u62FD\u7B2C ${visualIndex + 1} \u5F20\uFF0C\u65B9\u6848 ${plan.name}\uFF0Cbadge ${baselineState.badgeCount} -> ${afterState.badgeCount}\uFF0Cselected ${baselineState.selectedCount} -> ${afterState.selectedCount}`
-    );
-    if (accepted) {
-      return {
-        accepted: true,
-        dragAttempts
-      };
-    }
-    if (options.promptDragRetryDelayMs > 0) {
-      await page.waitForTimeout(options.promptDragRetryDelayMs);
-    }
-  }
-  await maybeCollectCaptchaDebugInfo(page, frame, iframeLocator, attempt, `drag-${visualIndex + 1}-failed`, options, {
-    visualIndex,
-    dragAttempts,
-    finalState: await readPromptCaptchaState(frame, options)
-  }).catch((error) => {
-    logger10.warn(`\u9A8C\u8BC1\u7801\u62D6\u62FD\u5931\u8D25\u8C03\u8BD5\u6293\u53D6\u5931\u8D25\uFF1A${error?.message || error}`);
-  });
-  return {
-    accepted: false,
-    dragAttempts
-  };
-};
 async function solveCaptcha(page, options = {}, dependencies = {}) {
   const { callCaptchaRecognitionApi: callCaptchaRecognitionApi2 } = dependencies;
   if (typeof callCaptchaRecognitionApi2 !== "function") {
@@ -5434,7 +5210,7 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
     return false;
   }
   logger10.info("\u5F53\u524D\u4F7F\u7528\u672Ctool\u2014\u2014\u6D4B\u8BD5\u7248\u672C");
-  for (let attempt = 1; attempt <= config.maxRetries; attempt += 1) {
+  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
     logger10.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
     try {
       const captchaContext = await getVerifycenterCaptchaContext(page, config);
@@ -5444,16 +5220,6 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
       }
       const { iframeLocator, frame } = captchaContext;
       await waitForCaptchaChallengeReady(page, frame, config);
-      await maybeCollectCaptchaDebugInfo(
-        page,
-        frame,
-        iframeLocator,
-        attempt,
-        "ready",
-        config
-      ).catch((error) => {
-        logger10.warn(`\u9A8C\u8BC1\u7801\u8C03\u8BD5\u6293\u53D6\u5931\u8D25\uFF1A${error?.message || error}`);
-      });
       await page.waitForTimeout(config.recognitionDelayMs);
       const screenshotBuffer = await iframeLocator.screenshot();
       const apiResponse = await callCaptchaRecognitionApi2({
@@ -5477,74 +5243,33 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
         await refreshCaptcha(page, frame, config);
         continue;
       }
-      const orderedSourceImages = await resolveCaptchaSourceImagesInVisualOrder(frame, config);
-      const normalizedIndexes = normalizeCaptchaImageIndexes(serialNumbers, orderedSourceImages.length);
-      if (normalizedIndexes.length !== serialNumbers.length) {
-        throw new Error(
-          `Captcha image indexes could not be normalized. raw=${serialNumbers.join(", ")}, count=${orderedSourceImages.length}`
-        );
-      }
-      logger10.info(`\u9A8C\u8BC1\u7801\u89C6\u89C9\u4F4D\u5E8F\u6620\u5C04\uFF1A${normalizedIndexes.map((index) => index + 1).join(", ")}`);
-      for (const imageIndex of normalizedIndexes) {
-        if (imageIndex < 0 || imageIndex >= orderedSourceImages.length) {
-          throw new Error(
-            `Captcha image index ${imageIndex} is out of range. count=${orderedSourceImages.length}`
-          );
+      const sourceImages = frame.locator(config.sourceImageSelector);
+      const imageCount = await sourceImages.count();
+      for (const rawIndex of serialNumbers) {
+        let imageIndex = rawIndex;
+        if (imageIndex >= imageCount && imageIndex > 0 && imageIndex - 1 < imageCount) {
+          imageIndex -= 1;
         }
-        const sourceImage = orderedSourceImages[imageIndex].locator;
+        if (imageIndex < 0 || imageIndex >= imageCount) {
+          throw new Error(`Captcha image index ${rawIndex} is out of range. count=${imageCount}`);
+        }
+        const sourceImage = sourceImages.nth(imageIndex);
         await sourceImage.waitFor({
           state: "visible",
           timeout: config.sourceImageVisibleTimeoutMs
         });
-        const dragResult = await dragPromptCaptchaImage(
-          page,
-          frame,
-          iframeLocator,
-          sourceImage,
-          dropTarget,
-          config,
-          {
-            attempt,
-            visualIndex: imageIndex
-          }
-        );
-        if (!dragResult.accepted) {
-          throw new Error(`Captcha prompt drag was not accepted for visual index ${imageIndex + 1}.`);
-        }
-        if (config.dragBetweenWaitMs > 0) {
-          await page.waitForTimeout(config.dragBetweenWaitMs);
-        }
+        await dragCaptchaAction(page, sourceImage, dropTarget);
       }
-      const beforeSubmitState = await readPromptCaptchaState(frame, config);
-      logger10.info(
-        `\u63D0\u4EA4\u524D\u9A8C\u8BC1\u7801\u72B6\u6001\uFF1Abadge=${beforeSubmitState.badgeCount}, selected=${beforeSubmitState.selectedCount}, submitDisabled=${beforeSubmitState.submitDisabled}`
-      );
-      const submitted = await clickCaptchaAction(frame, config.submitTexts, {
-        ...config,
-        page,
-        logger: logger10,
-        forceMouse: true,
-        actionVisibleTimeoutMs: config.submitReadyTimeoutMs
-      }).catch(() => false);
+      const submitted = await clickCaptchaAction(frame, config.submitTexts, { ...config, page }).catch(() => false);
       if (!submitted) {
         logger10.warn("\u672A\u627E\u5230\u63D0\u4EA4\u6309\u94AE\uFF0C\u53EF\u80FD\u4F1A\u81EA\u52A8\u63D0\u4EA4\u3002");
       }
       await page.waitForTimeout(config.submitWaitMs);
-      const afterSubmitState = await readPromptCaptchaState(frame, config);
-      logger10.info(
-        `\u63D0\u4EA4\u540E\u9A8C\u8BC1\u7801\u72B6\u6001\uFF1Abadge=${afterSubmitState.badgeCount}, selected=${afterSubmitState.selectedCount}, submitDisabled=${afterSubmitState.submitDisabled}`
-      );
       const stillVisible = await iframeLocator.isVisible({ timeout: config.containerVisibleTimeoutMs }).catch(() => false);
       if (!stillVisible) {
         logger10.info("\u9A8C\u8BC1\u7801\u8BC6\u522B\u5E76\u63D0\u4EA4\u6210\u529F\u3002");
         return true;
       }
-      await maybeCollectCaptchaDebugInfo(page, frame, iframeLocator, attempt, "submit-still-visible", config, {
-        beforeSubmitState,
-        afterSubmitState
-      }).catch((error) => {
-        logger10.warn(`\u63D0\u4EA4\u540E\u9A8C\u8BC1\u7801\u8C03\u8BD5\u6293\u53D6\u5931\u8D25\uFF1A${error?.message || error}`);
-      });
       logger10.warn("\u63D0\u4EA4\u540E\u9A8C\u8BC1\u7801 iframe \u4ECD\u7136\u53EF\u89C1\uFF0C\u51C6\u5907\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
       await page.waitForTimeout(2e3);
       await refreshCaptcha(page, frame, config);
@@ -5987,14 +5712,14 @@ var Mutation = {
             const isFrameElement = tagName === "IFRAME" || tagName === "FRAME";
             const nodeName = descriptor?.id || descriptor?.name || "no-id";
             let source = "main";
-            let path3 = `${selector}[${index}]`;
+            let path2 = `${selector}[${index}]`;
             let text = "";
             let html = "";
             let frameUrl = "";
             let readyState = "";
             if (isFrameElement) {
               source = "iframe";
-              path3 = `${selector}[${index}]::iframe(${nodeName})`;
+              path2 = `${selector}[${index}]::iframe(${nodeName})`;
               const frame = await handle.contentFrame();
               if (frame) {
                 try {
@@ -6024,7 +5749,7 @@ var Mutation = {
             items.push({
               selector,
               source,
-              path: path3,
+              path: path2,
               text,
               html,
               frameUrl,