@skrillex1224/playwright-toolkit 2.1.247 → 2.1.249

package/dist/index.js

@@ -106,10 +106,10 @@ var createActorInfo = (info) => {
       xurl
     };
   };
-  const buildLandingUrl = ({ protocol: protocol2, domain: domain2, path: path3 }) => {
+  const buildLandingUrl = ({ protocol: protocol2, domain: domain2, path: path4 }) => {
     const safeProtocol = String(protocol2).trim();
     const safeDomain = normalizeDomain(domain2);
-    const safePath = normalizePath(path3);
+    const safePath = normalizePath(path4);
     return `${safeProtocol}://${safeDomain}${safePath}`;
   };
   const buildIcon = ({ key }) => {
@@ -117,14 +117,14 @@ var createActorInfo = (info) => {
   };
   const protocol = info.protocol || "https";
   const domain = normalizeDomain(info.domain);
-  const path2 = normalizePath(info.path);
+  const path3 = normalizePath(info.path);
   const share = normalizeShare2(info.share);
   const device = normalizeDevice(info.device);
   return {
     ...info,
     protocol,
     domain,
-    path: path2,
+    path: path3,
     share,
     device,
     get icon() {
@@ -1484,7 +1484,7 @@ var normalizeCookies = (value) => {
     if (!name || !cookieValue || cookieValue === "<nil>") return null;
     const domain = String(raw.domain || "").trim();
     const url = normalizeHttpUrl(raw.url);
-    const path2 = String(raw.path || "").trim() || "/";
+    const path3 = String(raw.path || "").trim() || "/";
     const sameSite = normalizeCookieSameSite(raw.sameSite);
     const expires = normalizeCookieExpires(raw);
     const secure = Boolean(raw.secure);
@@ -1493,7 +1493,7 @@ var normalizeCookies = (value) => {
     const normalized = {
       name,
       value: cookieValue,
-      path: path2,
+      path: path3,
       ...domain ? { domain } : {},
       ...!domain && url ? { url } : {},
       ...sameSite ? { sameSite } : {},
@@ -2564,6 +2564,10 @@ 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);
@@ -2583,6 +2587,11 @@ 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);
@@ -2592,6 +2601,7 @@ 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 }]
@@ -2613,6 +2623,14 @@ 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",
@@ -2630,7 +2648,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) {
+  if (target && resolvedDevice === Device.Mobile && !normalizedOptions.forceClick && !normalizedOptions.forceMouse) {
     if (typeof target.tap === "function") {
       await target.tap(normalizedOptions.tapOptions);
       return true;
@@ -2830,20 +2848,26 @@ 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: sourceBox.x + sourceBox.width / 2,
-        y: sourceBox.y + sourceBox.height / 2
+        x: sourceCenterX,
+        y: sourceCenterY
       },
       lift: {
-        x: sourceBox.x + sourceBox.width / 2 + liftOffsetX,
-        y: sourceBox.y + sourceBox.height / 2 + liftOffsetY
+        x: sourceCenterX + liftOffsetX,
+        y: sourceCenterY + liftOffsetY
       },
       end: {
-        x: targetBox.x + targetBox.width / 2,
-        y: targetBox.y + targetBox.height / 2
+        x: targetBox.x + targetBox.width / 2 + targetOffsetX,
+        y: targetBox.y + targetBox.height / 2 + targetOffsetY
       },
       steps
     };
@@ -3379,13 +3403,6 @@ 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));
 };
-var randomPointInBox = (box, paddingRatio = 0.24) => {
-  const safePaddingX = Math.max(2, Math.min(box.width * paddingRatio, box.width / 2));
-  const safePaddingY = Math.max(2, Math.min(box.height * paddingRatio, box.height / 2));
-  const x = box.x + safePaddingX + Math.random() * Math.max(1, box.width - safePaddingX * 2);
-  const y = box.y + safePaddingY + Math.random() * Math.max(1, box.height - safePaddingY * 2);
-  return { x, y };
-};
 var resolveElement = async (page, target, { throwOnMissing = true } = {}) => {
   if (target == null) return null;
   let element = target;
@@ -3430,6 +3447,10 @@ var clipBoxToViewport = (box, viewport) => {
   }
   return box;
 };
