@skrillex1224/playwright-toolkit 2.1.276 → 2.1.278

package/dist/index.cjs

@@ -40,9 +40,11 @@ __export(constants_exports, {
   ActorInfo: () => ActorInfo,
   Code: () => Code,
   Device: () => Device,
+  Mode: () => Mode,
   PresetOfLiveViewKey: () => PresetOfLiveViewKey,
   Status: () => Status,
-  normalizeDevice: () => normalizeDevice
+  normalizeDevice: () => normalizeDevice,
+  normalizeMode: () => normalizeMode
 });
 var Code = {
   Success: 0,
@@ -62,6 +64,10 @@ var Device = Object.freeze({
   Desktop: "desktop",
   Mobile: "mobile"
 });
+var Mode = Object.freeze({
+  Default: "default",
+  CloakBrowser: "cloakbrowser"
+});
 var normalizeDevice = (value, fallback = Device.Desktop) => {
   const normalizedFallback = String(fallback || "").trim().toLowerCase() === Device.Mobile ? Device.Mobile : Device.Desktop;
   const raw = String(value || "").trim().toLowerCase();
@@ -69,6 +75,13 @@ var normalizeDevice = (value, fallback = Device.Desktop) => {
   if (raw === Device.Desktop) return Device.Desktop;
   return normalizedFallback;
 };
+var normalizeMode = (value, fallback = Mode.Default) => {
+  const normalizedFallback = String(fallback || "").trim().toLowerCase() === Mode.CloakBrowser ? Mode.CloakBrowser : Mode.Default;
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === Mode.CloakBrowser) return Mode.CloakBrowser;
+  if (raw === Mode.Default) return Mode.Default;
+  return normalizedFallback;
+};
 var createActorInfo = (info) => {
   const normalizeDomain = (value) => {
     if (!value) return "";
@@ -2477,8 +2490,7 @@ var Utils = {
   }
 };
 
-// src/anti-cheat.js
-var logger5 = createInternalLogger("AntiCheat");
+// src/internals/anti-cheat/default.js
 var BASE_CONFIG = Object.freeze({
   locale: "zh-CN",
   acceptLanguage: "zh-CN,zh;q=0.9",
@@ -2513,7 +2525,7 @@ function buildFingerprintOptions({ locale = BASE_CONFIG.locale, browserMajorVers
   }
   return options;
 }
-var AntiCheat = {
+var DefaultAntiCheat = {
   /**
    * 获取统一的基础配置
    */
@@ -2550,6 +2562,44 @@ var AntiCheat = {
   }
 };
 
+// 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 = {
+  getBaseConfig() {
+    return callAntiCheat("getBaseConfig");
+  },
+  getFingerprintGeneratorOptions(options = {}) {
+    return callAntiCheat("getFingerprintGeneratorOptions", options);
+  },
+  getLaunchArgs(options = {}) {
+    return callAntiCheat("getLaunchArgs", options);
+  },
+  getTlsFingerprintOptions(userAgent = "", acceptLanguage = "", options = {}) {
+    return callAntiCheat("getTlsFingerprintOptions", userAgent, acceptLanguage, options);
+  },
+  applyLocaleHeaders(headers, acceptLanguage = "") {
+    return callAntiCheat("applyLocaleHeaders", headers, acceptLanguage);
+  }
+};
+
 // src/device-input.js
 var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
 var assertPage = (page, method) => {
@@ -3103,7 +3153,7 @@ var DeviceView = {
 // src/internals/humanize/desktop.js
 var import_delay2 = __toESM(require("delay"), 1);
 var import_ghost_cursor_playwright = require("ghost-cursor-playwright");
-var logger6 = createInternalLogger("Humanize");
+var logger5 = createInternalLogger("Humanize");
 var $CursorWeakMap = /* @__PURE__ */ new WeakMap();
 function $GetCursor(page) {
   const cursor = $CursorWeakMap.get(page);
@@ -3131,13 +3181,13 @@ var Humanize = {
    */
   async initializeCursor(page) {
     if ($CursorWeakMap.has(page)) {
-      logger6.debug("initializeCursor: cursor already exists, skipping");
+      logger5.debug("initializeCursor: cursor already exists, skipping");
       return;
     }
-    logger6.start("initializeCursor", "creating cursor");
+    logger5.start("initializeCursor", "creating cursor");
     const cursor = await (0, import_ghost_cursor_playwright.createCursor)(page);
     $CursorWeakMap.set(page, cursor);
-    logger6.success("initializeCursor", "cursor initialized");
+    logger5.success("initializeCursor", "cursor initialized");
   },
   /**
    * 人类化鼠标移动 - 使用 ghost-cursor 移动到指定位置或元素
@@ -3147,17 +3197,17 @@ var Humanize = {
    */
   async humanMove(page, target) {
     const cursor = $GetCursor(page);
-    logger6.start("humanMove", `target=${typeof target === "string" ? target : "element/coords"}`);
+    logger5.start("humanMove", `target=${typeof target === "string" ? target : "element/coords"}`);
     try {
       if (typeof target === "string") {
         const element = await page.$(target);
         if (!element) {
-          logger6.warn(`humanMove: \u5143\u7D20\u4E0D\u5B58\u5728 ${target}`);
+          logger5.warn(`humanMove: \u5143\u7D20\u4E0D\u5B58\u5728 ${target}`);
           return false;
         }
         const box = await element.boundingBox();
         if (!box) {
-          logger6.warn(`humanMove: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E ${target}`);
+          logger5.warn(`humanMove: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E ${target}`);
           return false;
         }
         const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.2;
@@ -3173,10 +3223,10 @@ var Humanize = {
           await cursor.actions.move({ x, y });
         }
       }
-      logger6.success("humanMove");
+      logger5.success("humanMove");
       return true;
     } catch (error) {
-      logger6.fail("humanMove", error);
+      logger5.fail("humanMove", error);
       throw error;
     }
   },
@@ -3200,12 +3250,12 @@ var Humanize = {
       maxDurationMs = maxSteps * 220 + 800
     } = options;
     const targetDesc = typeof target === "string" ? target : "ElementHandle";
-    logger6.start("humanScroll", `target=${targetDesc}`);
+    logger5.start("humanScroll", `target=${targetDesc}`);
     let element;
     if (typeof target === "string") {
       element = await page.$(target);
       if (!element) {
-        logger6.warn(`humanScroll | \u5143\u7D20\u672A\u627E\u5230: ${target}`);
+        logger5.warn(`humanScroll | \u5143\u7D20\u672A\u627E\u5230: ${target}`);
         return { element: null, didScroll: false };
       }
     } else {
@@ -3280,26 +3330,26 @@ var Humanize = {
     try {
       for (let i = 0; i < maxSteps; i++) {
         if (Date.now() - startTime > maxDurationMs) {
-          logger6.warn(`humanScroll | \u8D85\u65F6\u4FDD\u62A4\u89E6\u53D1 (${maxDurationMs}ms)`);
+          logger5.warn(`humanScroll | \u8D85\u65F6\u4FDD\u62A4\u89E6\u53D1 (${maxDurationMs}ms)`);
           return { element, didScroll };
         }
         const status = await checkVisibility();
         if (status.code === "VISIBLE") {
           if (status.isFixed) {
-            logger6.info("humanScroll | fixed \u5BB9\u5668\u5185\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
+            logger5.info("humanScroll | fixed \u5BB9\u5668\u5185\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
           } else {
-            logger6.debug("humanScroll | \u5143\u7D20\u53EF\u89C1\u4E14\u65E0\u906E\u6321");
+            logger5.debug("humanScroll | \u5143\u7D20\u53EF\u89C1\u4E14\u65E0\u906E\u6321");
           }
-          logger6.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
+          logger5.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
           return { element, didScroll };
         }
-        logger6.debug(`humanScroll | \u6B65\u9AA4 ${i + 1}/${maxSteps}: ${status.reason} ${status.direction ? `(${status.direction})` : ""}`);
+        logger5.debug(`humanScroll | \u6B65\u9AA4 ${i + 1}/${maxSteps}: ${status.reason} ${status.direction ? `(${status.direction})` : ""}`);
         if (status.code === "OBSTRUCTED" && status.obstruction) {
-          logger6.debug(`humanScroll | \u88AB\u4EE5\u4E0B\u5143\u7D20\u906E\u6321 <${status.obstruction.tag} id="${status.obstruction.id}">`);
+          logger5.debug(`humanScroll | \u88AB\u4EE5\u4E0B\u5143\u7D20\u906E\u6321 <${status.obstruction.tag} id="${status.obstruction.id}">`);
         }
         const scrollRect = await getScrollableRect2();
         if (!scrollRect && status.isFixed) {
-          logger6.warn("humanScroll | fixed \u5BB9\u5668\u5185\u4E14\u65E0\u53EF\u6EDA\u52A8\u7956\u5148\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
+          logger5.warn("humanScroll | fixed \u5BB9\u5668\u5185\u4E14\u65E0\u53EF\u6EDA\u52A8\u7956\u5148\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
           return { element, didScroll };
         }
         const stepMin = scrollRect ? Math.min(minStep, Math.max(60, scrollRect.height * 0.4)) : minStep;
@@ -3335,10 +3385,10 @@ var Humanize = {
         didScroll = true;
         await (0, import_delay2.default)(this.jitterMs(20 + Math.random() * 40, 0.2));
       }
-      logger6.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
+      logger5.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
       return { element, didScroll };
     } catch (error) {
-      logger6.fail("humanScroll", error);
+      logger5.fail("humanScroll", error);
       throw error;
     }
   },
@@ -3356,7 +3406,7 @@ var Humanize = {
     const cursor = $GetCursor(page);
     const { reactionDelay = 250, throwOnMissing = true, scrollIfNeeded = true, restore = false } = options;
     const targetDesc = target == null ? "Current Position" : typeof target === "string" ? target : "ElementHandle";
-    logger6.start("humanClick", `target=${targetDesc}`);
+    logger5.start("humanClick", `target=${targetDesc}`);
     const restoreOnce = async () => {
       if (restoreOnce.restored) return;
       restoreOnce.restored = true;
@@ -3365,14 +3415,14 @@ var Humanize = {
         await (0, import_delay2.default)(this.jitterMs(1e3));
         await restoreOnce.do();
       } catch (restoreError) {
-        logger6.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
+        logger5.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
       }
     };
     try {
       if (target == null) {
         await (0, import_delay2.default)(this.jitterMs(reactionDelay, 0.4));
         await cursor.actions.click();
-        logger6.success("humanClick", "Clicked current position");
+        logger5.success("humanClick", "Clicked current position");
         return true;
       }
       let element;
@@ -3382,7 +3432,7 @@ var Humanize = {
           if (throwOnMissing) {
             throw new Error(`\u627E\u4E0D\u5230\u5143\u7D20 ${target}`);
           }
-          logger6.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${target}`);
+          logger5.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${target}`);
           return false;
         }
       } else {
@@ -3398,7 +3448,7 @@ var Humanize = {
         if (throwOnMissing) {
           throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
         }
-        logger6.warn("humanClick: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E\uFF0C\u8DF3\u8FC7\u70B9\u51FB");
+        logger5.warn("humanClick: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E\uFF0C\u8DF3\u8FC7\u70B9\u51FB");
         return false;
       }
       const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.3;
@@ -3407,11 +3457,11 @@ var Humanize = {
       await (0, import_delay2.default)(this.jitterMs(reactionDelay, 0.4));
       await cursor.actions.click();
       await restoreOnce();
-      logger6.success("humanClick");
+      logger5.success("humanClick");
       return true;
     } catch (error) {
       await restoreOnce();
-      logger6.fail("humanClick", error);
+      logger5.fail("humanClick", error);
       throw error;
     }
   },
@@ -3422,9 +3472,9 @@ var Humanize = {
    */
   async randomSleep(baseMs, jitterPercent = 0.3) {
     const ms = this.jitterMs(baseMs, jitterPercent);
-    logger6.start("randomSleep", `base=${baseMs}, actual=${ms}ms`);
+    logger5.start("randomSleep", `base=${baseMs}, actual=${ms}ms`);
     await (0, import_delay2.default)(ms);
-    logger6.success("randomSleep");
+    logger5.success("randomSleep");
   },
   /**
    * 模拟人类"注视"或"阅读"行为：鼠标在页面上随机微动
@@ -3434,7 +3484,7 @@ var Humanize = {
   async simulateGaze(page, baseDurationMs = 2500) {
     const cursor = $GetCursor(page);
     const durationMs = this.jitterMs(baseDurationMs, 0.4);
-    logger6.start("simulateGaze", `duration=${durationMs}ms`);
+    logger5.start("simulateGaze", `duration=${durationMs}ms`);
     const startTime = Date.now();
     const viewportSize = page.viewportSize() || { width: 1920, height: 1080 };
     while (Date.now() - startTime < durationMs) {
@@ -3443,7 +3493,7 @@ var Humanize = {
       await cursor.actions.move({ x, y });
       await (0, import_delay2.default)(this.jitterMs(600, 0.5));
     }
-    logger6.success("simulateGaze");
+    logger5.success("simulateGaze");
   },
   /**
    * 人类化输入 - 带节奏变化（快-慢-停顿-偶尔加速）
@@ -3456,7 +3506,7 @@ var Humanize = {
    * @param {number} [options.pauseBase=800] - 停顿时长基础值 (ms)，实际 ±50% 抖动
    */
   async humanType(page, selector, text, options = {}) {
-    logger6.start("humanType", `selector=${selector}, textLen=${text.length}`);
+    logger5.start("humanType", `selector=${selector}, textLen=${text.length}`);
     const {
       baseDelay = 180,
       pauseProbability = 0.08,
@@ -3480,13 +3530,13 @@ var Humanize = {
         await (0, import_delay2.default)(charDelay);
         if (Math.random() < pauseProbability && i < text.length - 1) {
           const pauseTime = this.jitterMs(pauseBase, 0.5);
-          logger6.debug(`\u505C\u987F ${pauseTime}ms...`);
+          logger5.debug(`\u505C\u987F ${pauseTime}ms...`);
           await (0, import_delay2.default)(pauseTime);
         }
       }
-      logger6.success("humanType");
+      logger5.success("humanType");
     } catch (error) {
-      logger6.fail("humanType", error);
+      logger5.fail("humanType", error);
       throw error;
     }
   },
@@ -3510,7 +3560,7 @@ var Humanize = {
       keyboardOptions = {}
     } = pressOptions || {};
     const targetDesc = hasTarget ? typeof targetOrKey === "string" ? targetOrKey : "ElementHandle" : "current focus";
-    logger6.start("humanPress", `key=${key}, target=${targetDesc}`);
+    logger5.start("humanPress", `key=${key}, target=${targetDesc}`);
     try {
       if (hasTarget) {
         await this.humanClick(page, targetOrKey, { reactionDelay: focusDelay, scrollIfNeeded, throwOnMissing });
@@ -3520,10 +3570,10 @@ var Humanize = {
         ...keyboardOptions,
         delay: this.jitterMs(holdDelay, 0.5)
       });
-      logger6.success("humanPress");
+      logger5.success("humanPress");
       return true;
     } catch (error) {
-      logger6.fail("humanPress", error);
+      logger5.fail("humanPress", error);
       throw error;
     }
   },
@@ -3533,22 +3583,22 @@ var Humanize = {
    * @param {string} selector - 输入框选择器
    */
   async humanClear(page, selector) {
-    logger6.start("humanClear", `selector=${selector}`);
+    logger5.start("humanClear", `selector=${selector}`);
     try {
       const locator = page.locator(selector);
       await locator.click();
       await (0, import_delay2.default)(this.jitterMs(200, 0.4));
       const currentValue = await locator.inputValue();
       if (!currentValue || currentValue.length === 0) {
-        logger6.success("humanClear", "already empty");
+        logger5.success("humanClear", "already empty");
         return;
       }
       await page.keyboard.press("Meta+A");
       await (0, import_delay2.default)(this.jitterMs(100, 0.4));
       await page.keyboard.press("Backspace");
-      logger6.success("humanClear");
+      logger5.success("humanClear");
     } catch (error) {
-      logger6.fail("humanClear", error);
+      logger5.fail("humanClear", error);
       throw error;
     }
   },
@@ -3560,7 +3610,7 @@ var Humanize = {
   async warmUpBrowsing(page, baseDuration = 3500) {
     const cursor = $GetCursor(page);
     const durationMs = this.jitterMs(baseDuration, 0.4);
-    logger6.start("warmUpBrowsing", `duration=${durationMs}ms`);
+    logger5.start("warmUpBrowsing", `duration=${durationMs}ms`);
     const startTime = Date.now();
     const viewportSize = page.viewportSize() || { width: 1920, height: 1080 };
     try {
@@ -3579,9 +3629,9 @@ var Humanize = {
           await (0, import_delay2.default)(this.jitterMs(800, 0.5));
         }
       }
-      logger6.success("warmUpBrowsing");
+      logger5.success("warmUpBrowsing");
     } catch (error) {
-      logger6.fail("warmUpBrowsing", error);
+      logger5.fail("warmUpBrowsing", error);
       throw error;
     }
   },
@@ -3595,7 +3645,7 @@ var Humanize = {
   async naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
     const steps = Math.max(3, baseSteps + Math.floor(Math.random() * 3) - 1);
     const actualDistance = this.jitterMs(distance, 0.15);
-    logger6.start("naturalScroll", `dir=${direction}, dist=${actualDistance}, steps=${steps}`);
+    logger5.start("naturalScroll", `dir=${direction}, dist=${actualDistance}, steps=${steps}`);
     const sign = direction === "down" ? 1 : -1;
     const stepDistance = actualDistance / steps;
     try {
@@ -3607,9 +3657,9 @@ var Humanize = {
         const baseDelay = 60 + i * 25;
         await (0, import_delay2.default)(this.jitterMs(baseDelay, 0.3));
       }
-      logger6.success("naturalScroll");
+      logger5.success("naturalScroll");
     } catch (error) {
-      logger6.fail("naturalScroll", error);
+      logger5.fail("naturalScroll", error);
       throw error;
     }
   }
@@ -3638,7 +3688,7 @@ var resolveElement = async (page, target, { throwOnMissing = true } = {}) => {
 var waitJitter = (base, jitterPercent = 0.3) => (0, import_delay3.default)(jitterMs(base, jitterPercent));
 
 // src/internals/humanize/mobile.js
-var logger7 = createInternalLogger("Humanize.Mobile");
+var logger6 = createInternalLogger("Humanize.Mobile");
 var initializedPages = /* @__PURE__ */ new WeakSet();
 var DEFAULT_TAP_TIMEOUT_MS = 2500;
 var DEFAULT_MOUSE_TAP_FALLBACK_TIMEOUT_MS = 1200;
@@ -4095,7 +4145,7 @@ var dispatchTouchSwipe = async (page, deltaY, options = {}) => {
     }
     return true;
   } catch (error) {
-    logger7.debug(`touch swipe fallback: ${error?.message || error}`);
+    logger6.debug(`touch swipe fallback: ${error?.message || error}`);
     try {
       await page.evaluate((amount) => window.scrollBy(0, amount), deltaY);
       await waitJitter(120, 0.35);
@@ -4129,7 +4179,7 @@ var tapPoint = async (page, point, options = {}) => {
       );
       return { method: "touchscreen" };
     } catch (error) {
-      logger7.warn(`tapPoint | touchscreen.tap \u5931\u8D25\u6216\u8D85\u65F6\uFF0C\u5C1D\u8BD5\u9F20\u6807\u515C\u5E95: ${error?.message || error}`);
+      logger6.warn(`tapPoint | touchscreen.tap \u5931\u8D25\u6216\u8D85\u65F6\uFF0C\u5C1D\u8BD5\u9F20\u6807\u515C\u5E95: ${error?.message || error}`);
       if (!allowMouseFallback) throw error;
     }
   }
@@ -4145,10 +4195,10 @@ var MobileHumanize = {
   async initializeCursor(page) {
     if (initializedPages.has(page)) return;
     initializedPages.add(page);
-    logger7.debug("initializeCursor: mobile mode uses touch gestures, cursor init skipped");
+    logger6.debug("initializeCursor: mobile mode uses touch gestures, cursor init skipped");
   },
   async humanMove(page, target) {
-    logger7.debug(`humanMove: mobile no-op target=${typeof target === "string" ? target : "element/coords"}`);
+    logger6.debug(`humanMove: mobile no-op target=${typeof target === "string" ? target : "element/coords"}`);
     if (typeof target === "string" || target && typeof target.boundingBox === "function") {
       const element = await resolveElement(page, target, { throwOnMissing: false });
       if (!element) {
@@ -4167,10 +4217,10 @@ var MobileHumanize = {
       throwOnMissing = false
     } = options;
     const targetDesc = describeTarget(target);
-    logger7.start("humanScroll", `target=${targetDesc}`);
+    logger6.start("humanScroll", `target=${targetDesc}`);
     const element = await resolveElement(page, target, { throwOnMissing });
     if (!element) {
-      logger7.warn(`humanScroll | \u5143\u7D20\u672A\u627E\u5230: ${targetDesc}`);
+      logger6.warn(`humanScroll | \u5143\u7D20\u672A\u627E\u5230: ${targetDesc}`);
       return { element: null, didScroll: false, restore: null };
     }
     const startTime = Date.now();
@@ -4179,42 +4229,42 @@ var MobileHumanize = {
       const status = await checkElementVisibility(element);
       if (status.code === "VISIBLE") {
         if (status.isFixed) {
-          logger7.info("humanScroll | fixed/sticky \u5BB9\u5668\u5185\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
+          logger6.info("humanScroll | fixed/sticky \u5BB9\u5668\u5185\uFF0C\u8DF3\u8FC7\u6EDA\u52A8");
         } else {
-          logger7.debug("humanScroll | \u5143\u7D20\u53EF\u89C1\u4E14\u65E0\u906E\u6321");
+          logger6.debug("humanScroll | \u5143\u7D20\u53EF\u89C1\u4E14\u65E0\u906E\u6321");
         }
-        logger7.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
+        logger6.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
         return { element, didScroll, restore: null };
       }
       if (status.code === "ZERO_DIMENSIONS" || status.code === "NOT_INTERACTABLE") {
-        logger7.warn(`humanScroll | \u5143\u7D20\u4E0D\u53EF\u6EDA\u52A8\u81F3\u53EF\u70B9\u51FB\u72B6\u6001: ${status.reason || status.code}`);
+        logger6.warn(`humanScroll | \u5143\u7D20\u4E0D\u53EF\u6EDA\u52A8\u81F3\u53EF\u70B9\u51FB\u72B6\u6001: ${status.reason || status.code}`);
         return { element, didScroll, restore: null };
       }
       const scrollRect = await getScrollableRect(element);
       if (!scrollRect && status.isFixed && status.code === "OUT_OF_VIEWPORT") {
-        logger7.warn(`humanScroll | fixed/sticky \u76EE\u6807\u4E0D\u5728\u89C6\u53E3\u5185\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (direction=${status.direction || "unknown"})`);
+        logger6.warn(`humanScroll | fixed/sticky \u76EE\u6807\u4E0D\u5728\u89C6\u53E3\u5185\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (direction=${status.direction || "unknown"})`);
         return { element, didScroll, restore: null, unscrollable: true };
       }
       if (!scrollRect && status.isFixed && status.code === "OBSTRUCTED") {
-        logger7.warn(`humanScroll | fixed/sticky \u76EE\u6807\u88AB\u906E\u6321\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u89E3\u9664 (${status.obstruction?.tag || "unknown"})`);
+        logger6.warn(`humanScroll | fixed/sticky \u76EE\u6807\u88AB\u906E\u6321\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u89E3\u9664 (${status.obstruction?.tag || "unknown"})`);
         return { element, didScroll, restore: null, unscrollable: true };
       }
       if (scrollRect && status.code === "OBSTRUCTED" && status.obstruction?.isFixed) {
         const moved = await scrollAwayFromObstruction(element, status);
         if (moved.moved) {
-          logger7.debug(`humanScroll | sticky/fixed \u906E\u6321\u8865\u507F\u6EDA\u52A8 top=${Math.round(moved.scrollTop || 0)}`);
+          logger6.debug(`humanScroll | sticky/fixed \u906E\u6321\u8865\u507F\u6EDA\u52A8 top=${Math.round(moved.scrollTop || 0)}`);
           await waitJitter(90, 0.3);
           didScroll = true;
           continue;
         }
       }
       if (Date.now() - startTime > maxDurationMs) {
-        logger7.warn(`humanScroll | mobile timeout (${maxDurationMs}ms, status=${status.code}, direction=${status.direction || "unknown"}, fixed=${Boolean(status.isFixed)})`);
+        logger6.warn(`humanScroll | mobile timeout (${maxDurationMs}ms, status=${status.code}, direction=${status.direction || "unknown"}, fixed=${Boolean(status.isFixed)})`);
         return { element, didScroll, restore: null };
       }
       const stepMin = scrollRect ? Math.min(minStep, Math.max(60, scrollRect.height * 0.4)) : minStep;
       const stepMax = scrollRect ? Math.min(maxStep, Math.max(stepMin + 40, scrollRect.height * 0.8)) : maxStep;
-      logger7.debug(`humanScroll | \u6B65\u9AA4 ${i + 1}/${maxSteps}: ${status.reason || status.code} ${status.direction ? `(${status.direction})` : ""}`);
+      logger6.debug(`humanScroll | \u6B65\u9AA4 ${i + 1}/${maxSteps}: ${status.reason || status.code} ${status.direction ? `(${status.direction})` : ""}`);
       const distance = stepMin + Math.random() * Math.max(1, stepMax - stepMin);
       let deltaY = status.direction === "up" ? -distance : distance;
       if (status.code === "OBSTRUCTED") {
@@ -4255,7 +4305,7 @@ var MobileHumanize = {
         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);
-          logger7.debug(`humanScroll | \u7A97\u53E3\u6EDA\u52A8\u56DE\u6536 from=${Math.round(afterWindowState.y)} to=${Math.round(beforeWindowState.y)}`);
+          logger6.debug(`humanScroll | \u7A97\u53E3\u6EDA\u52A8\u56DE\u6536 from=${Math.round(afterWindowState.y)} to=${Math.round(beforeWindowState.y)}`);
         }
       }
       let afterElementSnapshot = null;
@@ -4269,7 +4319,7 @@ var MobileHumanize = {
         const afterSnapshot = await readAfterElementSnapshot();
         if (isTargetImmobileAfterScroll(beforeElementSnapshot, afterSnapshot)) {
           await restoreWindowFromSnapshot(page, beforeElementSnapshot, afterSnapshot);
-          logger7.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u9875\u9762\u6EDA\u52A8\u79FB\u52A8\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
+          logger6.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u9875\u9762\u6EDA\u52A8\u79FB\u52A8\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
           return { element, didScroll, restore: null, unscrollable: true };
         }
       }
@@ -4301,12 +4351,12 @@ var MobileHumanize = {
         const moved = beforeState.kind !== afterState.kind || Math.abs(topDelta) > 2 || Math.abs(leftDelta) > 2;
         if (!moved) {
           const fallback = await scrollScrollableAncestor(element, deltaY);
-          logger7.debug(`humanScroll | \u5BB9\u5668\u89E6\u6478\u65E0\u6548\uFF0C\u76F4\u63A5\u6EDA\u52A8 fallback=${fallback.scroller ? "ancestor" : "window"} top=${Math.round(fallback.scrollTop || 0)}`);
+          logger6.debug(`humanScroll | \u5BB9\u5668\u89E6\u6478\u65E0\u6548\uFF0C\u76F4\u63A5\u6EDA\u52A8 fallback=${fallback.scroller ? "ancestor" : "window"} top=${Math.round(fallback.scrollTop || 0)}`);
         } else if (beforeState.kind === afterState.kind && Math.abs(expectedDelta) > 24 && Math.sign(topDelta || expectedDelta) === Math.sign(expectedDelta) && Math.abs(topDelta) < Math.min(Math.abs(expectedDelta) * 0.45, 96)) {
           const residualDelta = expectedDelta - topDelta;
           if (Math.sign(residualDelta) === Math.sign(expectedDelta) && Math.abs(residualDelta) > 24) {
             const fallback = await scrollScrollableAncestor(element, residualDelta);
-            logger7.debug(`humanScroll | \u5BB9\u5668\u89E6\u6478\u8DDD\u79BB\u4E0D\u8DB3\uFF0C\u8865\u507F\u6EDA\u52A8 fallback=${fallback.scroller ? "ancestor" : "window"} top=${Math.round(fallback.scrollTop || 0)}`);
+            logger6.debug(`humanScroll | \u5BB9\u5668\u89E6\u6478\u8DDD\u79BB\u4E0D\u8DB3\uFF0C\u8865\u507F\u6EDA\u52A8 fallback=${fallback.scroller ? "ancestor" : "window"} top=${Math.round(fallback.scrollTop || 0)}`);
           }
         }
       }
@@ -4314,7 +4364,7 @@ var MobileHumanize = {
         const afterSnapshot = await getElementViewportSnapshot(element).catch(() => null);
         if (isTargetImmobileAfterScroll(beforeElementSnapshot, afterSnapshot)) {
           await restoreWindowFromSnapshot(page, beforeElementSnapshot, afterSnapshot);
-          logger7.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u6EDA\u52A8\u5BB9\u5668\u79FB\u52A8\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
+          logger6.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u6EDA\u52A8\u5BB9\u5668\u79FB\u52A8\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
           return { element, didScroll, restore: null, unscrollable: true };
         }
       }
@@ -4325,14 +4375,14 @@ var MobileHumanize = {
       await waitJitter(80, 0.3);
       const finalStatus = await checkElementVisibility(element);
       if (finalStatus.code === "VISIBLE") {
-        logger7.info("humanScroll | \u539F\u751F scrollIntoViewIfNeeded \u515C\u5E95\u6210\u529F");
-        logger7.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
+        logger6.info("humanScroll | \u539F\u751F scrollIntoViewIfNeeded \u515C\u5E95\u6210\u529F");
+        logger6.success("humanScroll", didScroll ? "\u5DF2\u6EDA\u52A8" : "\u65E0\u9700\u6EDA\u52A8");
         return { element, didScroll: true, restore: null };
       }
     } catch (fallbackError) {
-      logger7.debug(`humanScroll | native fallback failed: ${fallbackError?.message || fallbackError}`);
+      logger6.debug(`humanScroll | native fallback failed: ${fallbackError?.message || fallbackError}`);
     }
-    logger7.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
+    logger6.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
     return { element, didScroll, restore: null };
   },
   async humanClick(page, target, options = {}) {
@@ -4347,7 +4397,7 @@ var MobileHumanize = {
       fallbackDomClickOnTapError = true
     } = options;
     const targetDesc = describeTarget(target);
-    logger7.start("humanClick", `target=${targetDesc}`);
+    logger6.start("humanClick", `target=${targetDesc}`);
     try {
       if (target == null) {
         const viewport = resolveViewport(page);
@@ -4359,12 +4409,12 @@ var MobileHumanize = {
           timeoutMs: tapTimeoutMs,
           mouseFallbackTimeoutMs
         });
-        logger7.success("humanClick", "Tapped current position");
+        logger6.success("humanClick", "Tapped current position");
         return true;
       }
       const element = await resolveElement(page, target, { throwOnMissing });
       if (!element) {
-        logger7.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${targetDesc}`);
+        logger6.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${targetDesc}`);
         return false;
       }
       const scrollResult = scrollIfNeeded ? await MobileHumanize.humanScroll(page, element, { throwOnMissing }) : null;
@@ -4388,19 +4438,19 @@ var MobileHumanize = {
             ).catch(() => null);
           }
           if (fallback?.activated) {
-            logger7.warn(`humanClick: \u4E0D\u53EF\u6EDA\u52A8\u76EE\u6807\u4E0D\u53EF\u7269\u7406\u70B9\u51FB\uFF0C\u5DF2\u7528 ${fallback.method} \u6FC0\u6D3B`);
+            logger6.warn(`humanClick: \u4E0D\u53EF\u6EDA\u52A8\u76EE\u6807\u4E0D\u53EF\u7269\u7406\u70B9\u51FB\uFF0C\u5DF2\u7528 ${fallback.method} \u6FC0\u6D3B`);
             return true;
           }
         }
         const message = `\u5143\u7D20\u4E0D\u53EF\u70B9\u51FB: ${status.reason || status.code}`;
         if (throwOnMissing) throw new Error(message);
-        logger7.warn(`humanClick: ${message}\uFF0C\u8DF3\u8FC7\u70B9\u51FB`);
+        logger6.warn(`humanClick: ${message}\uFF0C\u8DF3\u8FC7\u70B9\u51FB`);
         return false;
       }
       const box = await element.boundingBox();
       if (!box) {
         if (throwOnMissing) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
-        logger7.warn("humanClick: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E\uFF0C\u8DF3\u8FC7\u70B9\u51FB");
+        logger6.warn("humanClick: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E\uFF0C\u8DF3\u8FC7\u70B9\u51FB");
         return false;
       }
       await waitJitter(reactionDelay, 0.45);
@@ -4421,13 +4471,13 @@ var MobileHumanize = {
           "activation fallback"
         ).catch(() => null);
         if (!fallback?.activated) throw tapError;
-        logger7.warn(`humanClick: tap \u5931\u8D25\u540E\u5DF2\u7528 ${fallback.method} \u515C\u5E95: ${tapError?.message || tapError}`);
+        logger6.warn(`humanClick: tap \u5931\u8D25\u540E\u5DF2\u7528 ${fallback.method} \u515C\u5E95: ${tapError?.message || tapError}`);
       }
       await waitJitter(120, 0.35);
-      logger7.success("humanClick");
+      logger6.success("humanClick");
       return true;
     } catch (error) {
-      logger7.fail("humanClick", error);
+      logger6.fail("humanClick", error);
       throw error;
     }
   },
@@ -4480,7 +4530,7 @@ var MobileHumanize = {
       keyboardOptions = {}
     } = pressOptions || {};
     const targetDesc = hasTarget ? describeTarget(targetOrKey) : "current focus";
-    logger7.start("humanPress", `key=${key}, target=${targetDesc}`);
+    logger6.start("humanPress", `key=${key}, target=${targetDesc}`);
     try {
       if (hasTarget) {
         await MobileHumanize.humanClick(page, targetOrKey, {
@@ -4494,10 +4544,10 @@ var MobileHumanize = {
         ...keyboardOptions,
         delay: jitterMs(holdDelay, 0.5)
       });
-      logger7.success("humanPress");
+      logger6.success("humanPress");
       return true;
     } catch (error) {
-      logger7.fail("humanPress", error);
+      logger6.fail("humanPress", error);
       throw error;
     }
   },
@@ -4564,7 +4614,7 @@ var MobileHumanize = {
   }
 };
 
-// src/humanize.js
+// src/internals/humanize/default.js
 var resolveDeviceFromPage2 = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
 var resolveDelegate = (page) => {
   return resolveDeviceFromPage2(page) === Device.Mobile ? MobileHumanize : Humanize;
@@ -4573,7 +4623,7 @@ var callDelegate = (method, page, args) => {
   const delegate = resolveDelegate(page);
   return delegate[method](page, ...args);
 };
-var Humanize2 = {
+var DefaultHumanize = {
   jitterMs(base, jitterPercent = 0.3) {
     return Humanize.jitterMs(base, jitterPercent);
   },
@@ -4619,7 +4669,509 @@ var Humanize2 = {
   }
 };
 
-// src/launch.js
+// src/internals/humanize/cloakbrowser.js
+var import_delay4 = __toESM(require("delay"), 1);
+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 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);
+  }
+  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 Object.keys(humanConfig).length > 0 ? humanConfig : null;
+};
+var buildActionOptions = (options = {}) => {
+  const actionOptions = {};
+  if (options && options.timeout != null) {
+    actionOptions.timeout = options.timeout;
+  }
+  if (options && options.force != null) {
+    actionOptions.force = options.force;
+  }
+  const humanConfig = buildTypingHumanConfig(options);
+  if (humanConfig) {
+    actionOptions.human_config = humanConfig;
+  }
+  return actionOptions;
+};
+var getErrorMessage = (error) => {
+  if (typeof error === "string") return error;
+  if (error && typeof error.message === "string") return error.message;
+  return String(error ?? "");
+};
+var isPointerEventsCoveredError = (error) => {
+  const message = getErrorMessage(error).toLowerCase();
+  return message.includes("pointer_events") && (message.includes("covered by") || message.includes("receiving events"));
+};
+var withPointerEventsForceFallback = async (label, options, operation) => {
+  try {
+    return await operation(options);
+  } catch (error) {
+    if (options?.force || !isPointerEventsCoveredError(error)) {
+      throw error;
+    }
+    logger7.warn(`${label}: cloakbrowser pointer_events check failed, retrying with force=true (${getErrorMessage(error)})`);
+    return await operation({
+      ...options || {},
+      force: true
+    });
+  }
+};
+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;
+};
+var resolvePatchedTarget = async (page, target, { throwOnMissing = true } = {}) => {
+  if (target == null) {
+    return { target: null, dispose: null };
+  }
+  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 (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 };
+};
+var jitterSleep = async (baseMs, jitterPercent = 0.3) => {
+  await (0, import_delay4.default)(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);
+  return await withPointerEventsForceFallback("humanClick", options, async (effectiveOptions = {}) => {
+    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 = effectiveOptions.throwOnMissing !== false;
+    if (typeof target === "string") {
+      if (!throwOnMissing) {
+        const existingHandle = await page.$(target);
+        if (!existingHandle) {
+          return false;
+        }
+        await existingHandle.click(buildActionOptions(effectiveOptions));
+        return true;
+      }
+      await page.click(target, buildActionOptions(effectiveOptions));
+      return true;
+    }
+    const { target: resolvedTarget, dispose } = await resolvePatchedTarget(page, target, { throwOnMissing });
+    try {
+      if (!resolvedTarget) {
+        return false;
+      }
+      if (typeof resolvedTarget.click === "function") {
+        await resolvedTarget.click(buildActionOptions(effectiveOptions));
+        return true;
+      }
+      const box = await resolvedTarget.boundingBox?.();
+      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);
+      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);
+    }
+    await ensureDesktopHumanized(page);
+    logger7.debug("initializeCursor: cloakbrowser human layer ready");
+  },
+  async humanMove(page, target) {
+    if (isMobilePage(page)) {
+      return await MobileHumanize.humanMove(page, target);
+    }
+    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();
+        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);
+      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 };
+      }
+    }
+    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();
+      }
+    }
+  },
+  async humanClick(page, target, options = {}) {
+    if (isMobilePage(page)) {
+      return await MobileHumanize.humanClick(page, target, options);
+    }
+    return await doDesktopHumanClick(page, target, options);
+  },
+  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 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) {
+      await page.mouse.move(
+        100 + Math.random() * Math.max(120, viewportSize.width - 200),
+        100 + Math.random() * Math.max(120, viewportSize.height - 200)
+      );
+      await jitterSleep(600, 0.5);
+    }
+  },
+  async humanType(page, selector, text, options = {}) {
+    if (isMobilePage(page)) {
+      return await MobileHumanize.humanType(page, selector, text, options);
+    }
+    await ensureDesktopHumanized(page);
+    await withPointerEventsForceFallback("humanType", options, async (effectiveOptions = {}) => {
+      const actionOptions = buildActionOptions(effectiveOptions);
+      if (typeof selector === "string") {
+        await page.type(selector, text, actionOptions);
+        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();
+        }
+      }
+    });
+  },
+  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)
+      });
+      return true;
+    }
+    return await withPointerEventsForceFallback("humanPress", pressOptions, async (effectiveOptions = {}) => {
+      if (typeof targetOrKey === "string") {
+        await page.press(targetOrKey, key, buildActionOptions(effectiveOptions));
+        return true;
+      }
+      const { target: resolvedTarget, dispose } = await resolvePatchedTarget(page, targetOrKey, {
+        throwOnMissing: effectiveOptions.throwOnMissing !== false
+      });
+      try {
+        if (!resolvedTarget) {
+          return false;
+        }
+        if (typeof resolvedTarget.press === "function") {
+          await resolvedTarget.press(key, buildActionOptions(effectiveOptions));
+          return true;
+        }
+        await doDesktopHumanClick(page, targetOrKey, {
+          ...effectiveOptions,
+          reactionDelay: effectiveOptions.focusDelay ?? 180
+        });
+        await jitterSleep(effectiveOptions.reactionDelay ?? 180, 0.45);
+        await page.keyboard.press(key, {
+          ...effectiveOptions.keyboardOptions || {},
+          delay: jitterMs(effectiveOptions.holdDelay ?? 45, 0.5)
+        });
+        return true;
+      } finally {
+        if (typeof dispose === "function") {
+          await dispose();
+        }
+      }
+    });
+  },
+  async humanClear(page, selector) {
+    if (isMobilePage(page)) {
+      return await MobileHumanize.humanClear(page, selector);
+    }
+    await ensureDesktopHumanized(page);
+    if (typeof page.clear === "function") {
+      await page.clear(selector);
+      return;
+    }
+    await page.fill(selector, "");
+  },
+  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);
+    }
+  },
+  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 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);
+    }
+  }
+};
+
+// 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 Humanize2 = {
+  jitterMs(base, jitterPercent = 0.3) {
+    return callHumanize("jitterMs", base, jitterPercent);
+  },
+  initializeCursor(page) {
+    return callHumanize("initializeCursor", page);
+  },
+  humanMove(page, target) {
+    return callHumanize("humanMove", page, target);
+  },
+  humanScroll(page, target, options = {}) {
+    return callHumanize("humanScroll", page, target, options);
+  },
+  humanClick(page, target, options = {}) {
+    return callHumanize("humanClick", page, target, options);
+  },
+  randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
+    return callHumanize("randomSleep", pageOrBaseMs, maybeBaseMs, maybeJitterPercent);
+  },
+  simulateGaze(page, baseDurationMs = 2500) {
+    return callHumanize("simulateGaze", page, baseDurationMs);
+  },
+  humanType(page, selector, text, options = {}) {
+    return callHumanize("humanType", page, selector, text, options);
+  },
+  humanPress(page, targetOrKey, maybeKey, options = {}) {
+    if (typeof maybeKey === "string") {
+      return callHumanize("humanPress", page, targetOrKey, maybeKey, options);
+    }
+    return callHumanize("humanPress", page, targetOrKey, maybeKey || options);
+  },
+  humanClear(page, selector) {
+    return callHumanize("humanClear", page, selector);
+  },
+  warmUpBrowsing(page, baseDuration = 3500) {
+    return callHumanize("warmUpBrowsing", page, baseDuration);
+  },
+  naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
+    return callHumanize("naturalScroll", page, direction, distance, baseSteps);
+  }
+};
+
+// src/internals/launch/default.js
 var import_node_child_process = require("node:child_process");
 var import_fingerprint_generator = require("fingerprint-generator");
 var import_fingerprint_injector = require("fingerprint-injector");
