@skrillex1224/playwright-toolkit 2.1.279 → 2.1.281

package/dist/index.js

@@ -360,18 +360,18 @@ var fallbackLog = {
   error: (...args) => console.error(...args),
   debug: (...args) => console.debug ? console.debug(...args) : console.log(...args)
 };
-var resolveLogMethod = (logger17, name) => {
-  if (logger17 && typeof logger17[name] === "function") {
-    return logger17[name].bind(logger17);
+var resolveLogMethod = (logger16, name) => {
+  if (logger16 && typeof logger16[name] === "function") {
+    return logger16[name].bind(logger16);
   }
-  if (name === "warning" && logger17 && typeof logger17.warn === "function") {
-    return logger17.warn.bind(logger17);
+  if (name === "warning" && logger16 && typeof logger16.warn === "function") {
+    return logger16.warn.bind(logger16);
   }
   return fallbackLog[name];
 };
 var defaultLogger = null;
-var setDefaultLogger = (logger17) => {
-  defaultLogger = logger17;
+var setDefaultLogger = (logger16) => {
+  defaultLogger = logger16;
 };
 var resolveLogger = (explicitLogger) => {
   if (explicitLogger && typeof explicitLogger.info === "function") {
@@ -398,8 +398,8 @@ var colorize = (text, color) => {
 var createBaseLogger = (prefix = "", explicitLogger) => {
   const name = prefix ? String(prefix) : "";
   const dispatch = (methodName, icon, message, color) => {
-    const logger17 = resolveLogger(explicitLogger);
-    const logFn = resolveLogMethod(logger17, methodName);
+    const logger16 = resolveLogger(explicitLogger);
+    const logFn = resolveLogMethod(logger16, methodName);
     const timestamp = colorize(`[${formatTimestamp()}]`, ANSI.gray);
     const line = formatLine(name, icon, message);
     const coloredLine = colorize(line, color);
@@ -896,7 +896,7 @@ var prepareExpandedFullPageScreenshot = async (page, options = {}) => {
     viewportResized
   };
 };
-var restoreExpandedFullPageScreenshot = async (page, state = {}) => {
+var restoreExpandedFullPageScreenshot = async (page, state2 = {}) => {
   await page.evaluate((className) => {
     const targets = new Set([
       ...document.querySelectorAll(`.${className}`),
@@ -920,8 +920,8 @@ var restoreExpandedFullPageScreenshot = async (page, state = {}) => {
       el.classList.remove(className);
     });
   }, EXPANDED_SCROLLABLE_CLASS);
-  if (state?.originalViewport && state?.viewportResized) {
-    await page.setViewportSize(state.originalViewport);
+  if (state2?.originalViewport && state2?.viewportResized) {
+    await page.setViewportSize(state2.originalViewport);
   }
 };
 var capturePageScreenshot = async (page, options = {}) => {
@@ -978,21 +978,21 @@ var capturePageScreenshot = async (page, options = {}) => {
   }
 };
 var captureExpandedFullPageScreenshot = async (page, options = {}) => {
-  const state = await prepareExpandedFullPageScreenshot(page, options);
+  const state2 = await prepareExpandedFullPageScreenshot(page, options);
   try {
     return await capturePageScreenshot(page, {
       fullPage: true,
       type: options.type || "png",
       quality: options.quality,
       timeout: options.timeout,
-      maxClipHeight: state.targetHeight
+      maxClipHeight: state2.targetHeight
     });
   } finally {
     await restoreAffixedElementsForExpandedScreenshot(page).catch((error) => {
       logger.warning(`\u79FB\u52A8\u7AEF\u5438\u9644\u5143\u7D20\u6062\u590D\u5931\u8D25: ${error?.message || error}`);
     });
     if (options.restore) {
-      await restoreExpandedFullPageScreenshot(page, state);
+      await restoreExpandedFullPageScreenshot(page, state2);
     }
   }
 };
@@ -1887,8 +1887,8 @@ var normalizeBrowserProfile = (value) => {
     payload: buildBrowserProfilePayload(core, observed)
   };
 };
-var rememberRuntimeState = (state) => {
-  rememberedRuntimeState = deepClone(state);
+var rememberRuntimeState = (state2) => {
+  rememberedRuntimeState = deepClone(state2);
   return rememberedRuntimeState;
 };
 var normalizeRuntimeState = (source = {}, actor = "") => {
@@ -1947,7 +1947,7 @@ var RuntimeEnv = {
     } else {
       delete normalizedRuntime.browser_profile;
     }
-    const state = {
+    const state2 = {
       actor: resolvedActor,
       device,
       runtime: normalizedRuntime,
@@ -1961,73 +1961,73 @@ var RuntimeEnv = {
       browserProfileCore: browserProfile.core,
       browserProfileObserved: browserProfile.observed
     };
-    rememberRuntimeState(state);
-    return state;
+    rememberRuntimeState(state2);
+    return state2;
   },
   // buildEnvPatch 只构造允许回写到后端 env 的字段集合。
   buildEnvPatch(source = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
-    const browserProfile = buildBrowserProfilePayload(state.browserProfileCore, state.browserProfileObserved);
+    const state2 = normalizeRuntimeState(source, actor);
+    const browserProfile = buildBrowserProfilePayload(state2.browserProfileCore, state2.browserProfileObserved);
     const envPatch = {
-      ...Array.isArray(state.cookies) && state.cookies.length > 0 ? { cookies: state.cookies } : {},
-      ...Object.keys(state.localStorage || {}).length > 0 ? { local_storage: state.localStorage } : {},
-      ...Object.keys(state.sessionStorage || {}).length > 0 ? { session_storage: state.sessionStorage } : {},
+      ...Array.isArray(state2.cookies) && state2.cookies.length > 0 ? { cookies: state2.cookies } : {},
+      ...Object.keys(state2.localStorage || {}).length > 0 ? { local_storage: state2.localStorage } : {},
+      ...Object.keys(state2.sessionStorage || {}).length > 0 ? { session_storage: state2.sessionStorage } : {},
       ...Object.keys(browserProfile).length > 0 ? { browser_profile: browserProfile } : {}
     };
     return Object.keys(envPatch).length > 0 ? envPatch : null;
   },
   // hasLoginState 只判断 runtime 是否存在有效载荷，不再区分具体字段来源。
   hasLoginState(source = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
-    return isPlainObject(state.runtime) && Object.keys(state.runtime || {}).length > 0;
+    const state2 = normalizeRuntimeState(source, actor);
+    return isPlainObject(state2.runtime) && Object.keys(state2.runtime || {}).length > 0;
   },
   rememberState(source = {}) {
-    const state = normalizeRuntimeState(source);
-    rememberRuntimeState(state);
+    const state2 = normalizeRuntimeState(source);
+    rememberRuntimeState(state2);
     return RuntimeEnv.peekRememberedState();
   },
   peekRememberedState() {
     return rememberedRuntimeState ? deepClone(rememberedRuntimeState) : null;
   },
   getBrowserProfileCore(source = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
-    return deepClone(state.browserProfileCore || {});
+    const state2 = normalizeRuntimeState(source, actor);
+    return deepClone(state2.browserProfileCore || {});
   },
   setBrowserProfileCore(source = {}, core = {}, actor = "") {
-    const state = normalizeRuntimeState(source, actor);
+    const state2 = normalizeRuntimeState(source, actor);
     const normalizedCore = normalizeBrowserProfileCore({
       ...core,
-      device: normalizeKnownDevice(core?.device) || state.device
+      device: normalizeKnownDevice(core?.device) || state2.device
     });
-    state.browserProfileCore = normalizedCore;
-    state.browserProfile = buildBrowserProfilePayload(normalizedCore, state.browserProfileObserved);
-    if (Object.keys(state.browserProfile).length > 0) {
-      state.runtime.browser_profile = state.browserProfile;
+    state2.browserProfileCore = normalizedCore;
+    state2.browserProfile = buildBrowserProfilePayload(normalizedCore, state2.browserProfileObserved);
+    if (Object.keys(state2.browserProfile).length > 0) {
+      state2.runtime.browser_profile = state2.browserProfile;
     } else {
-      delete state.runtime.browser_profile;
+      delete state2.runtime.browser_profile;
     }
-    rememberRuntimeState(state);
-    return state;
+    rememberRuntimeState(state2);
+    return state2;
   },
   // applyToPage 只负责把登录态相关字段注入页面：
   // cookies / localStorage / sessionStorage。
   // 指纹、时区、UA、viewport 的回放发生在 launch.js 启动阶段，不在这里做。
   async applyToPage(page, source = {}, options = {}) {
     if (!page) return;
-    let state = normalizeRuntimeState(source, options?.actor || "");
+    let state2 = normalizeRuntimeState(source, options?.actor || "");
     if (typeof options?.preapply === "function") {
-      state = await options.preapply(state) || state;
-      rememberRuntimeState(state);
+      state2 = await options.preapply(state2) || state2;
+      rememberRuntimeState(state2);
     }
     Object.defineProperty(page, PageRuntimeStateKey, {
       configurable: true,
       enumerable: false,
       writable: true,
-      value: state
+      value: state2
     });
-    const localStorage = state.localStorage || {};
-    const sessionStorage = state.sessionStorage || {};
-    const cookies = (state.cookies || []).map((cookie) => {
+    const localStorage = state2.localStorage || {};
+    const sessionStorage = state2.sessionStorage || {};
+    const cookies = (state2.cookies || []).map((cookie) => {
       const normalized = { ...cookie };
       if (!normalized.path) {
         normalized.path = "/";
@@ -2065,8 +2065,8 @@ var RuntimeEnv = {
   },
   // captureEnvPatch 在任务结束时采集最新环境快照，用于 pushSuccess / pushFailed 自动回写。
   async captureEnvPatch(page, source = {}, options = {}) {
-    const state = normalizeRuntimeState(source, options?.actor || "");
-    const baseline = RuntimeEnv.buildEnvPatch(state) || {};
+    const state2 = normalizeRuntimeState(source, options?.actor || "");
+    const baseline = RuntimeEnv.buildEnvPatch(state2) || {};
     if (!page || typeof page.evaluate !== "function" || typeof page.context !== "function") {
       return Object.keys(baseline).length > 0 ? baseline : null;
     }
@@ -2085,7 +2085,7 @@ var RuntimeEnv = {
           cookies
         },
         {
-          browserProfileCore: state.browserProfileCore
+          browserProfileCore: state2.browserProfileCore
         }
       );
       return RuntimeEnv.mergeEnvPatches(baseline, capturedPatch);
@@ -2099,11 +2099,11 @@ var RuntimeEnv = {
 var logger3 = createInternalLogger("ApifyKit");
 var resolveRuntimeContext = (input) => {
   const rememberedState = RuntimeEnv.peekRememberedState();
-  const state = rememberedState || RuntimeEnv.parseInput(input || {});
-  const envPatch = RuntimeEnv.buildEnvPatch(state) || null;
+  const state2 = rememberedState || RuntimeEnv.parseInput(input || {});
+  const envPatch = RuntimeEnv.buildEnvPatch(state2) || null;
   return {
-    actor: state.actor,
-    runtime: state.runtime,
+    actor: state2.actor,
+    runtime: state2.runtime,
     envPatch
   };
 };
@@ -2462,6 +2462,57 @@ var Utils = {
   }
 };
 
+// src/internals/context.js
+var state = {
+  mode: Mode.Default
+};
+var normalizeStrategies = (strategies) => strategies && typeof strategies === "object" ? strategies : {};
+var ToolkitContext = {
+  get mode() {
+    return state.mode;
+  },
+  setMode(mode = Mode.Default) {
+    state.mode = normalizeMode(mode, Mode.Default);
+    return state.mode;
+  }
+};
+var getToolkitMode = () => state.mode;
+var setToolkitMode = (mode = Mode.Default) => ToolkitContext.setMode(mode);
+var resolveModeStrategy = (strategies = {}, mode = getToolkitMode(), fallbackMode = Mode.Default) => {
+  const normalizedStrategies = normalizeStrategies(strategies);
+  const normalizedMode = normalizeMode(mode, fallbackMode);
+  const delegate = normalizedStrategies[normalizedMode] ?? normalizedStrategies[fallbackMode] ?? Object.values(normalizedStrategies).find(Boolean) ?? null;
+  return {
+    mode: normalizedMode,
+    delegate
+  };
+};
+
+// src/internals/delegate.js
+var normalizeMethodDefinition = (definition) => typeof definition === "string" ? { name: definition, enumerable: true } : {
+  name: String(definition?.name || "").trim(),
+  enumerable: definition?.enumerable !== false
+};
+var createMethodDescriptor = (namespace, methodName, enumerable, strategies) => ({
+  enumerable,
+  value: (...args) => {
+    const { mode, delegate } = resolveModeStrategy(strategies);
+    if (typeof delegate?.[methodName] !== "function") {
+      throw new Error(`${namespace}.${methodName} is not available in ${mode} mode`);
+    }
+    return delegate[methodName](...args);
+  }
+});
+var createDelegatedFacade = (namespace, strategies = {}, methods = []) => {
+  const descriptors = Object.fromEntries(
+    methods.map(normalizeMethodDefinition).filter((method) => method.name).map((method) => [
+      method.name,
+      createMethodDescriptor(namespace, method.name, method.enumerable, strategies)
+    ])
+  );
+  return Object.defineProperties({}, descriptors);
+};
+
 // src/internals/anti-cheat/default.js
 var BASE_CONFIG = Object.freeze({
   locale: "zh-CN",
@@ -2535,43 +2586,52 @@ var DefaultAntiCheat = {
 };
 
 // src/internals/anti-cheat/cloakbrowser.js
-var CloakBrowserAntiCheat = DefaultAntiCheat;
-
-// src/internals/toolkit-mode.js
-var currentMode = Mode.Default;
-var getToolkitMode = () => currentMode;
-var setToolkitMode = (mode = Mode.Default) => {
-  currentMode = normalizeMode(mode, Mode.Default);
-  return currentMode;
-};
-
-// src/anti-cheat.js
-var resolveAntiCheatDelegate = () => getToolkitMode() === Mode.CloakBrowser ? CloakBrowserAntiCheat : DefaultAntiCheat;
-var callAntiCheat = (method, ...args) => {
-  const delegate = resolveAntiCheatDelegate();
-  if (typeof delegate?.[method] !== "function") {
-    throw new Error(`AntiCheat.${method} is not available in ${getToolkitMode()} mode`);
-  }
-  return delegate[method](...args);
-};
-var AntiCheat = {
+var CLOAK_BROWSER_BASE_CONFIG = Object.freeze({
+  locale: "",
+  acceptLanguage: "",
+  timezoneId: "",
+  timezoneOffset: null,
+  geolocation: null
+});
+var normalizeHeaders = (headers) => headers && typeof headers === "object" ? headers : {};
+var CloakBrowserAntiCheat = {
+  /**
+   * CloakBrowser 自身会负责浏览器指纹，toolkit 在该模式下尽量不再注入额外反检测配置。
+   */
   getBaseConfig() {
-    return callAntiCheat("getBaseConfig");
+    return { ...CLOAK_BROWSER_BASE_CONFIG };
   },
-  getFingerprintGeneratorOptions(options = {}) {
-    return callAntiCheat("getFingerprintGeneratorOptions", options);
+  getFingerprintGeneratorOptions() {
+    return {};
   },
-  getLaunchArgs(options = {}) {
-    return callAntiCheat("getLaunchArgs", options);
+  getLaunchArgs() {
+    return [];
   },
-  getTlsFingerprintOptions(userAgent = "", acceptLanguage = "", options = {}) {
-    return callAntiCheat("getTlsFingerprintOptions", userAgent, acceptLanguage, options);
+  getTlsFingerprintOptions() {
+    return {};
   },
   applyLocaleHeaders(headers, acceptLanguage = "") {
-    return callAntiCheat("applyLocaleHeaders", headers, acceptLanguage);
+    const normalizedHeaders = normalizeHeaders(headers);
+    if (acceptLanguage && !normalizedHeaders["accept-language"]) {
+      normalizedHeaders["accept-language"] = acceptLanguage;
+    }
+    return normalizedHeaders;
   }
 };
 
+// src/anti-cheat.js
+var antiCheatStrategies = {
+  [Mode.Default]: DefaultAntiCheat,
+  [Mode.CloakBrowser]: CloakBrowserAntiCheat
+};
+var AntiCheat = createDelegatedFacade("AntiCheat", antiCheatStrategies, [
+  "getBaseConfig",
+  "getFingerprintGeneratorOptions",
+  "getLaunchArgs",
+  "getTlsFingerprintOptions",
+  "applyLocaleHeaders"
+]);
+
 // src/device-input.js
 var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
 var assertPage = (page, method) => {
@@ -2971,12 +3031,12 @@ var resolveDescriptor = (descriptor, device) => {
   }
   return resolved;
 };
-var attachRuntimeState = (page, state) => {
+var attachRuntimeState = (page, state2) => {
   Object.defineProperty(page, PageRuntimeStateKey, {
     configurable: true,
     enumerable: false,
     writable: true,
-    value: state
+    value: state2
   });
 };
 var restoreRuntimeState = (page, snapshot) => {
@@ -4030,7 +4090,7 @@ var restoreWindowFromSnapshot = async (page, before, after) => {
     return;
   }
   await page.evaluate(
-    (state) => window.scrollTo(state.x, state.y),
+    (state2) => window.scrollTo(state2.x, state2.y),
     { x: Number(before.scrollX || 0), y: Number(before.scrollY || 0) }
   ).catch(() => {
   });
@@ -4276,7 +4336,7 @@ var MobileHumanize = {
       if (scrollRect && beforeWindowState) {
         const afterWindowState = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY }));
         if (Math.abs(afterWindowState.x - beforeWindowState.x) > 2 || Math.abs(afterWindowState.y - beforeWindowState.y) > 2) {
-          await page.evaluate((state) => window.scrollTo(state.x, state.y), beforeWindowState);
+          await page.evaluate((state2) => window.scrollTo(state2.x, state2.y), beforeWindowState);
           logger6.debug(`humanScroll | \u7A97\u53E3\u6EDA\u52A8\u56DE\u6536 from=${Math.round(afterWindowState.y)} to=${Math.round(beforeWindowState.y)}`);
         }
       }
@@ -4643,475 +4703,272 @@ var DefaultHumanize = {
 
 // src/internals/humanize/cloakbrowser.js
 import delay4 from "delay";
-var logger7 = createInternalLogger("Humanize.CloakBrowser");
-var humanizedPages = /* @__PURE__ */ new WeakSet();
-var cachedCloakHumanModulePromise = null;
-var isPageLike2 = (value) => value && typeof value === "object" && typeof value.evaluate === "function";
-var isPoint2 = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
 var resolveDeviceFromPage3 = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
 var isMobilePage = (page) => resolveDeviceFromPage3(page) === Device.Mobile;
-var loadCloakHumanModule = async () => {
-  if (!cachedCloakHumanModulePromise) {
-    cachedCloakHumanModulePromise = import("cloakbrowser/human").catch((error) => {
-      cachedCloakHumanModulePromise = null;
-      throw new Error("cloakbrowser/human \u6A21\u5757\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u5DF2\u5B89\u88C5 cloakbrowser\u3002", {
-        cause: error
-      });
-    });
-  }
-  return cachedCloakHumanModulePromise;
+var isPageLike2 = (value) => value && typeof value === "object" && typeof value.evaluate === "function";
+var isPoint2 = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
+var resolveNativeTarget2 = (page, target) => typeof target === "string" ? page.locator(target).first() : target;
+var getViewportCenter = (page) => {
+  const viewport = page?.viewportSize?.() || { width: 1365, height: 900 };
+  return {
+    x: Math.round(viewport.width / 2),
+    y: Math.round(viewport.height / 2)
+  };
 };
-var buildTypingHumanConfig = (options = {}) => {
-  const humanConfig = {};
-  if (Number.isFinite(Number(options.baseDelay))) {
-    humanConfig.typing_delay = Number(options.baseDelay);
-  }
-  if (Number.isFinite(Number(options.pauseProbability))) {
-    humanConfig.typing_pause_chance = Number(options.pauseProbability);
+var readViewportScroll = async (page) => await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => ({ x: 0, y: 0 }));
+var getTargetBox = async (target) => {
+  if (!target || typeof target.boundingBox !== "function") {
+    return null;
   }
-  if (Number.isFinite(Number(options.pauseBase))) {
-    const basePause = Math.max(40, Number(options.pauseBase));
-    humanConfig.typing_pause_range = [
-      Math.round(basePause * 0.5),
-      Math.round(basePause * 1.5)
-    ];
+  return await target.boundingBox().catch(() => null);
+};
+var clickOptionsFrom = (options = {}) => {
+  const nextOptions = {
+    force: true
+  };
+  if (options.timeout != null) {
+    nextOptions.timeout = options.timeout;
   }
-  return Object.keys(humanConfig).length > 0 ? humanConfig : null;
+  return nextOptions;
 };
-var buildActionOptions = (options = {}) => {
-  const actionOptions = {};
-  if (options && options.timeout != null) {
-    actionOptions.timeout = options.timeout;
+var typeOptionsFrom = (options = {}) => {
+  const nextOptions = {};
+  if (options.timeout != null) {
+    nextOptions.timeout = options.timeout;
   }
-  actionOptions.force = true;
-  const humanConfig = buildTypingHumanConfig(options);
-  if (humanConfig) {
-    actionOptions.human_config = humanConfig;
+  if (options.baseDelay != null) {
+    nextOptions.delay = Math.max(0, Number(options.baseDelay) || 0);
   }
-  return actionOptions;
-};
-var ensureDesktopHumanized = async (page) => {
-  if (!page || typeof page !== "object") {
-    throw new Error("Humanize requires a Playwright page");
-  }
-  const humanModule = await loadCloakHumanModule();
-  if (page._original && page._humanCursor) {
-    humanizedPages.add(page);
-    return humanModule;
-  }
-  if (humanizedPages.has(page)) {
-    return humanModule;
-  }
-  const config = page._humanCfg || humanModule.resolveConfig?.("default") || humanModule.resolveConfig?.();
-  const cursor = page._humanCursor || { x: 0, y: 0, initialized: false };
-  humanModule.patchPage(page, config, cursor);
-  humanizedPages.add(page);
-  return humanModule;
-};
-var patchHandle = async (page, handle) => {
-  if (!handle || typeof handle !== "object") return handle;
-  const humanModule = await ensureDesktopHumanized(page);
-  humanModule.patchSingleElementHandle(
-    handle,
-    page,
-    page._humanCfg,
-    page._humanCursor,
-    page._humanRaw,
-    page._humanRawKb,
-    page._humanOriginals,
-    page._stealth
-  );
-  return handle;
+  return nextOptions;
 };
-var resolvePatchedTarget = async (page, target, { throwOnMissing = true } = {}) => {
-  if (target == null) {
-    return { target: null, dispose: null };
+var pressOptionsFrom = (options = {}) => {
+  const nextOptions = {};
+  if (options.timeout != null) {
+    nextOptions.timeout = options.timeout;
   }
-  if (typeof target === "string") {
-    const handle = await page.$(target);
-    if (!handle) {
-      if (throwOnMissing) {
-        throw new Error(`\u627E\u4E0D\u5230\u5143\u7D20 ${String(target)}`);
-      }
-      return { target: null, dispose: null };
-    }
-    return { target: handle, dispose: null };
+  if (options.holdDelay != null) {
+    nextOptions.delay = Math.max(0, Number(options.holdDelay) || 0);
   }
-  if (typeof target.elementHandle === "function") {
-    const handle = await target.elementHandle();
-    if (!handle) {
-      if (throwOnMissing) {
-        throw new Error("\u627E\u4E0D\u5230 locator \u5BF9\u5E94\u7684\u5143\u7D20");
-      }
-      return { target: null, dispose: null };
-    }
-    await patchHandle(page, handle);
-    return {
-      target: handle,
-      dispose: async () => {
-        await handle.dispose().catch(() => {
-        });
-      }
-    };
-  }
-  await patchHandle(page, target);
-  return { target, dispose: null };
+  return nextOptions;
 };
-var jitterSleep = async (baseMs, jitterPercent = 0.3) => {
+var waitDesktopJitter = async (baseMs, jitterPercent = 0.3) => {
   await delay4(jitterMs(baseMs, jitterPercent));
 };
-var humanMoveToPoint = async (page, point) => {
-  await ensureDesktopHumanized(page);
-  await page.mouse.move(Number(point.x), Number(point.y));
-  return true;
-};
-var doDesktopHumanClick = async (page, target, options = {}) => {
-  await ensureDesktopHumanized(page);
-  if (target == null) {
-    const cursor = page._humanCursor || { x: 0, y: 0 };
-    await page.mouse.click(cursor.x || 0, cursor.y || 0);
-    return true;
-  }
-  if (isPoint2(target)) {
-    return humanMoveToPoint(page, target).then(async () => {
-      await page.mouse.click(Number(target.x), Number(target.y));
-      return true;
-    });
-  }
-  const throwOnMissing = options.throwOnMissing !== false;
-  if (typeof target === "string") {
-    if (!throwOnMissing) {
-      const existingHandle = await page.$(target);
-      if (!existingHandle) {
-        return false;
-      }
-      await existingHandle.click(buildActionOptions(options));
-      return true;
-    }
-    await page.click(target, buildActionOptions(options));
-    return true;
-  }
-  const { target: resolvedTarget, dispose } = await resolvePatchedTarget(page, target, { throwOnMissing });
-  try {
-    if (!resolvedTarget) {
+var DesktopCloakHumanize = {
+  jitterMs(base, jitterPercent = 0.3) {
+    return jitterMs(base, jitterPercent);
+  },
+  async initializeCursor(page) {
+    return Boolean(page);
+  },
+  async humanMove(page, target) {
+    if (target == null) {
       return false;
     }
-    if (typeof resolvedTarget.click === "function") {
-      await resolvedTarget.click(buildActionOptions(options));
+    if (isPoint2(target)) {
+      await page.mouse.move(Number(target.x), Number(target.y));
       return true;
     }
-    const box = await resolvedTarget.boundingBox?.();
+    const resolvedTarget = resolveNativeTarget2(page, target);
+    if (typeof resolvedTarget?.hover === "function") {
+      await resolvedTarget.hover(clickOptionsFrom());
+      return true;
+    }
+    const box = await getTargetBox(resolvedTarget);
     if (!box) {
-      if (throwOnMissing) {
-        throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
-      }
       return false;
     }
-    await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+    await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
     return true;
-  } finally {
-    if (typeof dispose === "function") {
-      await dispose();
-    }
-  }
-};
-var CloakBrowserHumanize = {
-  jitterMs(base, jitterPercent = 0.3) {
-    return jitterMs(base, jitterPercent);
   },
-  async initializeCursor(page) {
-    if (isMobilePage(page)) {
-      return MobileHumanize.initializeCursor(page);
+  async humanScroll(page, target) {
+    const resolvedTarget = resolveNativeTarget2(page, target);
+    if (!resolvedTarget) {
+      return { element: null, didScroll: false, restore: null };
     }
-    await ensureDesktopHumanized(page);
-    logger7.debug("initializeCursor: cloakbrowser human layer ready");
+    const before = await readViewportScroll(page);
+    await resolvedTarget.scrollIntoViewIfNeeded?.();
+    const after = await readViewportScroll(page);
+    return {
+      element: resolvedTarget,
+      didScroll: before.x !== after.x || before.y !== after.y,
+      restore: null
+    };
   },
-  async humanMove(page, target) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanMove(page, target);
+  async humanClick(page, target, options = {}) {
+    if (target == null) {
+      const center = getViewportCenter(page);
+      await page.mouse.click(center.x, center.y);
+      return true;
     }
-    await ensureDesktopHumanized(page);
     if (isPoint2(target)) {
-      return await humanMoveToPoint(page, target);
-    }
-    const { target: resolvedTarget, dispose } = await resolvePatchedTarget(page, target, { throwOnMissing: false });
-    try {
-      if (!resolvedTarget) {
-        return false;
-      }
-      if (typeof resolvedTarget.hover === "function") {
-        await resolvedTarget.hover({ force: true });
-        return true;
-      }
-      const box = await resolvedTarget.boundingBox?.();
-      if (!box) {
-        return false;
-      }
-      await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+      await page.mouse.click(Number(target.x), Number(target.y));
       return true;
-    } finally {
-      if (typeof dispose === "function") {
-        await dispose();
-      }
     }
-  },
-  async humanScroll(page, target, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanScroll(page, target, options);
-    }
-    const humanModule = await ensureDesktopHumanized(page);
     if (typeof target === "string") {
-      const { x = 0, y = 0 } = page._humanCursor || {};
-      try {
-        const result = await humanModule.scrollToElement(
-          page,
-          page._humanRaw,
-          target,
-          x,
-          y,
-          page._humanCfg,
-          options.timeout
-        );
-        if (page._humanCursor) {
-          page._humanCursor.x = result.cursorX;
-          page._humanCursor.y = result.cursorY;
-        }
-        return {
-          element: await page.$(target),
-          didScroll: Boolean(result.didScroll),
-          restore: null
-        };
-      } catch (error) {
-        logger7.warn(`humanScroll: cloakbrowser \u6EDA\u52A8\u5931\u8D25\uFF0C\u8DF3\u8FC7 (${error?.message || error})`);
-        return { element: null, didScroll: false, restore: null };
-      }
+      await page.click(target, clickOptionsFrom(options));
+      return true;
     }
-    const { target: resolvedTarget, dispose } = await resolvePatchedTarget(page, target, { throwOnMissing: false });
-    try {
-      if (!resolvedTarget) {
-        return { element: null, didScroll: false, restore: null };
-      }
-      const before = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY }));
-      await resolvedTarget.scrollIntoViewIfNeeded?.();
-      const after = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY }));
-      return {
-        element: resolvedTarget,
-        didScroll: before.x !== after.x || before.y !== after.y,
-        restore: null
-      };
-    } finally {
-      if (typeof dispose === "function") {
-        await dispose();
-      }
+    if (typeof target?.click === "function") {
+      await target.click(clickOptionsFrom(options));
+      return true;
     }
-  },
-  async humanClick(page, target, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanClick(page, target, options);
+    const box = await getTargetBox(target);
+    if (!box) {
+      return false;
     }
-    return await doDesktopHumanClick(page, target, options);
+    await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+    return true;
   },
-  async randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
-    if (isPageLike2(pageOrBaseMs)) {
-      if (isMobilePage(pageOrBaseMs)) {
-        return await MobileHumanize.randomSleep(maybeBaseMs, maybeJitterPercent);
-      }
-      await jitterSleep(maybeBaseMs, maybeJitterPercent ?? 0.3);
-      return;
-    }
-    await jitterSleep(pageOrBaseMs, maybeBaseMs ?? 0.3);
+  async randomSleep(baseMs, jitterPercent = 0.3) {
+    await waitDesktopJitter(baseMs, jitterPercent);
   },
   async simulateGaze(page, baseDurationMs = 2500) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.simulateGaze(page, baseDurationMs);
-    }
-    await ensureDesktopHumanized(page);
     const durationMs = jitterMs(baseDurationMs, 0.4);
-    const startTime = Date.now();
-    const viewportSize = page.viewportSize() || { width: 1365, height: 900 };
-    while (Date.now() - startTime < durationMs) {
+    const startedAt = Date.now();
+    const viewport = page.viewportSize() || { width: 1365, height: 900 };
+    while (Date.now() - startedAt < durationMs) {
       await page.mouse.move(
-        100 + Math.random() * Math.max(120, viewportSize.width - 200),
-        100 + Math.random() * Math.max(120, viewportSize.height - 200)
+        100 + Math.random() * Math.max(120, viewport.width - 200),
+        100 + Math.random() * Math.max(120, viewport.height - 200)
       );
-      await jitterSleep(600, 0.5);
+      await waitDesktopJitter(600, 0.5);
     }
   },
   async humanType(page, selector, text, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanType(page, selector, text, options);
-    }
-    await ensureDesktopHumanized(page);
-    const actionOptions = buildActionOptions(options);
     if (typeof selector === "string") {
-      await page.type(selector, text, actionOptions);
+      await page.type(selector, text, typeOptionsFrom(options));
       return;
     }
-    const { target: resolvedTarget, dispose } = await resolvePatchedTarget(page, selector, { throwOnMissing: true });
-    try {
-      if (!resolvedTarget || typeof resolvedTarget.type !== "function") {
-        throw new Error("\u76EE\u6807\u5143\u7D20\u4E0D\u652F\u6301 type()");
-      }
-      await resolvedTarget.type(text, actionOptions);
-    } finally {
-      if (typeof dispose === "function") {
-        await dispose();
-      }
-    }
+    await selector.type(text, typeOptionsFrom(options));
   },
   async humanPress(page, targetOrKey, maybeKey, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanPress(page, targetOrKey, maybeKey, options);
-    }
-    await ensureDesktopHumanized(page);
     const hasTarget = typeof maybeKey === "string";
     const key = hasTarget ? maybeKey : targetOrKey;
     const pressOptions = hasTarget ? options : maybeKey || options;
     if (!hasTarget) {
-      await jitterSleep(pressOptions.reactionDelay ?? 180, 0.45);
-      await page.keyboard.press(key, {
-        ...pressOptions.keyboardOptions || {},
-        delay: jitterMs(pressOptions.holdDelay ?? 45, 0.5)
-      });
+      await page.keyboard.press(key, pressOptionsFrom(pressOptions));
       return true;
     }
     if (typeof targetOrKey === "string") {
-      await page.press(targetOrKey, key, buildActionOptions(pressOptions));
+      await page.press(targetOrKey, key, pressOptionsFrom(pressOptions));
       return true;
     }
-    const { target: resolvedTarget, dispose } = await resolvePatchedTarget(page, targetOrKey, {
-      throwOnMissing: pressOptions.throwOnMissing !== false
-    });
-    try {
-      if (!resolvedTarget) {
-        return false;
-      }
-      if (typeof resolvedTarget.press === "function") {
-        await resolvedTarget.press(key, buildActionOptions(pressOptions));
-        return true;
-      }
-      await doDesktopHumanClick(page, targetOrKey, {
-        ...pressOptions,
-        reactionDelay: pressOptions.focusDelay ?? 180
-      });
-      await jitterSleep(pressOptions.reactionDelay ?? 180, 0.45);
-      await page.keyboard.press(key, {
-        ...pressOptions.keyboardOptions || {},
-        delay: jitterMs(pressOptions.holdDelay ?? 45, 0.5)
-      });
+    if (typeof targetOrKey?.press === "function") {
+      await targetOrKey.press(key, pressOptionsFrom(pressOptions));
       return true;
-    } finally {
-      if (typeof dispose === "function") {
-        await dispose();
-      }
     }
+    await page.keyboard.press(key, pressOptionsFrom(pressOptions));
+    return true;
   },
   async humanClear(page, selector) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanClear(page, selector);
+    if (typeof selector === "string") {
+      if (typeof page.clear === "function") {
+        await page.clear(selector, clickOptionsFrom());
+        return;
+      }
+      await page.fill(selector, "", clickOptionsFrom());
+      return;
     }
-    await ensureDesktopHumanized(page);
-    if (typeof page.clear === "function") {
-      await page.clear(selector, { force: true });
+    if (typeof selector?.clear === "function") {
+      await selector.clear(clickOptionsFrom());
+      return;
+    }
+    if (typeof selector?.fill === "function") {
+      await selector.fill("", clickOptionsFrom());
       return;
     }
-    await page.fill(selector, "", { force: true });
   },
   async warmUpBrowsing(page, baseDuration = 3500) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.warmUpBrowsing(page, baseDuration);
-    }
-    await ensureDesktopHumanized(page);
     const durationMs = jitterMs(baseDuration, 0.4);
-    const startTime = Date.now();
-    const viewportSize = page.viewportSize() || { width: 1365, height: 900 };
-    while (Date.now() - startTime < durationMs) {
-      const action = Math.random();
-      if (action < 0.4) {
-        await page.mouse.move(
-          100 + Math.random() * Math.max(120, viewportSize.width - 200),
-          100 + Math.random() * Math.max(120, viewportSize.height - 200)
-        );
-        await jitterSleep(350, 0.4);
-        continue;
-      }
-      if (action < 0.7) {
-        await page.mouse.wheel(0, (Math.random() - 0.5) * 220);
-        await jitterSleep(500, 0.4);
-        continue;
-      }
-      await jitterSleep(800, 0.5);
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < durationMs) {
+      await this.simulateGaze(page, 240);
+      await this.naturalScroll(page, Math.random() > 0.4 ? "down" : "up", 160, 3);
+      await waitDesktopJitter(250, 0.35);
     }
   },
   async naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.naturalScroll(page, direction, distance, baseSteps);
-    }
-    await ensureDesktopHumanized(page);
-    const steps = Math.max(3, baseSteps + Math.floor(Math.random() * 3) - 1);
-    const actualDistance = jitterMs(distance, 0.15);
+    const steps = Math.max(1, Number(baseSteps) || 1);
+    const stepDistance = (Number(distance) || 0) / steps;
     const sign = direction === "down" ? 1 : -1;
-    const stepDistance = actualDistance / steps;
     for (let index = 0; index < steps; index += 1) {
-      const factor = 1 - index / steps * 0.5;
-      const jitter = 0.9 + Math.random() * 0.2;
-      await page.mouse.wheel(0, stepDistance * factor * sign * jitter);
-      await jitterSleep(60 + index * 25, 0.3);
+      await page.mouse.wheel(0, stepDistance * sign);
+      await waitDesktopJitter(60 + index * 20, 0.3);
     }
   }
 };
-
-// src/humanize.js
-var resolveHumanizeDelegate = () => getToolkitMode() === Mode.CloakBrowser ? CloakBrowserHumanize : DefaultHumanize;
-var callHumanize = (method, ...args) => {
-  const delegate = resolveHumanizeDelegate();
-  if (typeof delegate?.[method] !== "function") {
-    throw new Error(`Humanize.${method} is not available in ${getToolkitMode()} mode`);
-  }
-  return delegate[method](...args);
+var resolveDelegate2 = (page) => isMobilePage(page) ? MobileHumanize : DesktopCloakHumanize;
+var callDelegate2 = (method, page, args) => {
+  const delegate = resolveDelegate2(page);
+  return delegate[method](page, ...args);
 };
-var Humanize2 = {
+var CloakBrowserHumanize = {
   jitterMs(base, jitterPercent = 0.3) {
-    return callHumanize("jitterMs", base, jitterPercent);
+    return jitterMs(base, jitterPercent);
   },
   initializeCursor(page) {
-    return callHumanize("initializeCursor", page);
+    return callDelegate2("initializeCursor", page, []);
   },
   humanMove(page, target) {
-    return callHumanize("humanMove", page, target);
+    return callDelegate2("humanMove", page, [target]);
   },
   humanScroll(page, target, options = {}) {
-    return callHumanize("humanScroll", page, target, options);
+    return callDelegate2("humanScroll", page, [target, options]);
   },
   humanClick(page, target, options = {}) {
-    return callHumanize("humanClick", page, target, options);
+    return callDelegate2("humanClick", page, [target, options]);
   },
   randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
-    return callHumanize("randomSleep", pageOrBaseMs, maybeBaseMs, maybeJitterPercent);
+    if (isPageLike2(pageOrBaseMs)) {
+      const delegate = resolveDelegate2(pageOrBaseMs);
+      return delegate.randomSleep(maybeBaseMs, maybeJitterPercent);
+    }
+    return DesktopCloakHumanize.randomSleep(pageOrBaseMs, maybeBaseMs);
   },
   simulateGaze(page, baseDurationMs = 2500) {
-    return callHumanize("simulateGaze", page, baseDurationMs);
+    return callDelegate2("simulateGaze", page, [baseDurationMs]);
   },
   humanType(page, selector, text, options = {}) {
-    return callHumanize("humanType", page, selector, text, options);
+    return callDelegate2("humanType", page, [selector, text, options]);
   },
   humanPress(page, targetOrKey, maybeKey, options = {}) {
     if (typeof maybeKey === "string") {
-      return callHumanize("humanPress", page, targetOrKey, maybeKey, options);
+      return callDelegate2("humanPress", page, [targetOrKey, maybeKey, options]);
     }
-    return callHumanize("humanPress", page, targetOrKey, maybeKey || options);
+    return callDelegate2("humanPress", page, [targetOrKey, maybeKey || options]);
   },
   humanClear(page, selector) {
-    return callHumanize("humanClear", page, selector);
+    return callDelegate2("humanClear", page, [selector]);
   },
   warmUpBrowsing(page, baseDuration = 3500) {
-    return callHumanize("warmUpBrowsing", page, baseDuration);
+    return callDelegate2("warmUpBrowsing", page, [baseDuration]);
   },
   naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
-    return callHumanize("naturalScroll", page, direction, distance, baseSteps);
+    return callDelegate2("naturalScroll", page, [direction, distance, baseSteps]);
   }
 };
 
+// src/humanize.js
+var humanizeStrategies = {
+  [Mode.Default]: DefaultHumanize,
+  [Mode.CloakBrowser]: CloakBrowserHumanize
+};
+var Humanize2 = createDelegatedFacade("Humanize", humanizeStrategies, [
+  "jitterMs",
+  "initializeCursor",
+  "humanMove",
+  "humanScroll",
+  "humanClick",
+  "randomSleep",
+  "simulateGaze",
+  "humanType",
+  "humanPress",
+  "humanClear",
+  "warmUpBrowsing",
+  "naturalScroll"
+]);
+
 // src/internals/launch/default.js
 import { execFileSync } from "node:child_process";
 import { FingerprintGenerator } from "fingerprint-generator";
@@ -5198,7 +5055,7 @@ var ByPass = {
 };
 
 // src/internals/launch/default.js
-var logger8 = createInternalLogger("Launch");
+var logger7 = createInternalLogger("Launch");
 var REQUEST_HOOK_FLAG = Symbol("playwright-toolkit-request-hook");
 var injectedContexts = /* @__PURE__ */ new WeakSet();
 var browserMajorVersionCache = /* @__PURE__ */ new Map();
@@ -5250,7 +5107,7 @@ var detectBrowserMajorVersion = (launcher) => {
     });
     detectedVersion = parseChromeMajorVersion(rawVersion);
   } catch (error) {
-    logger8.warn(`\u8BFB\u53D6\u6D4F\u89C8\u5668\u7248\u672C\u5931\u8D25: ${error?.message || error}`);
+    logger7.warn(`\u8BFB\u53D6\u6D4F\u89C8\u5668\u7248\u672C\u5931\u8D25: ${error?.message || error}`);
   }
   browserMajorVersionCache.set(executablePath, detectedVersion);
   return detectedVersion;
@@ -5287,7 +5144,7 @@ var generateFingerprintForCore = ({ locale, browserMajorVersion, device }) => {
     if (requestedBrowserMajorVersion <= 0) {
       throw error;
     }
-    logger8.warn(
+    logger7.warn(
       `\u5F53\u524D\u6D4F\u89C8\u5668\u5927\u7248\u672C ${requestedBrowserMajorVersion} \u65E0\u53EF\u7528 strict \u6307\u7EB9\u6837\u672C\uFF0C\u9000\u56DE\u4E0D\u7ED1\u5B9A\u5927\u7248\u672C\u751F\u6210: ${error?.message || error}`
     );
   }
@@ -5332,7 +5189,7 @@ var buildReplayableBrowserProfile = (runtimeState, launcher) => {
       schema_version: DEFAULT_BROWSER_PROFILE_SCHEMA_VERSION
     };
     nextState = RuntimeEnv.setBrowserProfileCore(nextState, browserProfileCore);
-    logger8.info(
+    logger7.info(
       `\u5DF2\u751F\u6210\u6D4F\u89C8\u5668\u6307\u7EB9\u771F\u6E90 | env=${String(nextState.envId || "-")} | device=${device} | version=${browserProfileCore.browser_major_version || "-"} | fingerprintVersion=${fingerprintBrowserMajorVersion || "-"} | exactVersion=${generated.exactBrowserMajorVersion ? "true" : "false"} | timezone=${timezoneId}`
     );
     return { runtimeState: nextState, browserProfileCore };
@@ -5461,18 +5318,18 @@ var DefaultLaunch = {
         upstreamLabel = `${parsedProxyUrl.protocol}//${parsedProxyUrl.host}`;
       } catch {
       }
-      logger8.info(
+      logger7.info(
         `[\u4EE3\u7406\u5DF2\u542F\u7528] \u672C\u5730=${launchProxy.server} \u4E0A\u6E38=${upstreamLabel || "-"} \u76F4\u8FDE\u57DF\u540D=${(byPassDomains || []).join(",")}`
       );
-      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     } else if (enableByPassLogger && enableProxy && !launchProxy) {
-      logger8.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=true \u4F46 proxy_url \u4E3A\u7A7A");
-      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger7.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=true \u4F46 proxy_url \u4E3A\u7A7A");
+      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     } else if (enableByPassLogger && !enableProxy && proxyUrl) {
-      logger8.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=false \u4E14 proxy_url \u5DF2\u914D\u7F6E");
-      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger7.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=false \u4E14 proxy_url \u5DF2\u914D\u7F6E");
+      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     } else if (enableByPassLogger) {
-      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     }
     const onPageCreated = (page) => {
       const recommendedGotoOptions = {
@@ -5494,7 +5351,7 @@ var DefaultLaunch = {
         }
         if (!enableByPassLogger || byPassDomains.length === 0) return;
         if (!matched || !matched.rule) return;
-        logger8.info(`[\u76F4\u8FDE\u547D\u4E2D] \u89C4\u5219=${matched.rule.pattern} \u57DF\u540D=${matched.hostname} \u8D44\u6E90\u7C7B\u578B=${resourceType} \u65B9\u6CD5=${req.method()} \u5730\u5740=${requestUrl}`);
+        logger7.info(`[\u76F4\u8FDE\u547D\u4E2D] \u89C4\u5219=${matched.rule.pattern} \u57DF\u540D=${matched.hostname} \u8D44\u6E90\u7C7B\u578B=${resourceType} \u65B9\u6CD5=${req.method()} \u5730\u5740=${requestUrl}`);
       };
       page.on("request", requestHandler);
       return recommendedGotoOptions;
@@ -5551,7 +5408,7 @@ var DefaultLaunch = {
 // src/internals/launch/cloakbrowser.js
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-var logger9 = createInternalLogger("CloakBrowser");
+var logger8 = createInternalLogger("CloakBrowser");
 var execFileAsync = promisify(execFile);
 var DEFAULT_CLOAK_CRAWLER_BASE_OPTIONS = Object.freeze({
   maxConcurrency: 1,
@@ -5687,7 +5544,7 @@ var forceTerminateBrowsersByFingerprintArg = async (fingerprintArg) => {
     if (error?.code === 1 || error?.code === "ENOENT") {
       return;
     }
-    logger9.info(`\u5F3A\u5236\u5173\u95ED CloakBrowser \u8FDB\u7A0B\u5931\u8D25\uFF08\u5FFD\u7565\uFF09: ${error?.message || String(error)}`);
+    logger8.info(`\u5F3A\u5236\u5173\u95ED CloakBrowser \u8FDB\u7A0B\u5931\u8D25\uFF08\u5FFD\u7565\uFF09: ${error?.message || String(error)}`);
   });
 };
 var CloakBrowserLaunch = {
@@ -5701,8 +5558,21 @@ var CloakBrowserLaunch = {
     return createStableGotoHook(recommendedGotoOptions);
   },
   async getPlaywrightCrawlerOptions(options = {}) {
-    const { crawlerOptions } = await CloakBrowserLaunch.createPlaywrightCrawlerRuntime(options);
-    return crawlerOptions;
+    const runtime2 = await CloakBrowserLaunch.createPlaywrightCrawlerRuntime(options);
+    return Object.defineProperties(runtime2.crawlerOptions, {
+      cleanup: {
+        enumerable: false,
+        value: runtime2.cleanup
+      },
+      closeActiveBrowsers: {
+        enumerable: false,
+        value: runtime2.closeActiveBrowsers
+      },
+      forceTerminateActiveProcesses: {
+        enumerable: false,
+        value: runtime2.forceTerminateActiveProcesses
+      }
+    });
   },
   async buildLaunchOptions(options = {}) {
     return await buildCloakLaunchOptions(options);
@@ -5783,39 +5653,18 @@ var CloakBrowserLaunch = {
 };
 
 // src/launch.js
-var resolveLaunchDelegate = () => getToolkitMode() === Mode.CloakBrowser ? CloakBrowserLaunch : DefaultLaunch;
-var callLaunch = (method, ...args) => {
-  const delegate = resolveLaunchDelegate();
-  if (typeof delegate?.[method] !== "function") {
-    throw new Error(`Launch.${method} is not available in ${getToolkitMode()} mode`);
-  }
-  return delegate[method](...args);
-};
-var Launch = {
-  getPlaywrightCrawlerOptions(options = {}) {
-    return callLaunch("getPlaywrightCrawlerOptions", options);
-  },
-  resolveProxyConfiguration(proxyConfiguration = {}) {
-    return callLaunch("resolveProxyConfiguration", proxyConfiguration);
-  },
-  extractFingerprintArg(launchOptions = {}) {
-    return callLaunch("extractFingerprintArg", launchOptions);
-  },
-  createStableGotoHook(recommendedGotoOptions = {}) {
-    return callLaunch("createStableGotoHook", recommendedGotoOptions);
-  },
-  buildLaunchOptions(options = {}) {
-    return callLaunch("buildLaunchOptions", options);
-  },
-  createPlaywrightCrawlerRuntime(options = {}) {
-    return callLaunch("createPlaywrightCrawlerRuntime", options);
-  }
+var launchStrategies = {
+  [Mode.Default]: DefaultLaunch,
+  [Mode.CloakBrowser]: CloakBrowserLaunch
 };
+var Launch = createDelegatedFacade("Launch", launchStrategies, [
+  "getPlaywrightCrawlerOptions"
+]);
 
 // src/live-view.js
 import express from "express";
 import { Actor } from "apify";
-var logger10 = createInternalLogger("LiveView");
+var logger9 = createInternalLogger("LiveView");
 async function startLiveViewServer(liveViewKey) {
   const app = express();
   app.get("/", async (req, res) => {
@@ -5840,13 +5689,13 @@ async function startLiveViewServer(liveViewKey) {
                 </html>
             `);
     } catch (error) {
-      logger10.fail("Live View Server", error);
+      logger9.fail("Live View Server", error);
       res.status(500).send(`\u65E0\u6CD5\u52A0\u8F7D\u5C4F\u5E55\u622A\u56FE: ${error.message}`);
     }
   });
   const port = process.env.APIFY_CONTAINER_PORT || 4321;
   app.listen(port, () => {
-    logger10.success("startLiveViewServer", `\u76D1\u542C\u7AEF\u53E3 ${port}`);
+    logger9.success("startLiveViewServer", `\u76D1\u542C\u7AEF\u53E3 ${port}`);
   });
 }
 async function takeLiveScreenshot(liveViewKey, page, logMessage) {
@@ -5854,10 +5703,10 @@ async function takeLiveScreenshot(liveViewKey, page, logMessage) {
     const buffer = await capturePageScreenshot(page, { type: "png" });
     await Actor.setValue(liveViewKey, buffer, { contentType: "image/png" });
     if (logMessage) {
-      logger10.info(`(\u622A\u56FE): ${logMessage}`);
+      logger9.info(`(\u622A\u56FE): ${logMessage}`);
     }
   } catch (e) {
-    logger10.warn(`\u65E0\u6CD5\u6355\u83B7 Live View \u5C4F\u5E55\u622A\u56FE: ${e.message}`);
+    logger9.warn(`\u65E0\u6CD5\u6355\u83B7 Live View \u5C4F\u5E55\u622A\u56FE: ${e.message}`);
   }
 }
 var useLiveView = (liveViewKey = PresetOfLiveViewKey) => {
@@ -5966,7 +5815,7 @@ var dragCaptchaAction = async (page, sourceLocator, targetLocator, options = {})
 };
 
 // src/internals/captcha/bytedance.js
-var logger11 = createInternalLogger("Captcha");
+var logger10 = createInternalLogger("Captcha");
 var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
   apiType: "31234",
   maxRetries: 3,
@@ -6098,7 +5947,7 @@ var collectCaptchaDebugInfo = async (page, frame, iframeLocator, attempt, phase,
     }
     await writeFile(infoPath, JSON.stringify(payload, null, 2), "utf8");
   }
-  logger11.info(`\u5DF2\u5199\u51FA\u9A8C\u8BC1\u7801\u8C03\u8BD5\u4EA7\u7269\uFF1A${debugDir}`);
+  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) {
@@ -6135,14 +5984,14 @@ var getVerifycenterCaptchaContext = async (page, options) => {
   if (!isContainerVisible) {
     return null;
   }
-  logger11.info("\u68C0\u6D4B\u5230\u9A8C\u8BC1\u7801\u5BB9\u5668\uFF0C\u5F00\u59CB\u7B49\u5F85 iframe \u52A0\u8F7D\u3002");
+  logger10.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) {
-    logger11.warn("\u672A\u5728\u9884\u671F\u9009\u62E9\u5668\u4E2D\u627E\u5230 verifycenter iframe\uFF0C\u5C1D\u8BD5\u5BB9\u5668\u5185\u4EFB\u610F iframe\u3002");
+    logger10.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,
@@ -6152,7 +6001,7 @@ var getVerifycenterCaptchaContext = async (page, options) => {
   if (!isIframeVisible) {
     throw new Error("verifycenter iframe not found inside captcha container.");
   }
-  logger11.info("\u9A8C\u8BC1\u7801 iframe \u5DF2\u53EF\u89C1\uFF0C\u5F00\u59CB\u89E3\u6790\u5185\u5BB9 frame\u3002");
+  logger10.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.");
@@ -6268,11 +6117,11 @@ var refreshCaptcha = async (page, frame, options) => {
   const clicked = await clickCaptchaAction(frame, options.refreshTexts, {
     ...options,
     page,
-    logger: logger11,
+    logger: logger10,
     forceMouse: true
   }).catch(() => false);
   if (!clicked) {
-    logger11.warn("Refresh button not found.");
+    logger10.warn("Refresh button not found.");
     return false;
   }
   await page.waitForTimeout(options.refreshWaitMs);
@@ -6303,24 +6152,24 @@ var waitForCaptchaChallengeReady = async (page, frame, options) => {
     const hasGuideMaskVisible = options.guideMaskSelector ? await frame.locator(options.guideMaskSelector).first().isVisible({ timeout: options.loadingIndicatorVisibleTimeoutMs }).catch(() => false) : false;
     hasSeenGuideMask = hasSeenGuideMask || hasGuideMaskVisible;
     if (hasGuideMaskVisible && !hasLoggedGuideMask) {
-      logger11.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");
+      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) {
-      logger11.info(
+      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) {
-      logger11.warn("\u9A8C\u8BC1\u7801\u9762\u677F\u51FA\u73B0\u7F51\u7EDC\u5F02\u5E38\u6587\u6848\uFF0C\u5C1D\u8BD5\u7ACB\u5373\u5237\u65B0\u9898\u76EE\u3002");
+      logger10.warn("\u9A8C\u8BC1\u7801\u9762\u677F\u51FA\u73B0\u7F51\u7EDC\u5F02\u5E38\u6587\u6848\uFF0C\u5C1D\u8BD5\u7ACB\u5373\u5237\u65B0\u9898\u76EE\u3002");
       await refreshCaptcha(page, frame, options);
       refreshDeadline = Date.now() + options.challengeReadyRefreshTimeoutMs;
       hasSeenLoading = false;
       continue;
     }
     if ((!hasVisibleSourceImage || !hasVisibleDropTarget) && Date.now() >= refreshDeadline) {
-      logger11.warn(`\u9A8C\u8BC1\u7801\u9898\u76EE\u8D85\u8FC7 ${options.challengeReadyRefreshTimeoutMs}ms \u4ECD\u672A\u51C6\u5907\u597D\uFF0C\u5C1D\u8BD5\u5237\u65B0\u9898\u76EE\u3002`);
+      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;
@@ -6368,7 +6217,7 @@ var dragPromptCaptchaImage = async (page, frame, iframeLocator, sourceLocator, d
       accepted
     };
     dragAttempts.push(attemptInfo);
-    logger11.info(
+    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) {
@@ -6386,7 +6235,7 @@ var dragPromptCaptchaImage = async (page, frame, iframeLocator, sourceLocator, d
     dragAttempts,
     finalState: await readPromptCaptchaState(frame, options)
   }).catch((error) => {
-    logger11.warn(`\u9A8C\u8BC1\u7801\u62D6\u62FD\u5931\u8D25\u8C03\u8BD5\u6293\u53D6\u5931\u8D25\uFF1A${error?.message || error}`);
+    logger10.warn(`\u9A8C\u8BC1\u7801\u62D6\u62FD\u5931\u8D25\u8C03\u8BD5\u6293\u53D6\u5931\u8D25\uFF1A${error?.message || error}`);
   });
   return {
     accepted: false,
@@ -6403,16 +6252,16 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
     ...options
   };
   if (!config.token) {
-    logger11.warn("\u7F3A\u5C11\u9A8C\u8BC1\u7801 token\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u8BC6\u522B\u3002");
+    logger10.warn("\u7F3A\u5C11\u9A8C\u8BC1\u7801 token\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u8BC6\u522B\u3002");
     return false;
   }
-  logger11.info("\u5F53\u524D\u4F7F\u7528\u672Ctool\u2014\u2014\u6D4B\u8BD5\u7248\u672C");
+  logger10.info("\u5F53\u524D\u4F7F\u7528\u672Ctool\u2014\u2014\u6D4B\u8BD5\u7248\u672C");
   for (let attempt = 1; attempt <= config.maxRetries; attempt += 1) {
-    logger11.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
+    logger10.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
     try {
       const captchaContext = await getVerifycenterCaptchaContext(page, config);
       if (!captchaContext) {
-        logger11.info("Captcha container is not visible anymore.");
+        logger10.info("Captcha container is not visible anymore.");
         return true;
       }
       const { iframeLocator, frame } = captchaContext;
@@ -6425,7 +6274,7 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
         "ready",
         config
       ).catch((error) => {
-        logger11.warn(`\u9A8C\u8BC1\u7801\u8C03\u8BD5\u6293\u53D6\u5931\u8D25\uFF1A${error?.message || 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();
@@ -6437,16 +6286,16 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
       });
       const serialNumbers = extractCaptchaSerialNumbers(apiResponse);
       if (apiResponse?.code !== config.recognitionSuccessCode || serialNumbers.length === 0) {
-        logger11.warn(
+        logger10.warn(
           `\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\u3002code=${apiResponse?.code}, msg=${apiResponse?.msg || "unknown"}`
         );
         await refreshCaptcha(page, frame, config);
         continue;
       }
-      logger11.info(`\u9A8C\u8BC1\u7801\u8BC6\u522B\u6210\u529F\uFF0C\u5E8F\u53F7\uFF1A${serialNumbers.join(", ")}`);
+      logger10.info(`\u9A8C\u8BC1\u7801\u8BC6\u522B\u6210\u529F\uFF0C\u5E8F\u53F7\uFF1A${serialNumbers.join(", ")}`);
       const dropTarget = await findCaptchaDropTarget(frame, config);
       if (!dropTarget) {
-        logger11.warn("\u672A\u627E\u5230\u9A8C\u8BC1\u7801\u62D6\u62FD\u76EE\u6807\u533A\u57DF\u3002");
+        logger10.warn("\u672A\u627E\u5230\u9A8C\u8BC1\u7801\u62D6\u62FD\u76EE\u6807\u533A\u57DF\u3002");
         await refreshCaptcha(page, frame, config);
         continue;
       }
@@ -6457,7 +6306,7 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
           `Captcha image indexes could not be normalized. raw=${serialNumbers.join(", ")}, count=${orderedSourceImages.length}`
         );
       }
-      logger11.info(`\u9A8C\u8BC1\u7801\u89C6\u89C9\u4F4D\u5E8F\u6620\u5C04\uFF1A${normalizedIndexes.map((index) => index + 1).join(", ")}`);
+      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(
@@ -6489,52 +6338,52 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
         }
       }
       const beforeSubmitState = await readPromptCaptchaState(frame, config);
-      logger11.info(
+      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: logger11,
+        logger: logger10,
         forceMouse: true,
         actionVisibleTimeoutMs: config.submitReadyTimeoutMs
       }).catch(() => false);
       if (!submitted) {
-        logger11.warn("\u672A\u627E\u5230\u63D0\u4EA4\u6309\u94AE\uFF0C\u53EF\u80FD\u4F1A\u81EA\u52A8\u63D0\u4EA4\u3002");
+        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);
-      logger11.info(
+      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) {
-        logger11.info("\u9A8C\u8BC1\u7801\u8BC6\u522B\u5E76\u63D0\u4EA4\u6210\u529F\u3002");
+        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) => {
-        logger11.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\u8C03\u8BD5\u6293\u53D6\u5931\u8D25\uFF1A${error?.message || error}`);
       });
-      logger11.warn("\u63D0\u4EA4\u540E\u9A8C\u8BC1\u7801 iframe \u4ECD\u7136\u53EF\u89C1\uFF0C\u51C6\u5907\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
+      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);
     } catch (error) {
-      logger11.error(`\u7B2C ${attempt}/${config.maxRetries} \u6B21\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\uFF1A${error?.message || error}`);
+      logger10.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);
     }
   }
-  logger11.error(`\u91CD\u8BD5 ${config.maxRetries} \u6B21\u540E\uFF0C\u9A8C\u8BC1\u7801\u4ECD\u672A\u8BC6\u522B\u6210\u529F\u3002`);
+  logger10.error(`\u91CD\u8BD5 ${config.maxRetries} \u6B21\u540E\uFF0C\u9A8C\u8BC1\u7801\u4ECD\u672A\u8BC6\u522B\u6210\u529F\u3002`);
   return false;
 }
 var sloveCaptcha = solveCaptcha;
 
 // src/chaptcha.js
-var logger12 = createInternalLogger("Captcha");
+var logger11 = createInternalLogger("Captcha");
 var DEFAULT_CAPTCHA_RECOGNITION_OPTIONS = Object.freeze({
   token: "eKJvBfwfN0YRav0-VD_44E2VBSfm7l0YtddUQ7cFySI",
   apiUrl: "https://api.jfbym.com/api/YmServer/customApi"
@@ -6621,7 +6470,7 @@ function useCaptchaMonitor(page, options) {
         };
       })();
     }, { selector: domSelector, callbackName: exposedFunctionName, cleanerName });
-    logger12.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${domSelector}`);
+    logger11.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${domSelector}`);
     cleanupFns.push(async () => {
       try {
         await page.evaluate((name) => {
@@ -6645,14 +6494,14 @@ function useCaptchaMonitor(page, options) {
       }
     };
     page.on("framenavigated", frameHandler);
-    logger12.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${urlPattern}`);
+    logger11.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${urlPattern}`);
     cleanupFns.push(async () => {
       page.off("framenavigated", frameHandler);
     });
   }
   return {
     stop: async () => {
-      logger12.info("\u6B63\u5728\u505C\u6B62\u9A8C\u8BC1\u7801\u76D1\u63A7...");
+      logger11.info("\u6B63\u5728\u505C\u6B62\u9A8C\u8BC1\u7801\u76D1\u63A7...");
       for (const fn of cleanupFns) {
         await fn();
       }
@@ -6691,7 +6540,7 @@ async function solveCaptchaWithStrategy(strategyName, page, options = {}) {
   );
   return strategy.sloveCaptcha(page, resolvedOptions, {
     callCaptchaRecognitionApi,
-    logger: logger12
+    logger: logger11
   });
 }
 var Captcha = {
@@ -6702,7 +6551,7 @@ var Captcha = {
 // src/mutation.js
 import { createHash } from "node:crypto";
 import { v4 as uuidv42 } from "uuid";
-var logger13 = createInternalLogger("Mutation");
+var logger12 = createInternalLogger("Mutation");
 var MUTATION_MONITOR_MODE = Object.freeze({
   Added: "added",
   Changed: "changed",
@@ -6735,14 +6584,14 @@ var Mutation = {
     const stableTime = options.stableTime ?? 5 * 1e3;
     const timeout = options.timeout ?? 120 * 1e3;
     const onMutation = options.onMutation;
-    logger13.start("waitForStable", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, \u7A33\u5B9A\u65F6\u95F4=${stableTime}ms`);
+    logger12.start("waitForStable", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, \u7A33\u5B9A\u65F6\u95F4=${stableTime}ms`);
     if (initialTimeout > 0) {
       const selectorQuery = selectorList.join(",");
       try {
         await page.waitForSelector(selectorQuery, { timeout: initialTimeout });
-        logger13.info(`waitForStable \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
+        logger12.info(`waitForStable \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
       } catch (e) {
-        logger13.warning(`waitForStable \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
+        logger12.warning(`waitForStable \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
         throw e;
       }
     }
@@ -6758,7 +6607,7 @@ var Mutation = {
             return "__CONTINUE__";
           }
         });
-        logger13.info("waitForStable \u5DF2\u542F\u7528 onMutation \u56DE\u8C03");
+        logger12.info("waitForStable \u5DF2\u542F\u7528 onMutation \u56DE\u8C03");
       } catch (e) {
       }
     }
@@ -6873,9 +6722,9 @@ var Mutation = {
       { selectorList, stableTime, timeout, callbackName, hasCallback: !!onMutation }
     );
     if (result.mutationCount === 0 && result.stableTime === 0) {
-      logger13.warning("waitForStable \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
+      logger12.warning("waitForStable \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
     }
-    logger13.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
+    logger12.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
     return result;
   },
   /**
@@ -7047,29 +6896,29 @@ var Mutation = {
         return "__CONTINUE__";
       }
     };
-    logger13.start(
+    logger12.start(
       "waitForStableAcrossRoots",
       `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668(\u8DE8 root), \u7A33\u5B9A\u65F6\u95F4=${waitForStableTime}ms`
     );
     if (initialTimeout > 0) {
       try {
         await page.waitForSelector(selectorQuery, { timeout: initialTimeout });
-        logger13.info(`waitForStableAcrossRoots \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
+        logger12.info(`waitForStableAcrossRoots \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
       } catch (e) {
-        logger13.warning(`waitForStableAcrossRoots \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
+        logger12.warning(`waitForStableAcrossRoots \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
         throw e;
       }
     }
-    let state = await buildState();
-    if (!state?.hasMatched) {
-      logger13.warning("waitForStableAcrossRoots \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
+    let state2 = await buildState();
+    if (!state2?.hasMatched) {
+      logger12.warning("waitForStableAcrossRoots \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
       return { mutationCount: 0, stableTime: 0, wasPaused: false };
     }
     let mutationCount = 0;
     let stableSince = 0;
     let isPaused = false;
     let wasPaused = false;
-    let lastSnapshotKey = state.snapshotKey;
+    let lastSnapshotKey = state2.snapshotKey;
     const applyPauseSignal = (signal) => {
       const nextPaused = signal === "__PAUSE__";
       if (nextPaused) {
@@ -7083,13 +6932,13 @@ var Mutation = {
     };
     const initialSignal = await invokeMutationCallback({
       mutationCount: 0,
-      html: state.html || "",
-      text: state.text || "",
-      mutationNodes: state.mutationNodes || []
+      html: state2.html || "",
+      text: state2.text || "",
+      mutationNodes: state2.mutationNodes || []
     });
     applyPauseSignal(initialSignal);
     const deadline = Date.now() + overallTimeout;
-    let lastState = state;
+    let lastState = state2;
     while (Date.now() < deadline) {
       await sleep(pollInterval);
       lastState = await buildState();
@@ -7099,7 +6948,7 @@ var Mutation = {
       if (lastState.snapshotKey !== lastSnapshotKey) {
         lastSnapshotKey = lastState.snapshotKey;
         mutationCount += 1;
-        logger13.info(
+        logger12.info(
           `waitForStableAcrossRoots \u53D8\u5316#${mutationCount}, len=${lastState.snapshotLength}, path=${lastState.primaryPath || "unknown"}, preview="${truncate(lastState.text, 120)}"`
         );
         const signal = await invokeMutationCallback({
@@ -7112,7 +6961,7 @@ var Mutation = {
         continue;
       }
       if (!isPaused && stableSince > 0 && Date.now() - stableSince >= waitForStableTime) {
-        logger13.success("waitForStableAcrossRoots", `DOM \u7A33\u5B9A, \u603B\u5171 ${mutationCount} \u6B21\u53D8\u5316${wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
+        logger12.success("waitForStableAcrossRoots", `DOM \u7A33\u5B9A, \u603B\u5171 ${mutationCount} \u6B21\u53D8\u5316${wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
         return {
           mutationCount,
           stableTime: waitForStableTime,
@@ -7139,7 +6988,7 @@ var Mutation = {
     const onMutation = options.onMutation;
     const rawMode = String(options.mode || MUTATION_MONITOR_MODE.Added).toLowerCase();
     const mode = [MUTATION_MONITOR_MODE.Added, MUTATION_MONITOR_MODE.Changed, MUTATION_MONITOR_MODE.All].includes(rawMode) ? rawMode : MUTATION_MONITOR_MODE.Added;
-    logger13.start("useMonitor", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, mode=${mode}`);
+    logger12.start("useMonitor", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, mode=${mode}`);
     const monitorKey = generateKey("pk_mon");
     const callbackName = generateKey("pk_mon_cb");
     const cleanerName = generateKey("pk_mon_clean");
@@ -7282,7 +7131,7 @@ var Mutation = {
         return total;
       };
     }, { selectorList, monitorKey, callbackName, cleanerName, hasCallback: !!onMutation, mode });
-    logger13.success("useMonitor", "\u76D1\u63A7\u5668\u5DF2\u542F\u52A8");
+    logger12.success("useMonitor", "\u76D1\u63A7\u5668\u5DF2\u542F\u52A8");
     return {
       stop: async () => {
         let totalMutations = 0;
@@ -7295,7 +7144,7 @@ var Mutation = {
           }, cleanerName);
         } catch (e) {
         }
-        logger13.success("useMonitor.stop", `\u76D1\u63A7\u5DF2\u505C\u6B62, \u5171 ${totalMutations} \u6B21\u53D8\u5316`);
+        logger12.success("useMonitor.stop", `\u76D1\u63A7\u5DF2\u505C\u6B62, \u5171 ${totalMutations} \u6B21\u53D8\u5316`);
         return { totalMutations };
       }
     };
@@ -8164,7 +8013,7 @@ var createTemplateLogger = (baseLogger = createBaseLogger()) => {
 };
 var getDefaultBaseLogger = () => createBaseLogger("");
 var Logger = {
-  setLogger: (logger17) => setDefaultLogger(logger17),
+  setLogger: (logger16) => setDefaultLogger(logger16),
   info: (message) => getDefaultBaseLogger().info(message),
   success: (message) => getDefaultBaseLogger().success(message),
   warning: (message) => getDefaultBaseLogger().warning(message),
@@ -8172,8 +8021,8 @@ var Logger = {
   error: (message) => getDefaultBaseLogger().error(message),
   debug: (message) => getDefaultBaseLogger().debug(message),
   start: (message) => getDefaultBaseLogger().start(message),
-  useTemplate: (logger17) => {
-    if (logger17) return createTemplateLogger(createBaseLogger("", logger17));
+  useTemplate: (logger16) => {
+    if (logger16) return createTemplateLogger(createBaseLogger("", logger16));
     return createTemplateLogger();
   }
 };
@@ -8247,7 +8096,7 @@ var LOCATION_NETWORK_SUFFIX_PATTERNS = [
 ];
 var cachedStripLogoSrcPromise = null;
 var cachedEnrichmentByContext = /* @__PURE__ */ new WeakMap();
-var logger14 = createInternalLogger("Watermarkify");
+var logger13 = createInternalLogger("Watermarkify");
 var normalizeText = (value) => String(value || "").trim();
 var toInline = (value, maxLen = 200) => {
   const text = normalizeText(value);
@@ -8489,9 +8338,9 @@ var resolveWithCustomResolver = async (page, baseMeta, options = {}) => {
       location: toInline(resolved.location, 80)
     };
     if (enrichment.ip || enrichment.location) {
-      logger14.info(`\u81EA\u5B9A\u4E49 resolver \u547D\u4E2D: ip=${enrichment.ip || "-"}, loc=${enrichment.location || "-"}`);
+      logger13.info(`\u81EA\u5B9A\u4E49 resolver \u547D\u4E2D: ip=${enrichment.ip || "-"}, loc=${enrichment.location || "-"}`);
     } else {
-      logger14.warning("\u81EA\u5B9A\u4E49 resolver \u5DF2\u6267\u884C\uFF0C\u4F46\u672A\u8FD4\u56DE IP/Loc");
+      logger13.warning("\u81EA\u5B9A\u4E49 resolver \u5DF2\u6267\u884C\uFF0C\u4F46\u672A\u8FD4\u56DE IP/Loc");
     }
     return enrichment;
   } finally {
@@ -8680,12 +8529,12 @@ var normalizeWatermarkifyRenderMode = (value) => {
 };
 var composeScreenshotBufferWithBrowser = async (page, buffer, overlaySvg, imageInfo = {}, options = {}) => {
   if (!page || typeof page.context !== "function") {
-    logger14.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u7F3A\u5C11\u53EF\u7528 page");
+    logger13.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u7F3A\u5C11\u53EF\u7528 page");
     return buffer;
   }
   const renderScope = await openProbePage(page);
   if (!renderScope?.page) {
-    logger14.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA render page");
+    logger13.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA render page");
     return buffer;
   }
   try {
@@ -8750,13 +8599,13 @@ var composeScreenshotBufferWithBrowser = async (page, buffer, overlaySvg, imageI
       fullPage: true,
       animations: "disabled"
     }).catch((error) => {
-      logger14.warning(`watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+      logger13.warning(`watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
       return null;
     });
     if (Buffer.isBuffer(composed) && composed.length > 0) {
       return composed;
     }
-    logger14.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: \u672A\u5F97\u5230\u6709\u6548\u622A\u56FE\u7ED3\u679C");
+    logger13.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: \u672A\u5F97\u5230\u6709\u6548\u622A\u56FE\u7ED3\u679C");
     return buffer;
   } finally {
     await renderScope.close().catch(() => {
@@ -8769,7 +8618,7 @@ var resolveWithIpLookup = async (page, options = {}) => {
   }
   const probeScope = await openProbePage(page);
   if (!probeScope?.page) {
-    logger14.warning("ipLookup \u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA probe page");
+    logger13.warning("ipLookup \u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA probe page");
     return null;
   }
   const timeoutMs = Math.max(
@@ -8778,12 +8627,12 @@ var resolveWithIpLookup = async (page, options = {}) => {
   );
   try {
     const probePage = probeScope.page;
-    logger14.info(`ipLookup \u5C1D\u8BD5: url=${DEFAULT_IP_LOOKUP_URL}, timeoutMs=${timeoutMs}`);
+    logger13.info(`ipLookup \u5C1D\u8BD5: url=${DEFAULT_IP_LOOKUP_URL}, timeoutMs=${timeoutMs}`);
     const response = await probePage.goto(DEFAULT_IP_LOOKUP_URL, {
       waitUntil: "commit",
       timeout: timeoutMs
     }).catch((error) => {
-      logger14.warning(`ipLookup \u8BF7\u6C42\u5931\u8D25: url=${DEFAULT_IP_LOOKUP_URL}, error=${error instanceof Error ? error.message : String(error)}`);
+      logger13.warning(`ipLookup \u8BF7\u6C42\u5931\u8D25: url=${DEFAULT_IP_LOOKUP_URL}, error=${error instanceof Error ? error.message : String(error)}`);
       return null;
     });
     const status = response && typeof response.status === "function" ? response.status() : 0;
@@ -8805,13 +8654,13 @@ var resolveWithIpLookup = async (page, options = {}) => {
     }
     const parsed = parseIpIpJsonResponse(rawText);
     if (parsed?.ip || parsed?.location) {
-      logger14.info(`ipLookup \u6210\u529F: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, ip=${parsed.ip || "-"}, loc=${parsed.location || "-"}`);
+      logger13.info(`ipLookup \u6210\u529F: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, ip=${parsed.ip || "-"}, loc=${parsed.location || "-"}`);
       return parsed;
     }
-    logger14.warning(`ipLookup \u672A\u89E3\u6790\u51FA IP/Loc: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, preview=${shortenTail(rawText, 120) || "[empty]"}`);
+    logger13.warning(`ipLookup \u672A\u89E3\u6790\u51FA IP/Loc: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, preview=${shortenTail(rawText, 120) || "[empty]"}`);
     return null;
   } catch (error) {
-    logger14.warning(`ipLookup \u6267\u884C\u5F02\u5E38\uFF0C\u672A\u83B7\u5F97 IP/Loc: ${error instanceof Error ? error.message : String(error)}`);
+    logger13.warning(`ipLookup \u6267\u884C\u5F02\u5E38\uFF0C\u672A\u83B7\u5F97 IP/Loc: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   } finally {
     await probeScope.close().catch(() => {
@@ -8825,10 +8674,10 @@ var resolveEnrichment = async (page, baseMeta, options) => {
     ip: toInline(options.ip, 80),
     location: toInline(options.location, 80)
   };
-  logger14.info(`enrichment \u5F00\u59CB: host=${baseMeta.hostname || "-"}, hasPresetIp=${Boolean(merged.ip)}, hasPresetLoc=${Boolean(merged.location)}, ipLookup=${options.ipLookup !== false}`);
+  logger13.info(`enrichment \u5F00\u59CB: host=${baseMeta.hostname || "-"}, hasPresetIp=${Boolean(merged.ip)}, hasPresetLoc=${Boolean(merged.location)}, ipLookup=${options.ipLookup !== false}`);
   if (!merged.ip || !merged.location) {
     if (cached?.ip || cached?.location) {
-      logger14.info(`enrichment \u547D\u4E2D\u4E0A\u4E0B\u6587\u7F13\u5B58: ip=${cached.ip || "-"}, loc=${cached.location || "-"}`);
+      logger13.info(`enrichment \u547D\u4E2D\u4E0A\u4E0B\u6587\u7F13\u5B58: ip=${cached.ip || "-"}, loc=${cached.location || "-"}`);
     }
     fillEnrichment(merged, cached);
   }
@@ -8852,15 +8701,15 @@ var resolveEnrichment = async (page, baseMeta, options) => {
       "x-geo-country"
     ]), 80);
     if (!merged.location || isWeakLocationValue(merged.location) && headerLocation) {
-      logger14.info(`enrichment \u4F7F\u7528\u54CD\u5E94\u5934\u8865\u5145 Loc: ${headerLocation || "-"}`);
+      logger13.info(`enrichment \u4F7F\u7528\u54CD\u5E94\u5934\u8865\u5145 Loc: ${headerLocation || "-"}`);
       merged.location = headerLocation || merged.location;
     }
   }
   writeCachedEnrichment(page, merged);
   if (merged.ip || merged.location) {
-    logger14.info(`enrichment \u5B8C\u6210: ip=${merged.ip || "-"}, loc=${merged.location || "-"}`);
+    logger13.info(`enrichment \u5B8C\u6210: ip=${merged.ip || "-"}, loc=${merged.location || "-"}`);
   } else {
-    logger14.warning("enrichment \u5B8C\u6210: \u672A\u83B7\u5F97 IP/Loc");
+    logger13.warning("enrichment \u5B8C\u6210: \u672A\u83B7\u5F97 IP/Loc");
   }
   return merged;
 };
@@ -9673,7 +9522,7 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null, options = {
   }
   const imageInfo = readImageInfo(buffer);
   if (!imageInfo.width || !imageInfo.height || !imageInfo.mimeType) {
-    logger14.warning("watermarkify \u8DF3\u8FC7: \u65E0\u6CD5\u89E3\u6790\u622A\u56FE\u5C3A\u5BF8\u6216\u683C\u5F0F");
+    logger13.warning("watermarkify \u8DF3\u8FC7: \u65E0\u6CD5\u89E3\u6790\u622A\u56FE\u5C3A\u5BF8\u6216\u683C\u5F0F");
     return buffer;
   }
   const isMobileStrip = normalizeDevice(meta.device) === Device.Mobile && hasStrip;
@@ -9691,7 +9540,7 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null, options = {
 
 // src/internals/compression.js
 import { Jimp, JimpMime, ResizeStrategy } from "jimp";
-var logger15 = createInternalLogger("Compression");
+var logger14 = createInternalLogger("Compression");
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_SCREENSHOT_OUTPUT_TYPE = "jpeg";
 var DEFAULT_SCREENSHOT_QUALITY = 0.72;
@@ -9810,18 +9659,18 @@ var compressImageBufferToBase64 = async (buffer, compression) => {
     return buffer.toString("base64");
   }
   const result = await compressImageBuffer(buffer, compression).catch((error) => {
-    logger15.warning(`captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE: ${error instanceof Error ? error.message : String(error)}`);
+    logger14.warning(`captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   });
   if (!result?.buffer) {
     return buffer.toString("base64");
   }
   if (result.withinLimit) {
-    logger15.info(
+    logger14.info(
       `captureScreen \u5DF2\u538B\u7F29: ${originalBytes} -> ${result.bytes} bytes, format=${result.format}, quality=${result.quality}, scale=${result.scale}, size=${result.width}x${result.height}`
     );
   } else {
-    logger15.warning(
+    logger14.warning(
       `captureScreen \u538B\u7F29\u540E\u4ECD\u8D85\u8FC7\u76EE\u6807: ${originalBytes} -> ${result.bytes} bytes, maxBytes=${compression.maxBytes}, format=${result.format}, quality=${result.quality}, scale=${result.scale}`
     );
   }
@@ -9829,7 +9678,7 @@ var compressImageBufferToBase64 = async (buffer, compression) => {
 };
 
 // src/share.js
-var logger16 = createInternalLogger("Share");
+var logger15 = createInternalLogger("Share");
 var DEFAULT_TIMEOUT_MS2 = 50 * 1e3;
 var DEFAULT_PAYLOAD_SNAPSHOT_MAX_LEN = 500;
 var DEFAULT_POLL_INTERVAL_MS = 120;
@@ -9966,7 +9815,7 @@ var createDomShareMonitor = async (page, options = {}) => {
   const onMatch = typeof options.onMatch === "function" ? options.onMatch : null;
   const onTelemetry = typeof options.onTelemetry === "function" ? options.onTelemetry : null;
   let matched = false;
-  logger16.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
+  logger15.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
   const monitor = await Mutation.useMonitor(page, selectors, {
     mode,
     onMutation: (context = {}) => {
@@ -9984,12 +9833,12 @@ ${text}`;
         });
       }
       if (mutationCount <= 5 || mutationCount % 50 === 0) {
-        logger16.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
+        logger15.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
       }
       const [candidate] = Utils.parseLinks(rawDom, { prefix }) || [];
       if (!candidate) return;
       matched = true;
-      logger16.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
+      logger15.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
       if (onMatch) {
         onMatch({
           link: candidate,
@@ -10005,7 +9854,7 @@ ${text}`;
   return {
     stop: async () => {
       const result = await monitor.stop();
-      logger16.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
+      logger15.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
       return result;
     }
   };
@@ -10054,8 +9903,8 @@ var Share = {
     if (share.mode === "response" && apiMatchers.length === 0) {
       throw new Error("Share.captureLink requires share.xurl[0] api matcher when mode=response");
     }
-    logger16.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutDisabled ? "disabled" : timeoutMs}, prefix=${share.prefix}`);
-    logger16.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
+    logger15.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutDisabled ? "disabled" : timeoutMs}, prefix=${share.prefix}`);
+    logger15.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
     const stats = {
       actionTimedOut: false,
       domMutationCount: 0,
@@ -10067,7 +9916,7 @@ var Share = {
       responseSampleUrls: []
     };
     if (isAborted()) {
-      logger16.warning(`captureLink \u5DF2\u53D6\u6D88: ${abortReason()}`);
+      logger15.warning(`captureLink \u5DF2\u53D6\u6D88: ${abortReason()}`);
       return {
         link: null,
         payloadText: "",
@@ -10090,7 +9939,7 @@ var Share = {
         link: validated,
         payloadText: String(payloadText || "")
       };
-      logger16.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
+      logger15.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
       return true;
     };
     const resolveResponseCandidate = (responseText) => {
@@ -10125,7 +9974,7 @@ var Share = {
       try {
         await monitor.stop();
       } catch (error) {
-        logger16.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+        logger15.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     const onResponse = async (response) => {
@@ -10139,29 +9988,29 @@ var Share = {
           stats.responseSampleUrls.push(url);
         }
         if (stats.responseObserved <= 5) {
-          logger16.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
+          logger15.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
         }
         if (!apiMatchers.some((matcher) => url.includes(matcher))) return;
         stats.responseMatched += 1;
         stats.lastMatchedUrl = url;
-        logger16.info(`\u63A5\u53E3\u547D\u4E2D\u5339\u914D(${stats.responseMatched}): ${url}`);
+        logger15.info(`\u63A5\u53E3\u547D\u4E2D\u5339\u914D(${stats.responseMatched}): ${url}`);
         const text = await response.text();
         const hit = resolveResponseCandidate(text);
         if (!hit?.link) {
           if (stats.responseMatched <= 3) {
-            logger16.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
+            logger15.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
           }
           return;
         }
         stats.responseResolved += 1;
-        logger16.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
+        logger15.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
         setCandidate("response", hit.link, hit.payloadText);
       } catch (error) {
-        logger16.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
+        logger15.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     if (share.mode === "dom") {
-      logger16.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
+      logger15.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
       domMonitor = await createDomShareMonitor(page, {
         prefix: share.prefix,
         selectors: domSelectors,
@@ -10176,17 +10025,17 @@ var Share = {
       });
     }
     if (share.mode === "response") {
-      logger16.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
+      logger15.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
       page.on("response", onResponse);
     }
     if (share.mode === "custom") {
-      logger16.info("\u5F53\u524D\u4E3A custom \u6A21\u5F0F\uFF0C\u5C06\u4F7F\u7528 performActions \u8FD4\u56DE\u503C");
+      logger15.info("\u5F53\u524D\u4E3A custom \u6A21\u5F0F\uFF0C\u5C06\u4F7F\u7528 performActions \u8FD4\u56DE\u503C");
     }
     const deadline = timeoutDisabled ? Infinity : Date.now() + timeoutMs;
     const getRemainingMs = () => timeoutDisabled ? Infinity : Math.max(0, deadline - Date.now());
     try {
       const actionTimeout = getRemainingMs();
-      logger16.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${timeoutDisabled ? "disabled" : `${actionTimeout}ms`}`);
+      logger15.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${timeoutDisabled ? "disabled" : `${actionTimeout}ms`}`);
       let actionValue;
       if (!isAborted() && actionTimeout > 0) {
         let timer = null;
@@ -10199,30 +10048,30 @@ var Share = {
         ]);
         if (timer) clearTimeout(timer);
         if (actionResult.type === "error") {
-          logger16.fail("captureLink.performActions", actionResult.error);
+          logger15.fail("captureLink.performActions", actionResult.error);
           throw actionResult.error;
         }
         if (actionResult.type === "timeout") {
           stats.actionTimedOut = true;
-          logger16.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
+          logger15.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
         } else {
           actionValue = actionResult.result;
-          logger16.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
+          logger15.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
         }
       }
       if (share.mode === "custom") {
         const customLink = typeof actionValue === "string" ? actionValue : actionValue?.link || actionValue?.payloadText;
         const customPayloadText = typeof actionValue === "string" ? actionValue : actionValue?.payloadText;
         if (setCandidate("custom", customLink, customPayloadText)) {
-          logger16.success("captureLink.customResult", `custom \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: link=${candidates.custom.link}`);
+          logger15.success("captureLink.customResult", `custom \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: link=${candidates.custom.link}`);
         } else {
-          logger16.warning("performActions \u6267\u884C\u5B8C\u6210\u4F46\u672A\u8FD4\u56DE\u6709\u6548\u5206\u4EAB\u94FE\u63A5");
+          logger15.warning("performActions \u6267\u884C\u5B8C\u6210\u4F46\u672A\u8FD4\u56DE\u6709\u6548\u5206\u4EAB\u94FE\u63A5");
         }
       }
       let nextProgressLogTs = Date.now() + 3e3;
       while (true) {
         if (isAborted()) {
-          logger16.warning(`captureLink \u5DF2\u53D6\u6D88: ${abortReason()}`);
+          logger15.warning(`captureLink \u5DF2\u53D6\u6D88: ${abortReason()}`);
           return {
             link: null,
             payloadText: "",
@@ -10232,7 +10081,7 @@ var Share = {
         }
         const selected = candidates[share.mode];
         if (selected?.link) {
-          logger16.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
+          logger15.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
           return {
             link: selected.link,
             payloadText: selected.payloadText,
@@ -10245,7 +10094,7 @@ var Share = {
         if (remaining <= 0) break;
         const now = Date.now();
         if (now >= nextProgressLogTs) {
-          logger16.info(
+          logger15.info(
             `captureLink \u7B49\u5F85\u4E2D: remaining=${timeoutDisabled ? "disabled" : `${remaining}ms`}, domMutationCount=${stats.domMutationCount}, responseMatched=${stats.responseMatched}`
           );
           nextProgressLogTs = now + 5e3;
@@ -10253,11 +10102,11 @@ var Share = {
         await delay5(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
       }
       if (!timeoutDisabled && share.mode === "response" && stats.responseMatched === 0) {
-        logger16.warning(
+        logger15.warning(
           `\u63A5\u53E3\u76D1\u542C\u672A\u547D\u4E2D: apiMatchers=${toJsonInline(apiMatchers, 220)}, \u54CD\u5E94\u6837\u672CURLs=${toJsonInline(stats.responseSampleUrls, 420)}`
         );
       }
-      logger16.warning(
+      logger15.warning(
         `captureLink ${timeoutDisabled ? "\u672A\u62FF\u5230\u94FE\u63A5" : "\u8D85\u65F6\u672A\u62FF\u5230\u94FE\u63A5"}: mode=${share.mode}, actionTimedOut=${stats.actionTimedOut}, domMutationCount=${stats.domMutationCount}, responseObserved=${stats.responseObserved}, responseMatched=${stats.responseMatched}, lastMatchedUrl=${stats.lastMatchedUrl || "none"}`
       );
       return {
@@ -10269,7 +10118,7 @@ var Share = {
     } finally {
       if (share.mode === "response") {
         page.off("response", onResponse);
-        logger16.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
+        logger15.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
       }
       await stopDomMonitor();
     }