+var centerPointInBox = (box) => ({
+  x: box.x + box.width / 2,
+  y: box.y + box.height / 2
+});
 var withTimeout = async (operation, timeoutMs, label) => {
   const safeTimeoutMs = Math.max(50, Number(timeoutMs || 0));
   let timeoutId = null;
@@ -3581,97 +3602,6 @@ var checkElementVisibility = async (element) => {
     return { code: "VISIBLE", isFixed, positioning };
   });
 };
-var resolveSafeTapPoint = async (element) => {
-  return element.evaluate((el) => {
-    const rect = el.getBoundingClientRect();
-    if (!rect || rect.width <= 0 || rect.height <= 0) {
-      return null;
-    }
-    const viewW = window.innerWidth;
-    const viewH = window.innerHeight;
-    let clipLeft = 0;
-    let clipRight = viewW;
-    let clipTop = 0;
-    let clipBottom = viewH;
-    for (let node = el.parentElement; node && node !== document.body; node = node.parentElement) {
-      const style = window.getComputedStyle(node);
-      if (!style) continue;
-      const clipsX = ["auto", "scroll", "overlay", "hidden", "clip"].includes(style.overflowX);
-      const clipsY = ["auto", "scroll", "overlay", "hidden", "clip"].includes(style.overflowY);
-      if (!clipsX && !clipsY) continue;
-      const nodeRect = node.getBoundingClientRect();
-      if (!nodeRect || nodeRect.width <= 0 || nodeRect.height <= 0) continue;
-      if (clipsX) {
-        clipLeft = Math.max(clipLeft, nodeRect.left);
-        clipRight = Math.min(clipRight, nodeRect.right);
-      }
-      if (clipsY) {
-        clipTop = Math.max(clipTop, nodeRect.top);
-        clipBottom = Math.min(clipBottom, nodeRect.bottom);
-      }
-    }
-    const visibleLeft = Math.max(clipLeft, Math.min(clipRight, rect.left));
-    const visibleRight = Math.max(clipLeft, Math.min(clipRight, rect.right));
-    const visibleTop = Math.max(clipTop, Math.min(clipBottom, rect.top));
-    const visibleBottom = Math.max(clipTop, Math.min(clipBottom, rect.bottom));
-    const visibleWidth = visibleRight - visibleLeft;
-    const visibleHeight = visibleBottom - visibleTop;
-    if (visibleWidth <= 1 || visibleHeight <= 1) {
-      return null;
-    }
-    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;
-      }
-      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 common.contains(el) && common.contains(pointElement);
-    };
-    const cx = visibleLeft + visibleWidth / 2;
-    const cy = visibleTop + visibleHeight / 2;
-    const smallX = Math.min(12, Math.max(2, visibleWidth * 0.18));
-    const smallY = Math.min(12, Math.max(2, visibleHeight * 0.18));
-    const points = [
-      { x: cx, y: cy },
-      { x: visibleLeft + smallX, y: visibleTop + smallY },
-      { x: visibleRight - smallX, y: visibleTop + smallY },
-      { x: visibleLeft + smallX, y: visibleBottom - smallY },
-      { x: visibleRight - smallX, y: visibleBottom - smallY },
-      { x: cx, y: visibleTop + Math.min(10, Math.max(2, visibleHeight * 0.2)) },
-      { x: cx, y: visibleBottom - Math.min(10, Math.max(2, visibleHeight * 0.2)) },
-      { x: visibleLeft + Math.min(10, Math.max(2, visibleWidth * 0.2)), y: cy },
-      { x: visibleRight - Math.min(10, Math.max(2, visibleWidth * 0.2)), y: cy }
-    ];
-    const safePoints = points.filter((point) => {
-      const pointElement = document.elementFromPoint(point.x, point.y);
-      return sameTapTarget(pointElement);
-    });
-    const candidates = safePoints.length ? safePoints : points;
-    const chosen = candidates[Math.floor(Math.random() * candidates.length)];
-    if (!chosen) return null;
-    return {
-      x: chosen.x,
-      y: chosen.y
-    };
-  });
-};
 var activateElementFallback = async (element, point = null, options = {}) => {
   return element.evaluate((el, { innerOptions }) => {
     const isEditable = (node) => {
@@ -4256,8 +4186,8 @@ var MobileHumanize = {
         return false;
       }
       await waitJitter(reactionDelay, 0.45);
-      const safePoint = await resolveSafeTapPoint(element).catch(() => null);
-      const tapTarget = safePoint || randomPointInBox(clipBoxToViewport(box, resolveViewport(page)), 0.2);
+      const visibleBox = clipBoxToViewport(box, resolveViewport(page));
+      const tapTarget = centerPointInBox(visibleBox);
       try {
         await tapPoint(page, tapTarget, {
           timeoutMs: tapTimeoutMs,
@@ -4960,6 +4890,10 @@ var LiveView = {
 // src/chaptcha.js
 import { v4 as uuidv4 } from "uuid";
 
+// src/internals/captcha/bytedance.js
+import { mkdir, writeFile } from "fs/promises";
+import path2 from "path";
+
 // src/internals/captcha/shared.js
 var waitForVisible = async (locator, timeout) => {
   try {
@@ -4977,38 +4911,71 @@ var isAnyCaptchaTextVisible = async (frame, texts, timeout) => {
     if (!text) {
       continue;
     }
-    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;
+    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;
+        }
       }
     }
   }
   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 candidates = [
-      frame.getByText(text, { exact: false }).first(),
-      frame.locator(`text=${text}`).first()
+    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 }
     ];
-    for (const candidate of candidates) {
-      const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
-      if (!isVisible) {
-        continue;
+    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;
       }
-      await DeviceInput.click(options.page, candidate);
-      return true;
     }
   }
   return false;
 };
-var dragCaptchaAction = async (page, sourceLocator, targetLocator) => {
-  await DeviceInput.drag(page, sourceLocator, targetLocator);
+var dragCaptchaAction = async (page, sourceLocator, targetLocator, options = {}) => {
+  await DeviceInput.drag(page, sourceLocator, targetLocator, options);
 };
 
 // src/internals/captcha/bytedance.js
@@ -5019,11 +4986,12 @@ var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
   containerSelector: "#captcha_container",
   iframeSelector: 'iframe[src*="verifycenter"]',
   iframeFallbackSelector: "iframe",
-  sourceImageSelector: "div.canvas-container",
-  dropTargetContainerSelector: "#captcha_verify_image div",
+  sourceImageSelector: ".img-container .canvas-container",
+  dropTargetContainerSelector: ".drag-area",
   dropTargetTexts: ["\u62D6\u62FD\u5230\u8FD9\u91CC"],
   refreshTexts: ["\u5237\u65B0"],
   submitTexts: ["\u63D0\u4EA4"],
+  guideMaskSelector: ".play-guide-mask",
   recognitionSuccessCode: 1e4,
   containerVisibleTimeoutMs: 2e3,
   iframeVisibleTimeoutMs: 12e3,
@@ -5046,10 +5014,111 @@ var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
   ],
   recognitionDelayMs: 2e3,
   refreshWaitMs: 3e3,
-  submitWaitMs: 3e3,
+  submitWaitMs: 5e3,
+  submitReadyTimeoutMs: 2500,
   retryDelayBaseMs: 2e3,
-  retryDelayStepMs: 1e3
+  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
 });
+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 = () => path2.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 mkdir(debugDir, { recursive: true });
+  const baseName = `bytedance-${timestamp}-attempt${attempt}-${phase}`;
+  const iframeScreenshotPath = path2.join(debugDir, `${baseName}-iframe.png`);
+  const pageScreenshotPath = path2.join(debugDir, `${baseName}-page.png`);
+  const htmlPath = path2.join(debugDir, `${baseName}-iframe.html`);
+  const infoPath = path2.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 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 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)) {
@@ -5058,7 +5127,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++) {
+  for (let attempt = 1; attempt <= options.contentFrameResolveRetries; attempt += 1) {
     const iframeHandle = await iframeLocator.elementHandle();
     const frame = await iframeHandle?.contentFrame();
     if (frame) {
@@ -5103,20 +5172,15 @@ var getVerifycenterCaptchaContext = async (page, options) => {
   }
   return { iframeLocator, frame };
 };
-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) => {
+  const directTarget = frame.locator(options.dropTargetContainerSelector).first();
+  if (await waitForVisible(directTarget, options.actionVisibleTimeoutMs)) {
+    return directTarget;
+  }
   for (const text of options.dropTargetTexts) {
     const candidates = [
-      frame.locator(options.dropTargetContainerSelector).filter({ hasText: text }).first(),
-      frame.getByText(text, { exact: false }).first()
+      frame.getByText(text, { exact: false }).first(),
+      frame.locator(`text=${text}`).first()
     ];
     for (const candidate of candidates) {
       const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
@@ -5127,10 +5191,112 @@ 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,
@@ -5146,8 +5312,17 @@ 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;
-    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");
+    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"
+      );
       return;
     }
     if (hasErrorTextVisible) {
@@ -5157,8 +5332,8 @@ var waitForCaptchaChallengeReady = async (page, frame, options) => {
       hasSeenLoading = false;
       continue;
     }
-    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`);
+    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`);
       await refreshCaptcha(page, frame, options);
       refreshDeadline = Date.now() + options.challengeReadyRefreshTimeoutMs;
       hasSeenLoading = false;
@@ -5168,6 +5343,69 @@ 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") {
@@ -5182,7 +5420,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++) {
+  for (let attempt = 1; attempt <= config.maxRetries; attempt += 1) {
     logger10.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
     try {
       const captchaContext = await getVerifycenterCaptchaContext(page, config);
@@ -5192,6 +5430,16 @@ 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({
@@ -5215,33 +5463,74 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
         await refreshCaptcha(page, frame, config);
         continue;
       }
-      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;
-        }
-        if (imageIndex < 0 || imageIndex >= imageCount) {
-          throw new Error(`Captcha image index ${rawIndex} is out of range. count=${imageCount}`);
+      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 sourceImage = sourceImages.nth(imageIndex);
+        const sourceImage = orderedSourceImages[imageIndex].locator;
         await sourceImage.waitFor({
           state: "visible",
           timeout: config.sourceImageVisibleTimeoutMs
         });
-        await dragCaptchaAction(page, sourceImage, dropTarget);
+        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);
+        }
       }
-      const submitted = await clickCaptchaAction(frame, config.submitTexts, { ...config, page }).catch(() => false);
+      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);
       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);
@@ -5684,14 +5973,14 @@ var Mutation = {
             const isFrameElement = tagName === "IFRAME" || tagName === "FRAME";
             const nodeName = descriptor?.id || descriptor?.name || "no-id";
             let source = "main";
-            let path2 = `${selector}[${index}]`;
+            let path3 = `${selector}[${index}]`;
             let text = "";
             let html = "";
             let frameUrl = "";
             let readyState = "";
             if (isFrameElement) {
               source = "iframe";
-              path2 = `${selector}[${index}]::iframe(${nodeName})`;
+              path3 = `${selector}[${index}]::iframe(${nodeName})`;
               const frame = await handle.contentFrame();
               if (frame) {
                 try {
@@ -5721,7 +6010,7 @@ var Mutation = {
             items.push({
               selector,
               source,
-              path: path2,
+              path: path3,
               text,
               html,
               frameUrl,