@skrillex1224/playwright-toolkit 2.1.170 → 2.1.180

package/dist/index.cjs

@@ -335,18 +335,18 @@ var fallbackLog = {
   error: (...args) => console.error(...args),
   debug: (...args) => console.debug ? console.debug(...args) : console.log(...args)
 };
-var resolveLogMethod = (logger13, name) => {
-  if (logger13 && typeof logger13[name] === "function") {
-    return logger13[name].bind(logger13);
+var resolveLogMethod = (logger12, name) => {
+  if (logger12 && typeof logger12[name] === "function") {
+    return logger12[name].bind(logger12);
   }
-  if (name === "warning" && logger13 && typeof logger13.warn === "function") {
-    return logger13.warn.bind(logger13);
+  if (name === "warning" && logger12 && typeof logger12.warn === "function") {
+    return logger12.warn.bind(logger12);
   }
   return fallbackLog[name];
 };
 var defaultLogger = null;
-var setDefaultLogger = (logger13) => {
-  defaultLogger = logger13;
+var setDefaultLogger = (logger12) => {
+  defaultLogger = logger12;
 };
 var resolveLogger = (explicitLogger) => {
   if (explicitLogger && typeof explicitLogger.info === "function") {
@@ -373,8 +373,8 @@ var colorize = (text, color) => {
 var createBaseLogger = (prefix = "", explicitLogger) => {
   const name = prefix ? String(prefix) : "";
   const dispatch = (methodName, icon, message, color) => {
-    const logger13 = resolveLogger(explicitLogger);
-    const logFn = resolveLogMethod(logger13, methodName);
+    const logger12 = resolveLogger(explicitLogger);
+    const logFn = resolveLogMethod(logger12, methodName);
     const timestamp = colorize(`[${formatTimestamp()}]`, ANSI.gray);
     const line = formatLine(name, icon, message);
     const coloredLine = colorize(line, color);
@@ -573,7 +573,7 @@ var CrawlerError = class _CrawlerError extends Error {
 // src/apify-kit.js
 var import_serialize_error2 = require("serialize-error");
 
-// src/proxy-meter-runtime.js
+// src/internals/proxy-meter-runtime.js
 var import_child_process = require("child_process");
 var import_fs = require("fs");
 var import_os = require("os");
@@ -643,6 +643,10 @@ var resolveResourceTypeMeta = (domain) => {
 };
 var resolveScriptPath = () => {
   const baseDir = typeof __dirname !== "undefined" ? __dirname : import_path.default.dirname((0, import_url.fileURLToPath)(import_meta.url));
+  const internalCandidate = import_path.default.join(baseDir, "internals", "proxy-meter.js");
+  if ((0, import_fs.existsSync)(internalCandidate)) {
+    return internalCandidate;
+  }
   return import_path.default.join(baseDir, "proxy-meter.js");
 };
 var pickFreePort = () => {
@@ -926,9 +930,589 @@ var getProxyMeterSnapshot = async (options = {}) => {
   }
   return snapshot;
 };
+var ProxyMeterRuntime = {
+  startProxyMeter,
+  recordProxyMeterResourceType,
+  stopProxyMeter,
+  getProxyMeterSnapshot
+};
+
+// src/runtime-env.js
+var BROWSER_PROFILE_SCHEMA_VERSION = 1;
+var rememberedRuntimeState = null;
+var isPlainObject = (value) => value && typeof value === "object" && !Array.isArray(value);
+var deepClone = (value) => {
+  if (value == null) return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+};
+var tryParseJSON = (value) => {
+  if (value == null) return null;
+  if (typeof value === "object") return value;
+  const raw = String(value || "").trim();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var normalizeLocalStorage = (value) => {
+  const source = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  return Object.entries(source).reduce((acc, [key, item]) => {
+    const safeKey = String(key || "").trim();
+    const safeValue = String(item ?? "").trim();
+    if (!safeKey || !safeValue || safeValue === "<nil>") return acc;
+    acc[safeKey] = safeValue;
+    return acc;
+  }, {});
+};
+var normalizeSessionStorage = (value) => {
+  const source = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  return Object.entries(source).reduce((acc, [key, item]) => {
+    const safeKey = String(key || "").trim();
+    const safeValue = String(item ?? "").trim();
+    if (!safeKey || !safeValue || safeValue === "<nil>") return acc;
+    acc[safeKey] = safeValue;
+    return acc;
+  }, {});
+};
+var normalizeAuth = (value) => {
+  const source = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  return Object.entries(source).reduce((acc, [key, item]) => {
+    const safeKey = String(key || "").trim();
+    const safeValue = String(item ?? "").trim();
+    if (!safeKey || !safeValue || safeValue === "<nil>") return acc;
+    acc[safeKey] = safeValue;
+    return acc;
+  }, {});
+};
+var normalizeCookies = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    const raw = item && typeof item === "object" ? item : {};
+    const name = String(raw.name || "").trim();
+    const cookieValue = String(raw.value ?? "").trim();
+    if (!name || !cookieValue || cookieValue === "<nil>") return null;
+    const domain = String(raw.domain || "").trim();
+    const path2 = String(raw.path || "").trim() || "/";
+    const sameSiteRaw = String(raw.sameSite || "").trim();
+    return {
+      ...raw,
+      name,
+      value: cookieValue,
+      domain,
+      path: path2,
+      ...sameSiteRaw ? { sameSite: sameSiteRaw } : {}
+    };
+  }).filter(Boolean);
+};
+var buildCookieMap = (cookies) => cookies.reduce((acc, item) => {
+  acc[item.name] = item.value;
+  return acc;
+}, {});
+var normalizeObservedBrowserProfile = (value) => {
+  const source = isPlainObject(value) ? value : {};
+  const profile = {};
+  const stringFields = {
+    user_agent: source.user_agent,
+    platform: source.platform,
+    language: source.language,
+    timezone: source.timezone
+  };
+  Object.entries(stringFields).forEach(([key, item]) => {
+    const safeValue = String(item || "").trim();
+    if (safeValue) {
+      profile[key] = safeValue;
+    }
+  });
+  if (Array.isArray(source.languages)) {
+    const languages = source.languages.map((item) => String(item || "").trim()).filter(Boolean);
+    if (languages.length > 0) {
+      profile.languages = languages;
+    }
+  }
+  const numericFields = {
+    hardware_concurrency: Number(source.hardware_concurrency || 0),
+    device_memory: Number(source.device_memory || 0)
+  };
+  Object.entries(numericFields).forEach(([key, item]) => {
+    if (Number.isFinite(item) && item > 0) {
+      profile[key] = item;
+    }
+  });
+  if (isPlainObject(source.viewport)) {
+    const width = Number(source.viewport.width || 0);
+    const height = Number(source.viewport.height || 0);
+    if (width > 0 && height > 0) {
+      profile.viewport = { width, height };
+    }
+  }
+  if (isPlainObject(source.screen)) {
+    const screenProfile = {};
+    const screenFields = {
+      width: Number(source.screen.width || 0),
+      height: Number(source.screen.height || 0),
+      avail_width: Number(source.screen.avail_width || 0),
+      avail_height: Number(source.screen.avail_height || 0),
+      color_depth: Number(source.screen.color_depth || 0),
+      pixel_depth: Number(source.screen.pixel_depth || 0)
+    };
+    Object.entries(screenFields).forEach(([key, item]) => {
+      if (Number.isFinite(item) && item > 0) {
+        screenProfile[key] = item;
+      }
+    });
+    if (Object.keys(screenProfile).length > 0) {
+      profile.screen = screenProfile;
+    }
+  }
+  return profile;
+};
+var normalizeBrowserProfileCore = (value) => {
+  const source = isPlainObject(value) ? value : {};
+  const profile = {};
+  if (isPlainObject(source.fingerprint) && Object.keys(source.fingerprint).length > 0) {
+    profile.fingerprint = deepClone(source.fingerprint);
+  }
+  const timezoneId = String(source.timezone_id || "").trim();
+  if (timezoneId) {
+    profile.timezone_id = timezoneId;
+  }
+  const locale = String(source.locale || "").trim();
+  if (locale) {
+    profile.locale = locale;
+  }
+  const profileKey = String(source.profile_key || "").trim();
+  if (profileKey) {
+    profile.profile_key = profileKey;
+  }
+  const browserMajorVersion = Number(source.browser_major_version || 0);
+  if (Number.isFinite(browserMajorVersion) && browserMajorVersion > 0) {
+    profile.browser_major_version = browserMajorVersion;
+  }
+  const schemaVersion = Number(source.schema_version || 0);
+  if (Number.isFinite(schemaVersion) && schemaVersion > 0) {
+    profile.schema_version = schemaVersion;
+  } else if (Object.keys(profile).length > 0) {
+    profile.schema_version = BROWSER_PROFILE_SCHEMA_VERSION;
+  }
+  return profile;
+};
+var buildBrowserProfilePayload = (core = {}, observed = {}) => {
+  const payload = {};
+  if (isPlainObject(core) && Object.keys(core).length > 0) {
+    payload.core = core;
+  }
+  if (isPlainObject(observed) && Object.keys(observed).length > 0) {
+    payload.observed = observed;
+  }
+  return payload;
+};
+var mergePlainObject = (target = {}, source = {}) => {
+  const next = isPlainObject(target) ? deepClone(target) : {};
+  if (!isPlainObject(source)) return next;
+  Object.entries(source).forEach(([key, value]) => {
+    if (!key) return;
+    if (isPlainObject(value) && isPlainObject(next[key])) {
+      next[key] = mergePlainObject(next[key], value);
+      return;
+    }
+    next[key] = deepClone(value);
+  });
+  return next;
+};
+var mergeBrowserProfilePayload = (target = {}, source = {}) => {
+  const current = isPlainObject(target) ? target : {};
+  const incoming = isPlainObject(source) ? source : {};
+  const currentCore = normalizeBrowserProfileCore(current.core);
+  const incomingCore = normalizeBrowserProfileCore(incoming.core);
+  const currentObserved = normalizeObservedBrowserProfile(current.observed);
+  const incomingObserved = normalizeObservedBrowserProfile(incoming.observed);
+  let mergedCore = currentCore;
+  if (Object.keys(mergedCore).length === 0 && Object.keys(incomingCore).length > 0) {
+    mergedCore = incomingCore;
+  } else if (Object.keys(incomingCore).length > 0) {
+    const currentVersion = Number(currentCore.browser_major_version || 0);
+    const incomingVersion = Number(incomingCore.browser_major_version || 0);
+    if (currentVersion > 0 && incomingVersion > 0 && currentVersion !== incomingVersion) {
+      mergedCore = incomingCore;
+    }
+  }
+  const mergedObserved = mergePlainObject(currentObserved, incomingObserved);
+  return buildBrowserProfilePayload(mergedCore, mergedObserved);
+};
+var mergeEnvPatchObjects = (...patches) => {
+  const merged = {};
+  patches.forEach((patch) => {
+    if (!isPlainObject(patch)) return;
+    Object.entries(patch).forEach(([key, value]) => {
+      if (!key) return;
+      if (key === "browser_profile") {
+        const browserProfile = mergeBrowserProfilePayload(merged.browser_profile, value);
+        if (Object.keys(browserProfile).length > 0) {
+          merged.browser_profile = browserProfile;
+        }
+        return;
+      }
+      if (isPlainObject(value) && isPlainObject(merged[key])) {
+        merged[key] = mergePlainObject(merged[key], value);
+        return;
+      }
+      merged[key] = deepClone(value);
+    });
+  });
+  return Object.keys(merged).length > 0 ? merged : null;
+};
+var normalizeBrowserProfile = (value) => {
+  const source = isPlainObject(value) ? value : {};
+  const coreSource = isPlainObject(source.core) ? source.core : {};
+  const observedSource = isPlainObject(source.observed) ? source.observed : {};
+  const core = normalizeBrowserProfileCore(coreSource);
+  const observed = normalizeObservedBrowserProfile(observedSource);
+  return {
+    core,
+    observed,
+    payload: buildBrowserProfilePayload(core, observed)
+  };
+};
+var rememberRuntimeState = (state) => {
+  rememberedRuntimeState = deepClone(state);
+  return rememberedRuntimeState;
+};
+var normalizeRuntimeState = (source = {}, actor = "") => {
+  if (source && typeof source === "object" && source.runtime && typeof source.runtime === "object" && !Array.isArray(source.runtime) && Object.prototype.hasOwnProperty.call(source, "browserProfileCore")) {
+    return source;
+  }
+  return RuntimeEnv.parseInput(source, actor);
+};
+var RuntimeEnv = {
+  tryParseJSON,
+  normalizeCookies,
+  normalizeLocalStorage,
+  normalizeSessionStorage,
+  normalizeAuth,
+  normalizeBrowserProfileCore,
+  normalizeObservedBrowserProfile,
+  mergeEnvPatches(...patches) {
+    return mergeEnvPatchObjects(...patches);
+  },
+  // parseInput 把 Actor 输入里的 runtime 字段标准化成 toolkit 内部统一结构。
+  // 后续 visitor 只和这个 state 交互，不再自己拼 token/cookie 逻辑。
+  parseInput(input = {}, actor = "") {
+    const runtime2 = tryParseJSON(input?.runtime) || {};
+    const resolvedActor = String(actor || input?.actor || "").trim();
+    const cookies = normalizeCookies(runtime2?.cookies);
+    const cookieMap = buildCookieMap(cookies);
+    const localStorage = normalizeLocalStorage(runtime2?.local_storage);
+    const sessionStorage = normalizeSessionStorage(runtime2?.session_storage);
+    const auth = normalizeAuth(runtime2?.auth);
+    const browserProfile = normalizeBrowserProfile(runtime2?.browser_profile);
+    const envId = String(input?.env_id || "").trim();
+    const normalizedRuntime = {
+      ...runtime2,
+      ...cookies.length > 0 ? { cookies } : {},
+      ...Object.keys(localStorage).length > 0 ? { local_storage: localStorage } : {},
+      ...Object.keys(sessionStorage).length > 0 ? { session_storage: sessionStorage } : {},
+      ...Object.keys(auth).length > 0 ? { auth } : {}
+    };
+    delete normalizedRuntime.actor;
+    delete normalizedRuntime.env_id;
+    if (Object.keys(browserProfile.payload).length > 0) {
+      normalizedRuntime.browser_profile = browserProfile.payload;
+    } else {
+      delete normalizedRuntime.browser_profile;
+    }
+    const state = {
+      actor: resolvedActor,
+      runtime: normalizedRuntime,
+      envId,
+      auth,
+      cookies,
+      cookieMap,
+      localStorage,
+      sessionStorage,
+      browserProfile: browserProfile.payload,
+      browserProfileCore: browserProfile.core,
+      browserProfileObserved: browserProfile.observed
+    };
+    rememberRuntimeState(state);
+    return state;
+  },
+  // buildEnvPatch 只构造允许回写到后端 env 的字段集合。
+  buildEnvPatch(source = {}, actor = "") {
+    const state = normalizeRuntimeState(source, actor);
+    const browserProfile = buildBrowserProfilePayload(state.browserProfileCore, state.browserProfileObserved);
+    const envPatch = {
+      ...Object.keys(state.auth || {}).length > 0 ? { auth: state.auth } : {},
+      ...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 } : {},
+      ...Object.keys(browserProfile).length > 0 ? { browser_profile: browserProfile } : {}
+    };
+    return Object.keys(envPatch).length > 0 ? envPatch : null;
+  },
+  // hasLoginState 用来区分“必须鉴权的平台”和“可匿名运行的平台”。
+  hasLoginState(source = {}, actor = "") {
+    const state = normalizeRuntimeState(source, actor);
+    return Array.isArray(state.cookies) && state.cookies.length > 0 || Object.keys(state.localStorage || {}).length > 0 || Object.keys(state.sessionStorage || {}).length > 0 || Object.keys(state.auth || {}).length > 0;
+  },
+  getAuthValue(source = {}, key = "", actor = "") {
+    const state = normalizeRuntimeState(source, actor);
+    const safeKey = String(key || "").trim();
+    if (!safeKey) return "";
+    return String(state.auth?.[safeKey] ?? "").trim();
+  },
+  rememberState(source = {}) {
+    const state = normalizeRuntimeState(source);
+    rememberRuntimeState(state);
+    return RuntimeEnv.peekRememberedState();
+  },
+  peekRememberedState() {
+    return rememberedRuntimeState ? deepClone(rememberedRuntimeState) : null;
+  },
+  getBrowserProfileCore(source = {}, actor = "") {
+    const state = normalizeRuntimeState(source, actor);
+    return deepClone(state.browserProfileCore || {});
+  },
+  setBrowserProfileCore(source = {}, core = {}, actor = "") {
+    const state = normalizeRuntimeState(source, actor);
+    const normalizedCore = normalizeBrowserProfileCore(core);
+    state.browserProfileCore = normalizedCore;
+    state.browserProfile = buildBrowserProfilePayload(normalizedCore, state.browserProfileObserved);
+    if (Object.keys(state.browserProfile).length > 0) {
+      state.runtime.browser_profile = state.browserProfile;
+    } else {
+      delete state.runtime.browser_profile;
+    }
+    rememberRuntimeState(state);
+    return state;
+  },
+  // applyToPage 只负责把登录态相关字段注入页面：
+  // cookies / localStorage / sessionStorage。
+  // 指纹、时区、UA、viewport 的回放发生在 launch.js 启动阶段，不在这里做。
+  async applyToPage(page, source = {}, options = {}) {
+    if (!page) return;
+    const state = normalizeRuntimeState(source, options?.actor || "");
+    const localStorage = state.localStorage || {};
+    const sessionStorage = state.sessionStorage || {};
+    const cookies = (state.cookies || []).map((cookie) => {
+      const normalized = { ...cookie };
+      if (!normalized.path) {
+        normalized.path = "/";
+      }
+      if (!normalized.domain) {
+        return null;
+      }
+      return normalized;
+    }).filter(Boolean);
+    if (cookies.length > 0) {
+      await page.context().addCookies(cookies);
+    }
+    if (Object.keys(localStorage).length > 0) {
+      await page.addInitScript((payload) => {
+        try {
+          Object.entries(payload || {}).forEach(([key, value]) => {
+            if (!key) return;
+            window.localStorage.setItem(key, String(value ?? ""));
+          });
+        } catch (error) {
+        }
+      }, localStorage);
+    }
+    if (Object.keys(sessionStorage).length > 0) {
+      await page.addInitScript((payload) => {
+        try {
+          Object.entries(payload || {}).forEach(([key, value]) => {
+            if (!key) return;
+            window.sessionStorage.setItem(key, String(value ?? ""));
+          });
+        } catch (error) {
+        }
+      }, sessionStorage);
+    }
+  },
+  // captureEnvPatch 在任务结束时采集最新环境快照，用于 pushSuccess / pushFailed 自动回写。
+  async captureEnvPatch(page, source = {}, options = {}) {
+    const state = normalizeRuntimeState(source, options?.actor || "");
+    const baseline = RuntimeEnv.buildEnvPatch(state) || {};
+    const patch = {
+      ...baseline
+    };
+    if (!page || typeof page.evaluate !== "function" || typeof page.context !== "function") {
+      return Object.keys(patch).length > 0 ? patch : null;
+    }
+    try {
+      const contextCookies = await page.context().cookies();
+      const normalizedCookies = normalizeCookies(contextCookies || []);
+      if (normalizedCookies.length > 0) {
+        patch.cookies = normalizedCookies;
+      }
+    } catch (error) {
+    }
+    try {
+      const snapshot = await page.evaluate(() => {
+        const localStorage2 = {};
+        const sessionStorage2 = {};
+        try {
+          for (let i = 0; i < window.localStorage.length; i += 1) {
+            const key = window.localStorage.key(i);
+            if (!key) continue;
+            const value = window.localStorage.getItem(key);
+            if (value !== null) localStorage2[key] = value;
+          }
+        } catch (error) {
+        }
+        try {
+          for (let i = 0; i < window.sessionStorage.length; i += 1) {
+            const key = window.sessionStorage.key(i);
+            if (!key) continue;
+            const value = window.sessionStorage.getItem(key);
+            if (value !== null) sessionStorage2[key] = value;
+          }
+        } catch (error) {
+        }
+        const nav = window.navigator || {};
+        const screen = window.screen || {};
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "";
+        return {
+          localStorage: localStorage2,
+          sessionStorage: sessionStorage2,
+          browserProfileObserved: {
+            user_agent: nav.userAgent || "",
+            platform: nav.platform || "",
+            language: nav.language || "",
+            languages: Array.isArray(nav.languages) ? nav.languages : [],
+            hardware_concurrency: Number(nav.hardwareConcurrency || 0),
+            device_memory: Number(nav.deviceMemory || 0),
+            timezone,
+            viewport: {
+              width: Number(window.innerWidth || 0),
+              height: Number(window.innerHeight || 0)
+            },
+            screen: {
+              width: Number(screen.width || 0),
+              height: Number(screen.height || 0),
+              avail_width: Number(screen.availWidth || 0),
+              avail_height: Number(screen.availHeight || 0),
+              color_depth: Number(screen.colorDepth || 0),
+              pixel_depth: Number(screen.pixelDepth || 0)
+            }
+          }
+        };
+      });
+      const localStorage = normalizeLocalStorage(snapshot?.localStorage);
+      if (Object.keys(localStorage).length > 0) {
+        patch.local_storage = localStorage;
+      }
+      const sessionStorage = normalizeSessionStorage(snapshot?.sessionStorage);
+      if (Object.keys(sessionStorage).length > 0) {
+        patch.session_storage = sessionStorage;
+      }
+      const observedProfile = normalizeObservedBrowserProfile(snapshot?.browserProfileObserved);
+      const browserProfile = buildBrowserProfilePayload(state.browserProfileCore, observedProfile);
+      if (Object.keys(browserProfile).length > 0) {
+        patch.browser_profile = browserProfile;
+      }
+    } catch (error) {
+    }
+    return Object.keys(patch).length > 0 ? patch : null;
+  }
+};
 
 // src/apify-kit.js
 var logger3 = createInternalLogger("ApifyKit");
+var resolveRuntimeContext = (input) => {
+  const rememberedState = RuntimeEnv.peekRememberedState();
+  const state = rememberedState || RuntimeEnv.parseInput(input || {});
+  const envPatch = RuntimeEnv.buildEnvPatch(state) || null;
+  return {
+    actor: state.actor,
+    runtime: state.runtime,
+    envPatch
+  };
+};
+var isPageLike = (value) => {
+  if (!value || typeof value !== "object") return false;
+  return typeof value.evaluate === "function" && typeof value.context === "function";
+};
+var pickPage = (...candidates) => {
+  for (const candidate of candidates) {
+    if (isPageLike(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+};
+var toSerializable = (value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) => {
+  if (depth > 6) return "[MaxDepth]";
+  if (value == null) return value;
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number" || valueType === "boolean") {
+    return value;
+  }
+  if (valueType === "bigint") {
+    return value.toString();
+  }
+  if (valueType === "function" || valueType === "symbol") {
+    return void 0;
+  }
+  if (value instanceof Error) {
+    return (0, import_serialize_error2.serializeError)(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toSerializable(item, depth + 1, seen)).filter((item) => item !== void 0);
+  }
+  if (valueType !== "object") {
+    return String(value);
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  const ctorName = String(value?.constructor?.name || "");
+  if (ctorName === "Page" || ctorName === "BrowserContext" || ctorName === "Browser" || ctorName === "Frame" || ctorName === "ElementHandle" || ctorName === "JSHandle") {
+    return `[${ctorName}]`;
+  }
+  const output = {};
+  Object.entries(value).forEach(([key, item]) => {
+    const safeValue = toSerializable(item, depth + 1, seen);
+    if (safeValue !== void 0) {
+      output[key] = safeValue;
+    }
+  });
+  return output;
+};
+var sanitizeMeta = (meta) => {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    return {};
+  }
+  const result = toSerializable(meta) || {};
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    delete result.page;
+  }
+  return result;
+};
+var captureAutoEnvPatch = async (page, runtimeContext) => {
+  const currentPage = pickPage(page);
+  if (!currentPage) return null;
+  try {
+    return await RuntimeEnv.captureEnvPatch(
+      currentPage,
+      {
+        actor: runtimeContext.actor,
+        runtime: runtimeContext.runtime
+      },
+      { actor: runtimeContext.actor }
+    );
+  } catch (error) {
+    logger3.warn(`\u81EA\u52A8\u91C7\u96C6 env_patch \u5931\u8D25: ${error?.message || error}`);
+    return null;
+  }
+};
 async function createApifyKit() {
   let apify = null;
   try {
@@ -937,6 +1521,9 @@ async function createApifyKit() {
     throw new Error("\u26A0\uFE0F  apify \u5E93\u672A\u5B89\u88C5\uFF0CApifyKit \u7684 Actor \u76F8\u5173\u529F\u80FD\u4E0D\u53EF\u7528");
   }
   const { Actor: Actor2 } = apify;
+  const actorInput = await Actor2.getInput() || {};
+  let lastPage = null;
+  const getRuntimeContext = () => resolveRuntimeContext(actorInput);
   return {
     /**
      * 核心封装：执行步骤，带自动日志确认、失败截图处理和重试机制
@@ -952,6 +1539,9 @@ async function createApifyKit() {
      * @param {Function} [options.retry.before] - 重试前钩子，可覆盖默认等待行为
      */
     async runStep(step, page, actionFn, options = {}) {
+      if (isPageLike(page)) {
+        lastPage = page;
+      }
       const { failActor = true, retry = {} } = options;
       const { times: retryTimes = 0, mode: retryMode = "direct", before: beforeRetry } = retry;
       const executeAction = async (attemptNumber) => {
@@ -1013,13 +1603,18 @@ async function createApifyKit() {
         } catch (snapErr) {
           logger3.warn(`\u622A\u56FE\u751F\u6210\u5931\u8D25: ${snapErr.message}`);
         }
-        await this.pushFailed(finalError, {
-          step,
-          page,
-          options,
-          base64,
-          retryAttempts: retryTimes
-        });
+        await this.pushFailed(
+          finalError,
+          {
+            step,
+            base64,
+            retryAttempts: retryTimes
+          },
+          {
+            page,
+            options
+          }
+        );
         await Actor2.fail(`Run Step ${step} \u5931\u8D25 (\u5DF2\u91CD\u8BD5 ${retryTimes} \u6B21): ${finalError.message}`);
       } else {
         throw finalError;
@@ -1041,42 +1636,83 @@ async function createApifyKit() {
       });
     },
     /**
-     * 推送成功数据的通用方法
+     * 推送成功数据的通用方法。
+     * 这里会自动做三件事：
+     * 1. 采集当前页面的 env_patch；
+     * 2. 合并显式传入的 env_patch；
+     * 3. 一并写入 dataset，供后端回写 runtime_env_json。
      * @param {Object} data - 要推送的数据对象
      */
-    async pushSuccess(data) {
-      const traffic = await getProxyMeterSnapshot({ finalize: true });
-      await Actor2.pushData({
-        // 固定为0
+    async pushSuccess(data, options = {}) {
+      const runtimeContext = getRuntimeContext();
+      const page = pickPage(options?.page, data?.page, lastPage);
+      if (page) {
+        lastPage = page;
+      }
+      let payloadData = data;
+      let explicitPatch = null;
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        payloadData = { ...data };
+        explicitPatch = payloadData.env_patch;
+        delete payloadData.env_patch;
+        delete payloadData.page;
+      }
+      const capturedPatch = await captureAutoEnvPatch(page, runtimeContext);
+      const envPatch = RuntimeEnv.mergeEnvPatches(runtimeContext.envPatch, capturedPatch, explicitPatch);
+      const traffic = await ProxyMeterRuntime.getProxyMeterSnapshot({ finalize: true });
+      const payload = {
         code: Code.Success,
         status: Status.Success,
         ...traffic ? { traffic } : {},
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        data
+        data: payloadData
+      };
+      if (envPatch) {
+        payload.env_patch = envPatch;
+      }
+      await Actor2.pushData({
+        ...payload
       });
       logger3.success("pushSuccess", "Data pushed");
     },
     /**
-     * 推送失败数据的通用方法（私有方法，仅供runStep内部使用）
-     * 自动解析 CrawlerError 的 code 和 context
+     * 推送失败数据的通用方法（私有方法，仅供 runStep 内部使用）。
+     * 即便任务失败，这里也会自动回收 env_patch，确保 cookies/storage 的最新状态不会丢。
      * @param {Error|CrawlerError} error - 错误对象
-     * @param {Object} [meta] - 额外的数据（如failedStep, screenshotBase64等）
+     * @param {Object} [meta] - 额外的数据（如 failedStep、screenshotBase64 等）
+     * @param {Object} [options] - 附加选项（如 page）
      * @private
      */
-    async pushFailed(error, meta = {}) {
+    async pushFailed(error, meta = {}, options = {}) {
+      const runtimeContext = getRuntimeContext();
+      const page = pickPage(options?.page, meta?.page, lastPage);
+      if (page) {
+        lastPage = page;
+      }
+      const capturedPatch = await captureAutoEnvPatch(page, runtimeContext);
+      const explicitPatch = meta?.env_patch;
+      const envPatch = RuntimeEnv.mergeEnvPatches(runtimeContext.envPatch, capturedPatch, explicitPatch);
+      const safeMeta = sanitizeMeta(meta);
+      delete safeMeta.env_patch;
       const isCrawlerError = CrawlerError.isCrawlerError(error);
       const code = isCrawlerError ? error.code : Code.UnknownError;
       const context = isCrawlerError ? error.context : {};
-      const traffic = await getProxyMeterSnapshot({ finalize: true });
-      await Actor2.pushData({
+      const traffic = await ProxyMeterRuntime.getProxyMeterSnapshot({ finalize: true });
+      const payload = {
         // 如果是 CrawlerError，使用其 code，否则使用默认 Failed code
         code,
         status: Status.Failed,
         ...traffic ? { traffic } : {},
         error: (0, import_serialize_error2.serializeError)(error),
-        meta,
+        meta: safeMeta,
         context,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (envPatch) {
+        payload.env_patch = envPatch;
+      }
+      await Actor2.pushData({
+        ...payload
       });
       logger3.success("pushFailed", "Error data pushed");
     }
@@ -1167,12 +1803,13 @@ var DEFAULT_LAUNCH_ARGS = [
   // '--disable-blink-features=AutomationControlled', // Crawlee 可能会自动处理，过多干预反而会被识别
   "--no-sandbox",
   "--disable-setuid-sandbox",
-  "--window-position=0,0",
-  `--lang=${BASE_CONFIG.locale}`
+  "--window-position=0,0"
 ];
-function buildFingerprintOptions(locale) {
+function buildFingerprintOptions({ locale = BASE_CONFIG.locale, browserMajorVersion = 0 } = {}) {
+  const normalizedBrowserMajorVersion = Number(browserMajorVersion || 0);
+  const browserDescriptor = normalizedBrowserMajorVersion > 0 ? [{ name: "chrome", minVersion: normalizedBrowserMajorVersion, maxVersion: normalizedBrowserMajorVersion }] : [{ name: "chrome", minVersion: 110 }];
   return {
-    browsers: [{ name: "chrome", minVersion: 110 }],
+    browsers: browserDescriptor,
     devices: ["desktop"],
     operatingSystems: ["windows", "macos", "linux"],
     locales: [locale]
@@ -1188,20 +1825,21 @@ var AntiCheat = {
   /**
    * 用于 Crawlee fingerprint generator 的统一配置（桌面端）。
    */
-  getFingerprintGeneratorOptions() {
-    return buildFingerprintOptions(BASE_CONFIG.locale);
+  getFingerprintGeneratorOptions(options = {}) {
+    return buildFingerprintOptions(options);
   },
   /**
    * 获取基础启动参数。
    */
-  getLaunchArgs() {
-    return [...DEFAULT_LAUNCH_ARGS];
+  getLaunchArgs(options = {}) {
+    const locale = String(options?.locale || BASE_CONFIG.locale).trim() || BASE_CONFIG.locale;
+    return [...DEFAULT_LAUNCH_ARGS, `--lang=${locale}`];
   },
   /**
    * 为 got-scraping 生成与浏览器一致的 TLS 指纹配置（桌面端）。
    */
   getTlsFingerprintOptions(userAgent = "", acceptLanguage = "") {
-    return buildFingerprintOptions(BASE_CONFIG.locale);
+    return buildFingerprintOptions();
   },
   /**
    * 规范化请求头
@@ -1692,12 +2330,18 @@ var Humanize = {
   }
 };
 
+// src/launch.js
+var import_node_child_process = require("node:child_process");
+var import_fingerprint_generator = require("fingerprint-generator");
+var import_fingerprint_injector = require("fingerprint-injector");
+
 // src/proxy-bypass.js
 var import_picomatch = __toESM(require("picomatch"), 1);
 var normalizeByPassDomains = (domains) => {
   if (!Array.isArray(domains)) return [];
   return domains.map((item) => String(item || "").trim()).filter(Boolean);
 };
+var normalizeHostname = (value = "") => String(value || "").trim().toLowerCase();
 var buildByPassDomainRule = (rawPattern) => {
   const pattern = String(rawPattern || "").trim().toLowerCase();
   if (!pattern) return null;
@@ -1718,7 +2362,7 @@ var buildByPassDomainRules = (domains = []) => {
 var findMatchedByPassRule = (rules = [], requestUrl = "") => {
   let hostname = "";
   try {
-    hostname = new URL(String(requestUrl || "")).hostname.toLowerCase();
+    hostname = normalizeHostname(new URL(String(requestUrl || "")).hostname);
   } catch {
     return null;
   }
@@ -1735,16 +2379,56 @@ var findMatchedByPassRule = (rules = [], requestUrl = "") => {
     hostname
   };
 };
+var isDomainCoveredByByPass = (domain = "", rules = []) => {
+  const hostname = normalizeHostname(domain);
+  if (!hostname) return false;
+  for (const rule of rules || []) {
+    if (!rule || typeof rule.test !== "function") continue;
+    if (rule.test(hostname)) return true;
+  }
+  return false;
+};
+var resolveRouteByProxy = ({
+  requestUrl = "",
+  enableProxy = false,
+  byPassRules = []
+}) => {
+  if (!enableProxy) {
+    return { route: "direct", matchedRule: null, hostname: "" };
+  }
+  const matched = findMatchedByPassRule(byPassRules, requestUrl);
+  if (!matched) {
+    return { route: "proxy", matchedRule: null, hostname: "" };
+  }
+  if (matched.rule) {
+    return { route: "direct", matchedRule: matched.rule, hostname: matched.hostname };
+  }
+  return { route: "proxy", matchedRule: null, hostname: matched.hostname };
+};
+var ByPass = {
+  normalizeByPassDomains,
+  normalizeHostname,
+  buildByPassDomainRule,
+  buildByPassDomainRules,
+  findMatchedByPassRule,
+  isDomainCoveredByByPass,
+  resolveRouteByProxy
+};
 
 // src/launch.js
 var logger7 = createInternalLogger("Launch");
 var REQUEST_HOOK_FLAG = Symbol("playwright-toolkit-request-hook");
+var injectedContexts = /* @__PURE__ */ new WeakSet();
+var browserMajorVersionCache = /* @__PURE__ */ new Map();
+var DEFAULT_BROWSER_PROFILE_SCHEMA_VERSION = 1;
+var DEFAULT_LOCALE = "zh-CN";
 var DEFAULT_CRAWLER_BASE_OPTIONS = Object.freeze({
   maxConcurrency: 1,
   maxRequestRetries: 0,
   requestHandlerTimeoutSecs: 240,
   navigationTimeoutSecs: 120
 });
+var fingerprintInjector = new import_fingerprint_injector.FingerprintInjector();
 var resolveProxyLaunchOptions = (proxyConfiguration = {}) => {
   const config = proxyConfiguration && typeof proxyConfiguration === "object" && !Array.isArray(proxyConfiguration) ? proxyConfiguration : {};
   const proxyUrl = String(config.proxy_url || "").trim();
@@ -1752,9 +2436,149 @@ var resolveProxyLaunchOptions = (proxyConfiguration = {}) => {
   if (!enableProxy || !proxyUrl) {
     return { byPassDomains: [], enableProxy, proxyUrl };
   }
-  const byPassDomains = normalizeByPassDomains(config.by_pass_domains);
+  const byPassDomains = ByPass.normalizeByPassDomains(config.by_pass_domains);
   return { byPassDomains, enableProxy, proxyUrl };
 };
+var parseChromeMajorVersion = (rawValue = "") => {
+  const match = String(rawValue || "").match(/Chrome\/(\d+)/i);
+  return match ? Number(match[1] || 0) : 0;
+};
+var resolveLauncherExecutablePath = (launcher) => {
+  if (!launcher || typeof launcher !== "object") return "";
+  if (typeof launcher.executablePath === "function") {
+    try {
+      return String(launcher.executablePath() || "").trim();
+    } catch {
+      return "";
+    }
+  }
+  return "";
+};
+var detectBrowserMajorVersion = (launcher) => {
+  const executablePath = resolveLauncherExecutablePath(launcher);
+  if (!executablePath) return 0;
+  if (browserMajorVersionCache.has(executablePath)) {
+    return browserMajorVersionCache.get(executablePath);
+  }
+  let detectedVersion = 0;
+  try {
+    const rawVersion = (0, import_node_child_process.execFileSync)(executablePath, ["--version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    detectedVersion = parseChromeMajorVersion(rawVersion);
+  } catch (error) {
+    logger7.warn(`\u8BFB\u53D6\u6D4F\u89C8\u5668\u7248\u672C\u5931\u8D25: ${error?.message || error}`);
+  }
+  browserMajorVersionCache.set(executablePath, detectedVersion);
+  return detectedVersion;
+};
+var buildFingerprintGenerator = ({ locale, browserMajorVersion }) => {
+  return new import_fingerprint_generator.FingerprintGenerator(
+    AntiCheat.getFingerprintGeneratorOptions({
+      locale,
+      browserMajorVersion
+    })
+  );
+};
+var buildReplayableBrowserProfile = (runtimeState, launcher) => {
+  if (!runtimeState || !RuntimeEnv.hasLoginState(runtimeState)) {
+    return { runtimeState, browserProfileCore: null };
+  }
+  let nextState = RuntimeEnv.rememberState(runtimeState);
+  let browserProfileCore = RuntimeEnv.getBrowserProfileCore(nextState);
+  const timezoneId = String(browserProfileCore?.timezone_id || "").trim() || AntiCheat.getBaseConfig().timezoneId;
+  const locale = DEFAULT_LOCALE;
+  const currentBrowserMajorVersion = detectBrowserMajorVersion(launcher);
+  const storedBrowserMajorVersion = Number(browserProfileCore?.browser_major_version || 0);
+  const needsRebuild = !browserProfileCore?.fingerprint || Object.keys(browserProfileCore.fingerprint || {}).length === 0 || currentBrowserMajorVersion > 0 && storedBrowserMajorVersion > 0 && storedBrowserMajorVersion !== currentBrowserMajorVersion;
+  if (needsRebuild) {
+    const generator = buildFingerprintGenerator({
+      locale,
+      browserMajorVersion: currentBrowserMajorVersion
+    });
+    const fingerprint = generator.getFingerprint();
+    const fingerprintBrowserMajorVersion = parseChromeMajorVersion(fingerprint?.fingerprint?.navigator?.userAgent || "");
+    browserProfileCore = {
+      fingerprint,
+      timezone_id: timezoneId,
+      locale,
+      browser_major_version: currentBrowserMajorVersion > 0 ? currentBrowserMajorVersion : fingerprintBrowserMajorVersion,
+      profile_key: String(nextState.envId || "").trim(),
+      schema_version: DEFAULT_BROWSER_PROFILE_SCHEMA_VERSION
+    };
+    nextState = RuntimeEnv.setBrowserProfileCore(nextState, browserProfileCore);
+    logger7.info(
+      `\u5DF2\u751F\u6210\u6D4F\u89C8\u5668\u6307\u7EB9\u771F\u6E90 | env=${String(nextState.envId || "-")} | version=${browserProfileCore.browser_major_version || "-"} | timezone=${timezoneId}`
+    );
+    return { runtimeState: nextState, browserProfileCore };
+  }
+  const normalizedBrowserProfileCore = {
+    ...browserProfileCore,
+    timezone_id: timezoneId,
+    locale,
+    profile_key: String(browserProfileCore.profile_key || nextState.envId || "").trim(),
+    schema_version: Number(browserProfileCore.schema_version || 0) > 0 ? Number(browserProfileCore.schema_version || 0) : DEFAULT_BROWSER_PROFILE_SCHEMA_VERSION,
+    browser_major_version: currentBrowserMajorVersion > 0 ? currentBrowserMajorVersion : Number(browserProfileCore.browser_major_version || 0)
+  };
+  const currentCoreRaw = JSON.stringify(browserProfileCore || {});
+  const nextCoreRaw = JSON.stringify(normalizedBrowserProfileCore);
+  if (currentCoreRaw !== nextCoreRaw) {
+    nextState = RuntimeEnv.setBrowserProfileCore(nextState, normalizedBrowserProfileCore);
+  }
+  return {
+    runtimeState: nextState,
+    browserProfileCore: normalizedBrowserProfileCore
+  };
+};
+var buildReplayBrowserPoolOptions = (browserProfileCore) => {
+  const fingerprintWithHeaders = browserProfileCore?.fingerprint;
+  const fingerprint = fingerprintWithHeaders?.fingerprint;
+  if (!fingerprintWithHeaders || !fingerprint) {
+    return null;
+  }
+  return {
+    useFingerprints: false,
+    prePageCreateHooks: [
+      (_pageId, _browserController, pageOptions = {}) => {
+        if (!pageOptions || typeof pageOptions !== "object") return;
+        const screen = fingerprint.screen || {};
+        const userAgent = String(fingerprint.navigator?.userAgent || "").trim();
+        if (userAgent) {
+          pageOptions.userAgent = userAgent;
+        }
+        if (Number(screen.width || 0) > 0 && Number(screen.height || 0) > 0) {
+          pageOptions.viewport = {
+            width: Number(screen.width),
+            height: Number(screen.height)
+          };
+          pageOptions.screen = {
+            width: Number(screen.width),
+            height: Number(screen.height)
+          };
+        }
+        if (browserProfileCore.locale) {
+          pageOptions.locale = browserProfileCore.locale;
+        }
+        if (browserProfileCore.timezone_id) {
+          pageOptions.timezoneId = browserProfileCore.timezone_id;
+        }
+      }
+    ],
+    postPageCreateHooks: [
+      async (page) => {
+        const context = page?.context?.();
+        if (!context) return;
+        if (!injectedContexts.has(context)) {
+          await fingerprintInjector.attachFingerprintToPlaywright(context, fingerprintWithHeaders);
+          injectedContexts.add(context);
+        }
+        await page.emulateMedia({ colorScheme: "dark" }).catch(() => {
+        });
+      }
+    ]
+  };
+};
 var Launch = {
   getPlaywrightCrawlerOptions(options = {}) {
     const normalizedOptions = Array.isArray(options) ? { customArgs: options } : options || {};
@@ -1767,18 +2591,22 @@ var Launch = {
       isRunningOnApify = false,
       launcher = null,
       preNavigationHooks = [],
-      postNavigationHooks = []
+      postNavigationHooks = [],
+      runtimeState = null
     } = normalizedOptions;
     const { byPassDomains, enableProxy, proxyUrl } = resolveProxyLaunchOptions(proxyConfiguration);
-    const byPassRules = buildByPassDomainRules(byPassDomains);
-    const proxyMeter = enableProxy && proxyUrl ? startProxyMeter({ proxyUrl, debugMode }) : null;
+    const byPassRules = ByPass.buildByPassDomainRules(byPassDomains);
+    const proxyMeter = enableProxy && proxyUrl ? ProxyMeterRuntime.startProxyMeter({ proxyUrl, debugMode }) : null;
     const launchProxy = proxyMeter ? { server: proxyMeter.server } : null;
     if (launchProxy && byPassDomains.length > 0) {
       launchProxy.bypass = byPassDomains.join(",");
     }
+    const replayContext = buildReplayableBrowserProfile(runtimeState, launcher);
+    const replayBrowserPoolOptions = buildReplayBrowserPoolOptions(replayContext.browserProfileCore);
+    const launchLocale = String(replayContext.browserProfileCore?.locale || DEFAULT_LOCALE).trim() || DEFAULT_LOCALE;
     const launchOptions = {
       args: [
-        ...AntiCheat.getLaunchArgs(),
+        ...AntiCheat.getLaunchArgs({ locale: launchLocale }),
         ...customArgs
       ],
       ignoreDefaultArgs: ["--enable-automation"]
@@ -1790,7 +2618,7 @@ var Launch = {
     if (enableByPassLogger && launchProxy) {
       let upstreamLabel = "";
       try {
-        const parsedProxyUrl = new URL(proxyUrl);
+        const parsedProxyUrl = new URL(proxyUrl.includes("://") ? proxyUrl : `http://${proxyUrl}`);
         upstreamLabel = `${parsedProxyUrl.protocol}//${parsedProxyUrl.host}`;
       } catch {
       }
@@ -1799,14 +2627,10 @@ var Launch = {
       );
       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) {
-      logger7.info(
-        `[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=true \u4F46 proxy_url \u4E3A\u7A7A`
-      );
+      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) {
-      logger7.info(
-        `[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=false \u4E14 proxy_url \u5DF2\u914D\u7F6E`
-      );
+      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) {
       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`);
@@ -1825,9 +2649,9 @@ var Launch = {
       const requestHandler = (req) => {
         const requestUrl = req.url();
         const resourceType = req.resourceType();
-        const matched = byPassDomains.length > 0 ? findMatchedByPassRule(byPassRules, requestUrl) : null;
-        if (launchProxy && !matched) {
-          recordProxyMeterResourceType(requestUrl, resourceType);
+        const matched = byPassDomains.length > 0 ? ByPass.findMatchedByPassRule(byPassRules, requestUrl) : null;
+        if (launchProxy) {
+          ProxyMeterRuntime.recordProxyMeterResourceType(requestUrl, resourceType);
         }
         if (!enableByPassLogger || byPassDomains.length === 0) return;
         if (!matched || !matched.rule) return;
@@ -1846,7 +2670,8 @@ var Launch = {
     const crawlerBaseOptions = {
       ...DEFAULT_CRAWLER_BASE_OPTIONS,
       headless: !runInHeadfulMode || isRunningOnApify,
-      browserPoolOptions: {
+      // 有 core.fingerprint 时走固定回放；否则退回 Crawlee 默认指纹模式。
+      browserPoolOptions: replayBrowserPoolOptions || {
         useFingerprints: true,
         fingerprintOptions: {
           fingerprintGeneratorOptions: AntiCheat.getFingerprintGeneratorOptions()
@@ -2049,241 +2874,9 @@ var Captcha = {
   useCaptchaMonitor
 };
 
-// src/sse.js
-var import_https = __toESM(require("https"), 1);
-var import_url2 = require("url");
-var logger10 = createInternalLogger("Sse");
-var Sse = {
-  /**
-  * 解析 SSE 流文本
-  * 支持 `data: {...}` 和 `data:{...}` 两种格式
-  * @param {string} sseStreamText
-  * @returns {Array<Object>} events
-  */
-  parseSseStream(sseStreamText) {
-    const events = [];
-    const lines = sseStreamText.split("\n");
-    for (const line of lines) {
-      if (line.startsWith("data:")) {
-        try {
-          const jsonContent = line.substring(5).trim();
-          if (jsonContent) {
-            events.push(JSON.parse(jsonContent));
-          }
-        } catch (e) {
-          logger10.debug("parseSseStream", `JSON \u89E3\u6790\u5931\u8D25: ${e.message}, line: ${line.substring(0, 100)}...`);
-        }
-      }
-    }
-    logger10.success("parseSseStream", `\u89E3\u6790\u5B8C\u6210, events \u6570\u91CF: ${events.length}`);
-    return events;
-  },
-  /**
-   * 拦截网络请求并使用 Node.js 原生 https 模块转发，以解决流式数据捕获问题。
-   * @param {import('playwright').Page} page
-   * @param {string|RegExp} urlPattern - 拦截的 URL 模式
-   * @param {object} options
-   * @param {function(string, function, string): void} [options.onData] - (textChunk, resolve, accumulatedText) => void
-   * @param {function(string, function): void} [options.onEnd] - (fullText, resolve) => void
-   * @param {function(Error, function): void} [options.onTimeout] - (error, reject) => void
-   * @param {number} [options.initialTimeout=90000] - 初始数据接收超时 (ms)，默认 90s
-   * @param {number} [options.overallTimeout=180000] - 整体请求超时时间 (ms)，默认 180s
-   * @param {boolean} [options.autoUnroute=true] - resolve/reject 后是否自动取消拦截
-   * @param {boolean} [options.firstMatchOnly=true] - 只拦截第一个命中的请求，后续请求全部放行
-   * @returns {Promise<any>} - 返回 Promise，当流满足条件时 resolve
-   */
-  async intercept(page, urlPattern, options = {}) {
-    const {
-      onData,
-      onEnd,
-      onTimeout,
-      initialTimeout = 9e4,
-      overallTimeout = 18e4,
-      autoUnroute = true,
-      firstMatchOnly = true
-    } = options;
-    let initialTimer = null;
-    let overallTimer = null;
-    let hasReceivedInitialData = false;
-    const clearAllTimers = () => {
-      if (initialTimer) clearTimeout(initialTimer);
-      if (overallTimer) clearTimeout(overallTimer);
-      initialTimer = null;
-      overallTimer = null;
-    };
-    let safeResolve = () => {
-    };
-    let safeReject = () => {
-    };
-    let safeUnroute = () => {
-    };
-    const workPromise = new Promise((resolve, reject) => {
-      let finished = false;
-      let unrouteRequested = false;
-      let hasMatchedOnce = false;
-      safeUnroute = () => {
-        if (!autoUnroute) return;
-        if (unrouteRequested) return;
-        unrouteRequested = true;
-        logger10.info("[MITM] autoUnroute: \u53D6\u6D88\u540E\u7EED\u62E6\u622A");
-        page.unroute(urlPattern, routeHandler).catch(() => {
-        });
-      };
-      safeResolve = (value) => {
-        if (finished) return;
-        finished = true;
-        clearAllTimers();
-        safeUnroute();
-        resolve(value);
-      };
-      safeReject = (error) => {
-        if (finished) return;
-        finished = true;
-        clearAllTimers();
-        safeUnroute();
-        reject(error);
-      };
-      const routeHandler = async (route) => {
-        if (firstMatchOnly && hasMatchedOnce) {
-          logger10.info(`[MITM] firstMatchOnly: \u653E\u884C\u540E\u7EED\u8BF7\u6C42: ${route.request().url()}`);
-          route.continue().catch(() => {
-          });
-          return;
-        }
-        if (firstMatchOnly && !hasMatchedOnce) {
-          hasMatchedOnce = true;
-          logger10.info("[MITM] firstMatchOnly: \u547D\u4E2D\u9996\u4E2A\u8BF7\u6C42\uFF0C\u53D6\u6D88\u540E\u7EED\u62E6\u622A");
-          page.unroute(urlPattern, routeHandler).catch(() => {
-          });
-        }
-        const request = route.request();
-        logger10.info(`[MITM] \u5DF2\u62E6\u622A\u8BF7\u6C42: ${request.url()}`);
-        try {
-          const headers = await request.allHeaders();
-          const postData = request.postData();
-          const urlObj = new import_url2.URL(request.url());
-          delete headers["accept-encoding"];
-          delete headers["content-length"];
-          const reqOptions = {
-            hostname: urlObj.hostname,
-            port: 443,
-            path: urlObj.pathname + urlObj.search,
-            method: request.method(),
-            headers,
-            timeout: overallTimeout
-          };
-          const req = import_https.default.request(reqOptions, (res) => {
-            const chunks = [];
-            let accumulatedText = "";
-            res.on("data", (chunk) => {
-              if (!hasReceivedInitialData) {
-                hasReceivedInitialData = true;
-                if (initialTimer) {
-                  clearTimeout(initialTimer);
-                  initialTimer = null;
-                }
-                logger10.debug("[Intercept] \u5DF2\u63A5\u6536\u521D\u59CB\u6570\u636E");
-              }
-              chunks.push(chunk);
-              const textChunk = chunk.toString("utf-8");
-              accumulatedText += textChunk;
-              if (onData) {
-                try {
-                  onData(textChunk, safeResolve, accumulatedText);
-                } catch (e) {
-                  logger10.fail(`onData \u9519\u8BEF`, e);
-                }
-              }
-            });
-            res.on("end", () => {
-              logger10.info("[MITM] \u4E0A\u6E38\u54CD\u5E94\u7ED3\u675F");
-              clearAllTimers();
-              if (onEnd) {
-                try {
-                  onEnd(accumulatedText, safeResolve);
-                } catch (e) {
-                  logger10.fail(`onEnd \u9519\u8BEF`, e);
-                }
-              } else if (!onData) {
-                safeResolve(accumulatedText);
-              }
-              route.fulfill({
-                status: res.statusCode,
-                headers: res.headers,
-                body: Buffer.concat(chunks)
-              }).catch(() => {
-              });
-            });
-          });
-          req.on("error", (e) => {
-            clearAllTimers();
-            route.abort().catch(() => {
-            });
-            safeReject(e);
-          });
-          if (postData) req.write(postData);
-          req.end();
-        } catch (e) {
-          clearAllTimers();
-          route.continue().catch(() => {
-          });
-          safeReject(e);
-        }
-      };
-      page.route(urlPattern, routeHandler).catch(safeReject);
-    });
-    const timeoutPromise = new Promise((_, reject) => {
-      initialTimer = setTimeout(() => {
-        if (!hasReceivedInitialData) {
-          const error = new CrawlerError({
-            message: `\u521D\u59CB\u6570\u636E\u63A5\u6536\u8D85\u65F6 (${initialTimeout}ms)`,
-            code: Code.InitialTimeout,
-            context: { timeout: initialTimeout }
-          });
-          clearAllTimers();
-          if (onTimeout) {
-            try {
-              onTimeout(error, (err) => safeReject(err));
-            } catch (e) {
-              safeReject(e);
-            }
-          } else {
-            safeReject(error);
-          }
-        }
-      }, initialTimeout);
-      overallTimer = setTimeout(() => {
-        const error = new CrawlerError({
-          message: `\u6574\u4F53\u8BF7\u6C42\u8D85\u65F6 (${overallTimeout}ms)`,
-          code: Code.OverallTimeout,
-          context: { timeout: overallTimeout }
-        });
-        clearAllTimers();
-        if (onTimeout) {
-          try {
-            onTimeout(error, (err) => safeReject(err));
-          } catch (e) {
-            safeReject(e);
-          }
-        } else {
-          safeReject(error);
-        }
-      }, overallTimeout);
-    });
-    workPromise.catch(() => {
-    });
-    timeoutPromise.catch(() => {
-    });
-    const racePromise = Promise.race([workPromise, timeoutPromise]);
-    racePromise.catch(() => {
-    });
-    return racePromise;
-  }
-};
-
 // src/mutation.js
 var import_uuid2 = require("uuid");
-var logger11 = createInternalLogger("Mutation");
+var logger10 = createInternalLogger("Mutation");
 var MUTATION_MONITOR_MODE = Object.freeze({
   Added: "added",
   Changed: "changed",
@@ -2316,14 +2909,14 @@ var Mutation = {
     const stableTime = options.stableTime ?? 5 * 1e3;
     const timeout = options.timeout ?? 120 * 1e3;
     const onMutation = options.onMutation;
-    logger11.start("waitForStable", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, \u7A33\u5B9A\u65F6\u95F4=${stableTime}ms`);
+    logger10.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 });
-        logger11.info(`waitForStable \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
+        logger10.info(`waitForStable \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
       } catch (e) {
-        logger11.warning(`waitForStable \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
+        logger10.warning(`waitForStable \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
         throw e;
       }
     }
@@ -2339,7 +2932,7 @@ var Mutation = {
             return "__CONTINUE__";
           }
         });
-        logger11.info("waitForStable \u5DF2\u542F\u7528 onMutation \u56DE\u8C03");
+        logger10.info("waitForStable \u5DF2\u542F\u7528 onMutation \u56DE\u8C03");
       } catch (e) {
       }
     }
@@ -2454,9 +3047,9 @@ var Mutation = {
       { selectorList, stableTime, timeout, callbackName, hasCallback: !!onMutation }
     );
     if (result.mutationCount === 0 && result.stableTime === 0) {
-      logger11.warning("waitForStable \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
+      logger10.warning("waitForStable \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
     }
-    logger11.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
+    logger10.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
     return result;
   },
   /**
@@ -2574,22 +3167,22 @@ var Mutation = {
         return "__CONTINUE__";
       }
     };
-    logger11.start(
+    logger10.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 });
-        logger11.info(`waitForStableAcrossRoots \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
+        logger10.info(`waitForStableAcrossRoots \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
       } catch (e) {
-        logger11.warning(`waitForStableAcrossRoots \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
+        logger10.warning(`waitForStableAcrossRoots \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
         throw e;
       }
     }
     let state = await buildState();
     if (!state?.hasMatched) {
-      logger11.warning("waitForStableAcrossRoots \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
+      logger10.warning("waitForStableAcrossRoots \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
       return { mutationCount: 0, stableTime: 0, wasPaused: false };
     }
     let mutationCount = 0;
@@ -2626,7 +3219,7 @@ var Mutation = {
       if (lastState.snapshotKey !== lastSnapshotKey) {
         lastSnapshotKey = lastState.snapshotKey;
         mutationCount += 1;
-        logger11.info(
+        logger10.info(
           `waitForStableAcrossRoots \u53D8\u5316#${mutationCount}, len=${lastState.snapshotLength}, path=${lastState.primaryPath || "unknown"}, preview="${truncate(lastState.text, 120)}"`
         );
         const signal = await invokeMutationCallback({
@@ -2639,7 +3232,7 @@ var Mutation = {
         continue;
       }
       if (!isPaused && stableSince > 0 && Date.now() - stableSince >= waitForStableTime) {
-        logger11.success("waitForStableAcrossRoots", `DOM \u7A33\u5B9A, \u603B\u5171 ${mutationCount} \u6B21\u53D8\u5316${wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
+        logger10.success("waitForStableAcrossRoots", `DOM \u7A33\u5B9A, \u603B\u5171 ${mutationCount} \u6B21\u53D8\u5316${wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
         return {
           mutationCount,
           stableTime: waitForStableTime,
@@ -2666,7 +3259,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;
-    logger11.start("useMonitor", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, mode=${mode}`);
+    logger10.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");
@@ -2809,7 +3402,7 @@ var Mutation = {
         return total;
       };
     }, { selectorList, monitorKey, callbackName, cleanerName, hasCallback: !!onMutation, mode });
-    logger11.success("useMonitor", "\u76D1\u63A7\u5668\u5DF2\u542F\u52A8");
+    logger10.success("useMonitor", "\u76D1\u63A7\u5668\u5DF2\u542F\u52A8");
     return {
       stop: async () => {
         let totalMutations = 0;
@@ -2822,7 +3415,7 @@ var Mutation = {
           }, cleanerName);
         } catch (e) {
         }
-        logger11.success("useMonitor.stop", `\u76D1\u63A7\u5DF2\u505C\u6B62, \u5171 ${totalMutations} \u6B21\u53D8\u5316`);
+        logger10.success("useMonitor.stop", `\u76D1\u63A7\u5DF2\u505C\u6B62, \u5171 ${totalMutations} \u6B21\u53D8\u5316`);
         return { totalMutations };
       }
     };
@@ -2833,28 +3426,28 @@ var Mutation = {
 var Display = {
   parseTokenDisplayName(value) {
     if (!value) {
-      return { owner: "", accountType: "", note: "" };
+      return { owner: "", envType: "", note: "" };
     }
     const parts = String(value).split(":");
     const owner = (parts[0] || "").trim();
-    const accountType = (parts[1] || "").trim();
+    const envType = (parts[1] || "").trim();
     const note = parts.length > 2 ? parts.slice(2).join(":").trim() : "";
-    return { owner, accountType, note };
+    return { owner, envType, note };
   },
-  parseAccountDisplayName(value) {
+  parseEnvDisplayName(value) {
     if (!value) {
-      return { account: "", owner: "", accountType: "", note: "" };
+      return { env: "", owner: "", envType: "", note: "" };
     }
     const parts = String(value).split(":");
-    const account = (parts[0] || "").trim();
+    const env = (parts[0] || "").trim();
     const owner = (parts[1] || "").trim();
-    const accountType = (parts[2] || "").trim();
+    const envType = (parts[2] || "").trim();
     const note = parts.length > 3 ? parts.slice(3).join(":").trim() : "";
-    return { account, owner, accountType, note };
+    return { env, owner, envType, note };
   },
-  buildTokenDisplayName({ owner, accountType, note } = {}) {
+  buildTokenDisplayName({ owner, envType, note } = {}) {
     const trimmedOwner = owner?.trim() || "";
-    const trimmedType = accountType?.trim() || "";
+    const trimmedType = envType?.trim() || "";
     const trimmedNote = note?.trim() || "";
     const parts = [trimmedOwner, trimmedType];
     if (trimmedNote) {
@@ -2877,12 +3470,12 @@ var Display = {
     const secondary = hasName && short ? short : "";
     return { primary, secondary, fullId: cleanId, shortId: short };
   },
-  resolveAccountIdentity(displayName, accountId) {
-    const parts = this.parseAccountDisplayName(displayName);
-    const cleanId = String(accountId || "").trim();
+  resolveEnvIdentity(displayName, envId) {
+    const parts = this.parseEnvDisplayName(displayName);
+    const cleanId = String(envId || "").trim();
     const short = this.shortId(cleanId, 8);
-    const hasName = parts.account !== "" && parts.account !== cleanId;
-    const primary = hasName ? parts.account : short || "-";
+    const hasName = parts.env !== "" && parts.env !== cleanId;
+    const primary = hasName ? parts.env : short || "-";
     const secondary = hasName && short ? short : "";
     return { primary, secondary, parts, fullId: cleanId, shortId: short };
   }
@@ -3691,7 +4284,7 @@ var createTemplateLogger = (baseLogger = createBaseLogger()) => {
 };
 var getDefaultBaseLogger = () => createBaseLogger("");
 var Logger = {
-  setLogger: (logger13) => setDefaultLogger(logger13),
+  setLogger: (logger12) => setDefaultLogger(logger12),
   info: (message) => getDefaultBaseLogger().info(message),
   success: (message) => getDefaultBaseLogger().success(message),
   warning: (message) => getDefaultBaseLogger().warning(message),
@@ -3699,15 +4292,15 @@ var Logger = {
   error: (message) => getDefaultBaseLogger().error(message),
   debug: (message) => getDefaultBaseLogger().debug(message),
   start: (message) => getDefaultBaseLogger().start(message),
-  useTemplate: (logger13) => {
-    if (logger13) return createTemplateLogger(createBaseLogger("", logger13));
+  useTemplate: (logger12) => {
+    if (logger12) return createTemplateLogger(createBaseLogger("", logger12));
     return createTemplateLogger();
   }
 };
 
 // src/share.js
 var import_delay2 = __toESM(require("delay"), 1);
-var logger12 = createInternalLogger("Share");
+var logger11 = createInternalLogger("Share");
 var DEFAULT_TIMEOUT_MS2 = 50 * 1e3;
 var DEFAULT_PAYLOAD_SNAPSHOT_MAX_LEN = 500;
 var DEFAULT_POLL_INTERVAL_MS = 120;
@@ -3827,7 +4420,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;
-  logger12.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
+  logger11.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
   const monitor = await Mutation.useMonitor(page, selectors, {
     mode,
     onMutation: (context = {}) => {
@@ -3845,12 +4438,12 @@ ${text}`;
         });
       }
       if (mutationCount <= 5 || mutationCount % 50 === 0) {
-        logger12.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
+        logger11.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
       }
       const [candidate] = Utils.parseLinks(rawDom, { prefix }) || [];
       if (!candidate) return;
       matched = true;
-      logger12.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
+      logger11.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
       if (onMatch) {
         onMatch({
           link: candidate,
@@ -3866,7 +4459,7 @@ ${text}`;
   return {
     stop: async () => {
       const result = await monitor.stop();
-      logger12.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
+      logger11.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
       return result;
     }
   };
@@ -3906,8 +4499,8 @@ var Share = {
     if (share.mode === "response" && apiMatchers.length === 0) {
       throw new Error("Share.captureLink requires share.xurl[0] api matcher when mode=response");
     }
-    logger12.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutMs}, prefix=${share.prefix}`);
-    logger12.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
+    logger11.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutMs}, prefix=${share.prefix}`);
+    logger11.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
     const stats = {
       actionTimedOut: false,
       domMutationCount: 0,
@@ -3932,7 +4525,7 @@ var Share = {
         link: validated,
         payloadText: String(payloadText || "")
       };
-      logger12.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
+      logger11.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
       return true;
     };
     const resolveResponseCandidate = (responseText) => {
@@ -3967,7 +4560,7 @@ var Share = {
       try {
         await monitor.stop();
       } catch (error) {
-        logger12.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+        logger11.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     const onResponse = async (response) => {
@@ -3980,29 +4573,29 @@ var Share = {
           stats.responseSampleUrls.push(url);
         }
         if (stats.responseObserved <= 5) {
-          logger12.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
+          logger11.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
         }
         if (!apiMatchers.some((matcher) => url.includes(matcher))) return;
         stats.responseMatched += 1;
         stats.lastMatchedUrl = url;
-        logger12.info(`\u63A5\u53E3\u547D\u4E2D\u5339\u914D(${stats.responseMatched}): ${url}`);
+        logger11.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) {
-            logger12.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
+            logger11.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
           }
           return;
         }
         stats.responseResolved += 1;
-        logger12.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
+        logger11.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
         setCandidate("response", hit.link, hit.payloadText);
       } catch (error) {
-        logger12.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
+        logger11.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     if (share.mode === "dom") {
-      logger12.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
+      logger11.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
       domMonitor = await createDomShareMonitor(page, {
         prefix: share.prefix,
         selectors: domSelectors,
@@ -4017,14 +4610,14 @@ var Share = {
       });
     }
     if (share.mode === "response") {
-      logger12.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
+      logger11.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
       page.on("response", onResponse);
     }
     const deadline = Date.now() + timeoutMs;
     const getRemainingMs = () => Math.max(0, deadline - Date.now());
     try {
       const actionTimeout = getRemainingMs();
-      logger12.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${actionTimeout}ms`);
+      logger11.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${actionTimeout}ms`);
       if (actionTimeout > 0) {
         let timer = null;
         let actionError = null;
@@ -4038,21 +4631,21 @@ var Share = {
         const actionResult = await Promise.race([actionPromise, timeoutPromise]);
         if (timer) clearTimeout(timer);
         if (actionResult === "__ACTION_ERROR__") {
-          logger12.fail("captureLink.performActions", actionError);
+          logger11.fail("captureLink.performActions", actionError);
           throw actionError;
         }
         if (actionResult === "__ACTION_TIMEOUT__") {
           stats.actionTimedOut = true;
-          logger12.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
+          logger11.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
         } else {
-          logger12.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
+          logger11.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
         }
       }
       let nextProgressLogTs = Date.now() + 3e3;
       while (true) {
         const selected = share.mode === "dom" ? candidates.dom : candidates.response;
         if (selected?.link) {
-          logger12.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
+          logger11.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
           return {
             link: selected.link,
             payloadText: selected.payloadText,
@@ -4064,7 +4657,7 @@ var Share = {
         if (remaining <= 0) break;
         const now = Date.now();
         if (now >= nextProgressLogTs) {
-          logger12.info(
+          logger11.info(
             `captureLink \u7B49\u5F85\u4E2D: remaining=${remaining}ms, domMutationCount=${stats.domMutationCount}, responseMatched=${stats.responseMatched}`
           );
           nextProgressLogTs = now + 5e3;
@@ -4072,11 +4665,11 @@ var Share = {
         await (0, import_delay2.default)(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
       }
       if (share.mode === "response" && stats.responseMatched === 0) {
-        logger12.warning(
+        logger11.warning(
           `\u63A5\u53E3\u76D1\u542C\u672A\u547D\u4E2D: apiMatchers=${toJsonInline(apiMatchers, 220)}, \u54CD\u5E94\u6837\u672CURLs=${toJsonInline(stats.responseSampleUrls, 420)}`
         );
       }
-      logger12.warning(
+      logger11.warning(
         `captureLink \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 {
@@ -4088,7 +4681,7 @@ var Share = {
     } finally {
       if (share.mode === "response") {
         page.off("response", onResponse);
-        logger12.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
+        logger11.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
       }
       await stopDomMonitor();
     }
@@ -4174,13 +4767,14 @@ var usePlaywrightToolKit = () => {
     LiveView,
     Constants: constants_exports,
     Utils,
+    RuntimeEnv,
     Captcha,
-    Sse,
     Errors: errors_exports,
     Mutation,
     Display,
     Logger,
     Share,
+    ByPass,
     $Internals: { LOG_TEMPLATES, stripAnsi }
   };
 };