@@ -4704,7 +5256,7 @@ var ByPass = {
   resolveRouteByProxy
 };
 
-// src/launch.js
+// src/internals/launch/default.js
 var logger8 = createInternalLogger("Launch");
 var REQUEST_HOOK_FLAG = Symbol("playwright-toolkit-request-hook");
 var injectedContexts = /* @__PURE__ */ new WeakSet();
@@ -4771,7 +5323,7 @@ var resolveCoreDevice = (core = {}) => {
 };
 var buildFingerprintGenerator = ({ locale, browserMajorVersion, device }) => {
   return new import_fingerprint_generator.FingerprintGenerator(
-    AntiCheat.getFingerprintGeneratorOptions({
+    DefaultAntiCheat.getFingerprintGeneratorOptions({
       locale,
       browserMajorVersion,
       device
@@ -4815,7 +5367,7 @@ var buildReplayableBrowserProfile = (runtimeState, launcher) => {
   }
   let nextState = RuntimeEnv.rememberState(runtimeState);
   let browserProfileCore = RuntimeEnv.getBrowserProfileCore(nextState);
-  const timezoneId = String(browserProfileCore?.timezone_id || "").trim() || AntiCheat.getBaseConfig().timezoneId;
+  const timezoneId = String(browserProfileCore?.timezone_id || "").trim() || DefaultAntiCheat.getBaseConfig().timezoneId;
   const locale = DEFAULT_LOCALE;
   const currentBrowserMajorVersion = detectBrowserMajorVersion(launcher);
   const storedBrowserMajorVersion = Number(browserProfileCore?.browser_major_version || 0);
@@ -4924,7 +5476,7 @@ var buildReplayBrowserPoolOptions = (browserProfileCore) => {
     ]
   };
 };
-var Launch = {
+var DefaultLaunch = {
   getPlaywrightCrawlerOptions(options = {}) {
     const normalizedOptions = Array.isArray(options) ? { customArgs: options } : options || {};
     const {
@@ -4952,7 +5504,7 @@ var Launch = {
     const launchLocale = String(replayContext.browserProfileCore?.locale || DEFAULT_LOCALE).trim() || DEFAULT_LOCALE;
     const launchOptions = {
       args: [
-        ...AntiCheat.getLaunchArgs({ locale: launchLocale }),
+        ...DefaultAntiCheat.getLaunchArgs({ locale: launchLocale }),
         ...customArgs
       ],
       ignoreDefaultArgs: ["--enable-automation"]
@@ -5020,7 +5572,7 @@ var Launch = {
       browserPoolOptions: replayBrowserPoolOptions || {
         useFingerprints: true,
         fingerprintOptions: {
-          fingerprintGeneratorOptions: AntiCheat.getFingerprintGeneratorOptions({
+          fingerprintGeneratorOptions: DefaultAntiCheat.getFingerprintGeneratorOptions({
             locale: launchLocale,
             device
           })
@@ -5028,7 +5580,7 @@ var Launch = {
         prePageCreateHooks: [
           (_pageId, browserController, pageOptions = {}) => {
             const fingerprintWithHeaders = browserController?.launchContext?.fingerprint;
-            const timezoneId = AntiCheat.getBaseConfig().timezoneId;
+            const timezoneId = DefaultAntiCheat.getBaseConfig().timezoneId;
             applyFingerprintPageOptions(pageOptions, {
               fingerprintWithHeaders,
               locale: launchLocale,
@@ -5055,7 +5607,7 @@ var Launch = {
   }
 };
 
-// src/cloakbrowser.js
+// src/internals/launch/cloakbrowser.js
 var import_node_child_process2 = require("node:child_process");
 var import_node_util = require("node:util");
 var logger9 = createInternalLogger("CloakBrowser");
@@ -5197,7 +5749,7 @@ var forceTerminateBrowsersByFingerprintArg = async (fingerprintArg) => {
     logger9.info(`\u5F3A\u5236\u5173\u95ED CloakBrowser \u8FDB\u7A0B\u5931\u8D25\uFF08\u5FFD\u7565\uFF09: ${error?.message || String(error)}`);
   });
 };
-var CloakBrowser = {
+var CloakBrowserLaunch = {
   resolveProxyConfiguration(proxyConfiguration = {}) {
     return resolveCloakBrowserProxy(proxyConfiguration);
   },
@@ -5207,6 +5759,10 @@ var CloakBrowser = {
   createStableGotoHook(recommendedGotoOptions = DEFAULT_CLOAK_GOTO_OPTIONS) {
     return createStableGotoHook(recommendedGotoOptions);
   },
+  async getPlaywrightCrawlerOptions(options = {}) {
+    const { crawlerOptions } = await CloakBrowserLaunch.createPlaywrightCrawlerRuntime(options);
+    return crawlerOptions;
+  },
   async buildLaunchOptions(options = {}) {
     return await buildCloakLaunchOptions(options);
   },
@@ -5284,26 +5840,35 @@ var CloakBrowser = {
     };
   }
 };
-var createCloakLaunchModule = (baseLaunch = {}) => {
-  const normalizedBaseLaunch = normalizeObject(baseLaunch);
-  return {
-    ...normalizedBaseLaunch,
-    resolveProxyConfiguration(proxyConfiguration = {}) {
-      return CloakBrowser.resolveProxyConfiguration(proxyConfiguration);
-    },
-    extractFingerprintArg(launchOptions = {}) {
-      return CloakBrowser.extractFingerprintArg(launchOptions);
-    },
-    createStableGotoHook(recommendedGotoOptions = DEFAULT_CLOAK_GOTO_OPTIONS) {
-      return CloakBrowser.createStableGotoHook(recommendedGotoOptions);
-    },
-    async buildLaunchOptions(options = {}) {
-      return await CloakBrowser.buildLaunchOptions(options);
-    },
-    async createPlaywrightCrawlerRuntime(options = {}) {
-      return await CloakBrowser.createPlaywrightCrawlerRuntime(options);
-    }
-  };
+
+// 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);
+  }
 };
 
 // src/live-view.js
@@ -7673,7 +8238,7 @@ var Logger = {
 };
 
 // src/share.js
-var import_delay4 = __toESM(require("delay"), 1);
+var import_delay5 = __toESM(require("delay"), 1);
 
 // src/internals/watermarkify.js
 var DEFAULT_TIMEZONE_OFFSET = 8;
@@ -9744,7 +10309,7 @@ var Share = {
           );
           nextProgressLogTs = now + 5e3;
         }
-        await (0, import_delay4.default)(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
+        await (0, import_delay5.default)(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
       }
       if (!timeoutDisabled && share.mode === "response" && stats.responseMatched === 0) {
         logger16.warning(
@@ -9810,14 +10375,14 @@ var Share = {
 // entrys/node.js
 Logger.setLogger(import_crawlee.log);
 var usePlaywrightToolKit = (mode = "default") => {
-  const launchModule = mode === "cloakbrowser" ? createCloakLaunchModule(Launch) : Launch;
+  setToolkitMode(mode);
   const toolkit = {
     ApifyKit,
     AntiCheat,
     DeviceInput,
     DeviceView,
     Humanize: Humanize2,
-    Launch: launchModule,
+    Launch,
     LiveView,
     Constants: constants_exports,
     Utils,