@skrillex1224/playwright-toolkit 2.1.197 → 2.1.199

package/dist/index.js

@@ -393,9 +393,6 @@ function createInternalLogger(moduleName, explicitLogger) {
       const message = error instanceof Error ? error.message : error;
       baseLogger.error(`${methodName} \u5931\u8D25: ${message}`);
     },
-    error(message) {
-      baseLogger.error(message);
-    },
     debug(message) {
       baseLogger.debug(message);
     },
@@ -574,9 +571,31 @@ var logger2 = createInternalLogger("ProxyMeter");
 var MAX_TOP_DOMAINS = 20;
 var FLUSH_INTERVAL_MS = 2e3;
 var DEFAULT_DEBUG_MAX_EVENTS = 400;
+var PROXY_METER_READY_TIMEOUT_MS = 5e3;
+var PROXY_METER_STABLE_WINDOW_MS = 2e3;
+var PROXY_METER_POLL_INTERVAL_MS = 100;
+var PROXY_METER_CONNECT_TIMEOUT_MS = 200;
 var runtime = null;
 var cleanupInstalled = false;
 var observedDomainResourceTypes = /* @__PURE__ */ new Map();
+var sleepSignal = new Int32Array(new SharedArrayBuffer(4));
+var portProbeScript = [
+  'const net = require("net");',
+  "const port = Number(process.argv[1] || 0);",
+  "const timeout = Number(process.argv[2] || 200);",
+  "if (!Number.isFinite(port) || port <= 0) process.exit(2);",
+  'const socket = net.connect({ host: "127.0.0.1", port });',
+  "let done = false;",
+  "const finish = (code) => {",
+  "  if (done) return;",
+  "  done = true;",
+  "  try { socket.destroy(); } catch {}",
+  "  process.exit(code);",
+  "};",
+  'socket.once("connect", () => finish(0));',
+  'socket.once("error", () => finish(1));',
+  "socket.setTimeout(timeout, () => finish(1));"
+].join("");
 var toSafeInt = (value) => {
   const num = Number(value);
   if (!Number.isFinite(num) || num <= 0) return 0;
@@ -675,6 +694,17 @@ var ensureLogPath = () => {
   const label = runId ? `proxy-meter-${runId}-${suffix}.json` : `proxy-meter-${process.pid}-${suffix}.json`;
   return path.join(baseDir, label);
 };
+var ensureStatePath = () => {
+  const baseDir = resolveLogDir();
+  if (!existsSync(baseDir)) {
+    try {
+      mkdirSync(baseDir, { recursive: true });
+    } catch {
+    }
+  }
+  const suffix = `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+  return path.join(baseDir, `proxy-meter-state-${process.pid}-${suffix}.json`);
+};
 var readSnapshot = (logPath) => {
   if (!logPath || !existsSync(logPath)) return null;
   try {
@@ -685,6 +715,86 @@ var readSnapshot = (logPath) => {
     return null;
   }
 };
+var readState = (statePath) => {
+  if (!statePath || !existsSync(statePath)) return null;
+  try {
+    const raw = readFileSync(statePath, "utf8");
+    if (!raw) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var sleepSync = (durationMs) => {
+  const timeout = Math.max(0, Number(durationMs) || 0);
+  if (timeout <= 0) return;
+  Atomics.wait(sleepSignal, 0, 0, timeout);
+};
+var canConnectToPort = (port, timeoutMs = PROXY_METER_CONNECT_TIMEOUT_MS) => {
+  const result = spawnSync(process.execPath, ["-e", portProbeScript, String(port), String(timeoutMs)], {
+    stdio: "ignore",
+    timeout: timeoutMs + 100
+  });
+  return result.status === 0;
+};
+var waitForProxyMeterReady = ({ port, statePath }) => {
+  const startedAt = Date.now();
+  const listenDeadline = startedAt + PROXY_METER_READY_TIMEOUT_MS;
+  let firstConnectAt = 0;
+  let stableHealthy = true;
+  while (Date.now() < listenDeadline) {
+    const lifecycle = readState(statePath);
+    if (lifecycle?.status === "exited") {
+      return {
+        ok: false,
+        reason: "child_exit_before_ready",
+        childExitCode: lifecycle.exitCode,
+        latencyMs: Date.now() - startedAt
+      };
+    }
+    if (canConnectToPort(port)) {
+      firstConnectAt = Date.now();
+      break;
+    }
+    sleepSync(PROXY_METER_POLL_INTERVAL_MS);
+  }
+  if (!firstConnectAt) {
+    return {
+      ok: false,
+      reason: "listen_timeout",
+      childExitCode: readState(statePath)?.exitCode ?? null,
+      latencyMs: Date.now() - startedAt
+    };
+  }
+  const stableDeadline = firstConnectAt + PROXY_METER_STABLE_WINDOW_MS;
+  while (Date.now() < stableDeadline) {
+    const lifecycle = readState(statePath);
+    if (lifecycle?.status === "exited") {
+      return {
+        ok: false,
+        reason: "stabilize_timeout",
+        childExitCode: lifecycle.exitCode,
+        latencyMs: Date.now() - startedAt
+      };
+    }
+    if (!canConnectToPort(port)) {
+      stableHealthy = false;
+    }
+    sleepSync(PROXY_METER_POLL_INTERVAL_MS);
+  }
+  if (!stableHealthy || !canConnectToPort(port)) {
+    return {
+      ok: false,
+      reason: "stabilize_timeout",
+      childExitCode: readState(statePath)?.exitCode ?? null,
+      latencyMs: Date.now() - startedAt
+    };
+  }
+  return {
+    ok: true,
+    latencyMs: Date.now() - startedAt
+  };
+};
 var normalizeDomainRows = (hosts) => {
   const rows = [];
   let requestCount = 0;
@@ -833,15 +943,23 @@ var startProxyMeter = (options = {}) => {
   const upstreamUrl = String(options.proxyUrl || "").trim();
   if (!upstreamUrl) return null;
   if (runtime && runtime.proc) {
+    const previousStatePath = runtime.statePath;
     try {
       runtime.proc.kill("SIGTERM");
     } catch {
     }
     runtime = null;
+    if (previousStatePath) {
+      try {
+        rmSync(previousStatePath, { force: true });
+      } catch {
+      }
+    }
   }
   observedDomainResourceTypes = /* @__PURE__ */ new Map();
   const port = pickFreePort();
   const logPath = ensureLogPath();
+  const statePath = ensureStatePath();
   const scriptPath = resolveScriptPath();
   const debugMode = Boolean(options.debugMode);
   const debugMaxEvents = Math.max(10, toSafeInt(options.debugMaxEvents) || DEFAULT_DEBUG_MAX_EVENTS);
@@ -852,7 +970,8 @@ var startProxyMeter = (options = {}) => {
     PROXY_METER_UPSTREAM: upstreamUrl,
     PROXY_METER_FLUSH_MS: String(FLUSH_INTERVAL_MS),
     PROXY_METER_DEBUG: debugMode ? "1" : "0",
-    PROXY_METER_DEBUG_MAX_EVENTS: String(debugMaxEvents)
+    PROXY_METER_DEBUG_MAX_EVENTS: String(debugMaxEvents),
+    PROXY_METER_STATE: statePath
   };
   const child = spawn(process.execPath, [scriptPath], {
     env,
@@ -867,8 +986,27 @@ var startProxyMeter = (options = {}) => {
     proc: child,
     port,
     logPath,
+    statePath,
     startedAt: Date.now()
   };
+  const readiness = waitForProxyMeterReady({ port, statePath });
+  if (!readiness.ok) {
+    logger2.warn(
+      `[proxy-meter] startup failed reason=${readiness.reason} latency_ms=${readiness.latencyMs} exit_code=${readiness.childExitCode ?? "unknown"}`
+    );
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    runtime = null;
+    try {
+      rmSync(statePath, { force: true });
+    } catch {
+    }
+    throw new Error(`proxy-meter startup failed: ${readiness.reason}`);
+  }
+  runtime.startedAt = Date.now() - readiness.latencyMs;
+  logger2.info(`[proxy-meter] ready latency_ms=${readiness.latencyMs} stable_window_ms=${PROXY_METER_STABLE_WINDOW_MS}`);
   registerCleanup();
   return { server: `http://127.0.0.1:${port}` };
 };
@@ -880,9 +1018,15 @@ var recordProxyMeterResourceType = (requestUrl, resourceType) => {
 };
 var stopProxyMeter = async () => {
   if (!runtime) return null;
-  const { proc, logPath } = runtime;
+  const { proc, logPath, statePath } = runtime;
   if (!proc || proc.killed) {
     runtime = null;
+    if (statePath) {
+      try {
+        rmSync(statePath, { force: true });
+      } catch {
+      }
+    }
     return logPath || null;
   }
   await new Promise((resolve) => {
@@ -904,6 +1048,12 @@ var stopProxyMeter = async () => {
     }
   });
   runtime = null;
+  if (statePath) {
+    try {
+      rmSync(statePath, { force: true });
+    } catch {
+    }
+  }
   return logPath || null;
 };
 var getProxyMeterSnapshot = async (options = {}) => {
@@ -2927,41 +3077,13 @@ var LiveView = {
 // src/captcha-monitor.js
 import { v4 as uuidv4 } from "uuid";
 var logger9 = createInternalLogger("Captcha");
-var DEFAULT_BYTEDANCE_CAPTCHA_TOKEN = "eKJvBfwfN0YRav0-VD_44E2VBSfm7l0YtddUQ7cFySI";
-var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
-  token: DEFAULT_BYTEDANCE_CAPTCHA_TOKEN,
-  apiUrl: "https://api.jfbym.com/api/YmServer/customApi",
-  apiType: "31234",
-  maxRetries: 3,
-  containerSelector: "#captcha_container",
-  iframeSelector: 'iframe[src*="verifycenter"]',
-  iframeFallbackSelector: "iframe",
-  sourceImageSelector: "div.canvas-container",
-  dropTargetContainerSelector: "#captcha_verify_image div",
-  dropTargetTexts: ["\u62D6\u62FD\u5230\u8FD9\u91CC"],
-  refreshTexts: ["\u5237\u65B0"],
-  submitTexts: ["\u63D0\u4EA4"],
-  recognitionSuccessCode: 1e4,
-  containerVisibleTimeoutMs: 2e3,
-  iframeVisibleTimeoutMs: 12e3,
-  iframeFallbackVisibleTimeoutMs: 4e3,
-  contentFrameResolveRetries: 5,
-  contentFrameResolveDelayMs: 500,
-  actionVisibleTimeoutMs: 1500,
-  sourceImageVisibleTimeoutMs: 3e3,
-  recognitionDelayMs: 2e3,
-  refreshWaitMs: 3e3,
-  submitWaitMs: 3e3,
-  retryDelayBaseMs: 2e3,
-  retryDelayStepMs: 1e3
-});
 function useCaptchaMonitor(page, options) {
   const { domSelector, urlPattern, onDetected } = options;
   if (!domSelector && !urlPattern) {
-    throw new Error("[CaptchaMonitor] \u5FC5\u987B\u63D0\u4F9B domSelector \u6216 urlPattern\u3002");
+    throw new Error("[CaptchaMonitor] \u5FC5\u987B\u63D0\u4F9B domSelector \u6216 urlPattern \u81F3\u5C11\u4E00\u4E2A");
   }
   if (!onDetected || typeof onDetected !== "function") {
-    throw new Error("[CaptchaMonitor] onDetected \u5FC5\u987B\u662F\u51FD\u6570\u3002");
+    throw new Error("[CaptchaMonitor] onDetected \u5FC5\u987B\u662F\u4E00\u4E2A\u51FD\u6570");
   }
   let isStopped = false;
   let isHandling = false;
@@ -2982,22 +3104,28 @@ function useCaptchaMonitor(page, options) {
     const cleanerName = `__c_cleaner_${uuidv4().replace(/-/g, "_")}`;
     page.exposeFunction(exposedFunctionName, triggerDetected).catch(() => {
     });
-    page.addInitScript(({ selector, callbackName, cleanerName: cleanupName }) => {
+    page.addInitScript(({ selector, callbackName, cleanerName: cleanerName2 }) => {
       (() => {
         let observer = null;
         const checkAndReport = () => {
           const element = document.querySelector(selector);
-          if (!element) {
-            return false;
-          }
-          if (window[callbackName]) {
-            window[callbackName]();
+          if (element) {
+            if (window[callbackName]) {
+              window[callbackName]();
+            }
+            return true;
           }
-          return true;
+          return false;
         };
         checkAndReport();
         observer = new MutationObserver((mutations) => {
-          const shouldCheck = mutations.some((mutation) => mutation.addedNodes.length > 0);
+          let shouldCheck = false;
+          for (const mutation of mutations) {
+            if (mutation.addedNodes.length > 0) {
+              shouldCheck = true;
+              break;
+            }
+          }
           if (shouldCheck && observer) {
             checkAndReport();
           }
@@ -3013,7 +3141,7 @@ function useCaptchaMonitor(page, options) {
         } else {
           mountObserver();
         }
-        window[cleanupName] = () => {
+        window[cleanerName2] = () => {
           if (observer) {
             observer.disconnect();
             observer = null;
@@ -3021,7 +3149,7 @@ function useCaptchaMonitor(page, options) {
         };
       })();
     }, { selector: domSelector, callbackName: exposedFunctionName, cleanerName });
-    logger9.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${domSelector}`);
+    logger9.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528: ${domSelector}`);
     cleanupFns.push(async () => {
       try {
         await page.evaluate((name) => {
@@ -3030,29 +3158,28 @@ function useCaptchaMonitor(page, options) {
             delete window[name];
           }
         }, cleanerName);
-      } catch {
+      } catch (e) {
       }
     });
   }
   if (urlPattern) {
     frameHandler = async (frame) => {
-      if (frame !== page.mainFrame()) {
-        return;
-      }
-      const currentUrl = page.url();
-      if (currentUrl.includes(urlPattern)) {
-        await triggerDetected();
+      if (frame === page.mainFrame()) {
+        const currentUrl = page.url();
+        if (currentUrl.includes(urlPattern)) {
+          await triggerDetected();
+        }
       }
     };
     page.on("framenavigated", frameHandler);
-    logger9.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${urlPattern}`);
+    logger9.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528: ${urlPattern}`);
     cleanupFns.push(async () => {
       page.off("framenavigated", frameHandler);
     });
   }
   return {
     stop: async () => {
-      logger9.info("\u6B63\u5728\u505C\u6B62\u9A8C\u8BC1\u7801\u76D1\u63A7...");
+      logger9.info("useCaptchaMonitor", "\u6B63\u5728\u505C\u6B62\u76D1\u63A7...");
       for (const fn of cleanupFns) {
         await fn();
       }
@@ -3060,241 +3187,8 @@ function useCaptchaMonitor(page, options) {
     }
   };
 }
-var callCaptchaRecognitionApi = async (imageBase64, { apiUrl, apiType, token }) => {
-  const response = await fetch(apiUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      type: apiType,
-      image: imageBase64,
-      token
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`Captcha API request failed with status ${response.status}`);
-  }
-  return await response.json();
-};
-var extractCaptchaSerialNumbers = (apiResponse) => {
-  const serialNumbers = apiResponse?.data?.data?.serial_number;
-  if (!Array.isArray(serialNumbers)) {
-    return [];
-  }
-  return serialNumbers.map((value) => Number(value)).filter((value) => Number.isInteger(value) && value >= 0);
-};
-var waitForVisible = async (locator, timeout) => {
-  try {
-    await locator.waitFor({
-      state: "visible",
-      timeout
-    });
-    return true;
-  } catch {
-    return false;
-  }
-};
-var resolveContentFrame = async (page, iframeLocator, options) => {
-  for (let attempt = 1; attempt <= options.contentFrameResolveRetries; attempt++) {
-    const iframeHandle = await iframeLocator.elementHandle();
-    const frame = await iframeHandle?.contentFrame();
-    if (frame) {
-      return frame;
-    }
-    if (attempt < options.contentFrameResolveRetries) {
-      await page.waitForTimeout(options.contentFrameResolveDelayMs);
-    }
-  }
-  return null;
-};
-var getVerifycenterCaptchaContext = async (page, options) => {
-  const captchaContainer = page.locator(options.containerSelector).first();
-  const isContainerVisible = await waitForVisible(
-    captchaContainer,
-    options.containerVisibleTimeoutMs
-  );
-  if (!isContainerVisible) {
-    return null;
-  }
-  logger9.info("\u68C0\u6D4B\u5230\u9A8C\u8BC1\u7801\u5BB9\u5668\uFF0C\u5F00\u59CB\u7B49\u5F85 iframe \u52A0\u8F7D\u3002");
-  let iframeLocator = page.locator(options.iframeSelector).first();
-  let isIframeVisible = await waitForVisible(
-    iframeLocator,
-    options.iframeVisibleTimeoutMs
-  );
-  if (!isIframeVisible) {
-    logger9.warn("\u672A\u5728\u9884\u671F\u9009\u62E9\u5668\u4E2D\u627E\u5230 verifycenter iframe\uFF0C\u5C1D\u8BD5\u5BB9\u5668\u5185\u4EFB\u610F iframe\u3002");
-    iframeLocator = captchaContainer.locator(options.iframeFallbackSelector).first();
-    isIframeVisible = await waitForVisible(
-      iframeLocator,
-      options.iframeFallbackVisibleTimeoutMs
-    );
-  }
-  if (!isIframeVisible) {
-    throw new Error("verifycenter iframe not found inside captcha container.");
-  }
-  logger9.info("\u9A8C\u8BC1\u7801 iframe \u5DF2\u53EF\u89C1\uFF0C\u5F00\u59CB\u89E3\u6790\u5185\u5BB9 frame\u3002");
-  const frame = await resolveContentFrame(page, iframeLocator, options);
-  if (!frame) {
-    throw new Error("Failed to resolve verifycenter iframe content frame.");
-  }
-  return { iframeLocator, frame };
-};
-var clickCaptchaAction = async (frame, texts, options) => {
-  for (const text of texts) {
-    const candidates = [
-      frame.getByText(text, { exact: false }).first(),
-      frame.locator(`text=${text}`).first()
-    ];
-    for (const candidate of candidates) {
-      const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
-      if (!isVisible) {
-        continue;
-      }
-      await candidate.click();
-      return true;
-    }
-  }
-  return false;
-};
-var findCaptchaDropTarget = async (frame, options) => {
-  for (const text of options.dropTargetTexts) {
-    const candidates = [
-      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);
-      if (isVisible) {
-        return candidate;
-      }
-    }
-  }
-  return null;
-};
-var dragCaptchaWithMouse = async (page, sourceLocator, targetLocator) => {
-  const sourceBox = await sourceLocator.boundingBox();
-  const targetBox = await targetLocator.boundingBox();
-  if (!sourceBox || !targetBox) {
-    throw new Error("Unable to resolve captcha drag coordinates.");
-  }
-  const startX = sourceBox.x + sourceBox.width / 2;
-  const startY = sourceBox.y + sourceBox.height / 2;
-  const endX = targetBox.x + targetBox.width / 2;
-  const endY = targetBox.y + targetBox.height / 2;
-  const steps = 10;
-  const liftOffsetX = Math.min(18, Math.max(8, sourceBox.width * 0.12));
-  const liftOffsetY = Math.min(12, Math.max(4, sourceBox.height * 0.08));
-  await page.mouse.move(startX, startY, { steps: 8 });
-  await page.waitForTimeout(250);
-  await page.mouse.down();
-  await page.waitForTimeout(350);
-  await page.mouse.move(startX + liftOffsetX, startY + liftOffsetY, { steps: 6 });
-  await page.waitForTimeout(250);
-  for (let step = 1; step <= steps; step++) {
-    const progress = step / steps;
-    const easedProgress = 1 - (1 - progress) * (1 - progress);
-    const currentX = startX + liftOffsetX + (endX - startX - liftOffsetX) * easedProgress;
-    const currentY = startY + liftOffsetY + (endY - startY - liftOffsetY) * easedProgress;
-    await page.mouse.move(currentX, currentY, { steps: 2 });
-    await page.waitForTimeout(90);
-  }
-  await page.waitForTimeout(100);
-  await page.mouse.up();
-  await page.waitForTimeout(100);
-};
-var refreshCaptcha = async (page, frame, options) => {
-  const clicked = await clickCaptchaAction(frame, options.refreshTexts, options).catch(() => false);
-  if (!clicked) {
-    logger9.warn("Refresh button not found.");
-    return false;
-  }
-  await page.waitForTimeout(options.refreshWaitMs);
-  return true;
-};
-async function solveBytedanceCaptcha(page, options = {}) {
-  const config = {
-    ...DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS,
-    ...options
-  };
-  if (!config.token) {
-    logger9.warn("\u7F3A\u5C11\u9A8C\u8BC1\u7801 token\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u8BC6\u522B\u3002");
-    return false;
-  }
-  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-    logger9.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
-    try {
-      const captchaContext = await getVerifycenterCaptchaContext(page, config);
-      if (!captchaContext) {
-        logger9.info("Captcha container is not visible anymore.");
-        return true;
-      }
-      const { iframeLocator, frame } = captchaContext;
-      await page.waitForTimeout(config.recognitionDelayMs);
-      const screenshotBuffer = await iframeLocator.screenshot();
-      const apiResponse = await callCaptchaRecognitionApi(
-        screenshotBuffer.toString("base64"),
-        config
-      );
-      const serialNumbers = extractCaptchaSerialNumbers(apiResponse);
-      if (apiResponse?.code !== config.recognitionSuccessCode || serialNumbers.length === 0) {
-        logger9.warn(
-          `\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\u3002code=${apiResponse?.code}, msg=${apiResponse?.msg || "unknown"}`
-        );
-        await refreshCaptcha(page, frame, config);
-        continue;
-      }
-      logger9.info(`\u9A8C\u8BC1\u7801\u8BC6\u522B\u6210\u529F\uFF0C\u5E8F\u53F7\uFF1A${serialNumbers.join(", ")}`);
-      const dropTarget = await findCaptchaDropTarget(frame, config);
-      if (!dropTarget) {
-        logger9.warn("\u672A\u627E\u5230\u9A8C\u8BC1\u7801\u62D6\u62FD\u76EE\u6807\u533A\u57DF\u3002");
-        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 sourceImage = sourceImages.nth(imageIndex);
-        await sourceImage.waitFor({
-          state: "visible",
-          timeout: config.sourceImageVisibleTimeoutMs
-        });
-        await dragCaptchaWithMouse(page, sourceImage, dropTarget);
-      }
-      const submitted = await clickCaptchaAction(frame, config.submitTexts, config).catch(() => false);
-      if (!submitted) {
-        logger9.warn("\u672A\u627E\u5230\u63D0\u4EA4\u6309\u94AE\uFF0C\u53EF\u80FD\u4F1A\u81EA\u52A8\u63D0\u4EA4\u3002");
-      }
-      await page.waitForTimeout(config.submitWaitMs);
-      const stillVisible = await iframeLocator.isVisible({ timeout: config.containerVisibleTimeoutMs }).catch(() => false);
-      if (!stillVisible) {
-        logger9.info("\u9A8C\u8BC1\u7801\u8BC6\u522B\u5E76\u63D0\u4EA4\u6210\u529F\u3002");
-        return true;
-      }
-      logger9.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);
-    } catch (error) {
-      logger9.error(`\u7B2C ${attempt}/${config.maxRetries} \u6B21\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\uFF1A${error?.message || error}`);
-    }
-    if (attempt < config.maxRetries) {
-      await page.waitForTimeout(config.retryDelayBaseMs + attempt * config.retryDelayStepMs);
-    }
-  }
-  logger9.error(`\u91CD\u8BD5 ${config.maxRetries} \u6B21\u540E\uFF0C\u9A8C\u8BC1\u7801\u4ECD\u672A\u8BC6\u522B\u6210\u529F\u3002`);
-  return false;
-}
 var Captcha = {
-  useCaptchaMonitor,
-  solveBytedanceCaptcha
+  useCaptchaMonitor
 };
 
 // src/mutation.js