@bryce3310687963/android-toolkit 0.0.0-stage → 1.0.51

package/dist/index.cjs

@@ -0,0 +1,3300 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// entrys/node.js
+var node_exports = {};
+__export(node_exports, {
+  useAndroidToolKit: () => useAndroidToolKit
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/apify-kit.js
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_json_cycle = __toESM(require("json-cycle"), 1);
+
+// src/constants.js
+var constants_exports = {};
+__export(constants_exports, {
+  ActorInfo: () => ActorInfo,
+  ActorKey: () => ActorKey,
+  AppiumSettings: () => AppiumSettings,
+  Code: () => Code,
+  Status: () => Status,
+  StoragePath: () => StoragePath,
+  UnicodeIme: () => UnicodeIme,
+  WebViewBridge: () => WebViewBridge
+});
+var Code = Object.freeze({
+  Success: 0,
+  EmptySuccess: 1,
+  UnknownError: -1,
+  NotLogin: 30000001,
+  Timeout: 30000003,
+  InitialTimeout: 30000004,
+  OverallTimeout: 30000005,
+  AccountFreeze: 30000006,
+  InvalidRequest: 30010001,
+  AdbUnavailable: 30010002,
+  ContentUnavailable: 30010003,
+  SourceExtractionFailed: 30010004,
+  AutomationFailed: 30010005,
+  AppRuntimeUnavailable: 30010008,
+  AppNotInstalled: 30010009
+});
+var Status = Object.freeze({
+  Success: "SUCCESS",
+  Failed: "FAILED"
+});
+var StoragePath = Object.freeze({
+  Input: "/apify_storage/input.json",
+  Output: "/apify_storage/output.json"
+});
+var UnicodeIme = Object.freeze({
+  packageName: "io.appium.settings",
+  component: "io.appium.settings/.UnicodeIME",
+  inputAction: "ADB_INPUT_TEXT"
+});
+var AppiumSettings = Object.freeze({
+  packageName: "io.appium.settings",
+  clipboardReceiver: "io.appium.settings/.receivers.ClipboardReceiver",
+  clipboardGetAction: "io.appium.settings.clipboard.get"
+});
+var WebViewBridge = Object.freeze({
+  packageName: "com.heartbit.apify.android.bridge",
+  actionCommand: "com.heartbit.apify.android.bridge.COMMAND",
+  cacheDir: "apify-webview-bridge",
+  hookConfigFile: "hook.json",
+  commandDir: "commands",
+  resultDir: "results"
+});
+var ActorKey = Object.freeze({
+  DoubaoAndroid: "doubao.android",
+  ErineAndroid: "erine.android",
+  WechatAndroid: "wechat.android",
+  QwenAndroid: "qwen.android",
+  YuanbaoAndroid: "yuanbao.android",
+  XhsAndroid: "xhs.android"
+});
+var normalizeShare = (share) => {
+  const source = share && typeof share === "object" ? share : {};
+  return {
+    mode: "clipboard",
+    prefix: String(source.prefix || "").trim(),
+    xurl: Array.isArray(source.xurl) ? source.xurl : []
+  };
+};
+var createActorInfo = (info) => {
+  const key = String(info.key || "").trim();
+  return Object.freeze({
+    key,
+    name: String(info.name || key),
+    icon: String(info.icon || `https://static.heartbitai.com/general/actors/${key}.png`),
+    webviews: Object.freeze(Array.isArray(info.webviews) ? info.webviews : []),
+    share: Object.freeze(normalizeShare(info.share))
+  });
+};
+var ActorInfo = Object.freeze({
+  [ActorKey.DoubaoAndroid]: createActorInfo({
+    key: ActorKey.DoubaoAndroid,
+    name: "\u8C46\u5305 Android",
+    webviews: [{
+      name: [
+        "android.webkit.WebView",
+        "com.baidu.webkit.sdk.WebView",
+        "com.tencent.smtt.sdk.WebView",
+        "com.tencent.xweb.WebView",
+        "com.tencent.xweb.pinus.PSWebview"
+      ],
+      value: ["www.doubao.com"]
+    }],
+    share: {
+      prefix: "https://www.doubao.com/thread/",
+      xurl: []
+    }
+  }),
+  [ActorKey.ErineAndroid]: createActorInfo({
+    key: ActorKey.ErineAndroid,
+    name: "\u6587\u5C0F\u8A00 Android",
+    webviews: [{
+      name: [
+        "android.webkit.WebView",
+        "com.baidu.webkit.sdk.WebView",
+        "com.tencent.smtt.sdk.WebView",
+        "com.tencent.xweb.WebView",
+        "com.tencent.xweb.pinus.PSWebview"
+      ],
+      value: ["yiyanapp.baidu.com"]
+    }],
+    share: {
+      prefix: "https://mr.baidu.com/r/",
+      xurl: []
+    }
+  }),
+  [ActorKey.WechatAndroid]: createActorInfo({
+    key: ActorKey.WechatAndroid,
+    name: "\u5FAE\u4FE1 Android",
+    webviews: [{
+      name: [
+        "android.webkit.WebView",
+        "com.baidu.webkit.sdk.WebView",
+        "com.tencent.smtt.sdk.WebView",
+        "com.tencent.xweb.WebView",
+        "com.tencent.xweb.pinus.PSWebview"
+      ],
+      value: ["websearch/template"]
+    }],
+    share: {
+      prefix: "",
+      xurl: []
+    }
+  }),
+  [ActorKey.QwenAndroid]: createActorInfo({
+    key: ActorKey.QwenAndroid,
+    name: "\u5343\u95EE Android",
+    webviews: [{
+      name: [
+        "android.webkit.WebView",
+        "com.baidu.webkit.sdk.WebView",
+        "com.tencent.smtt.sdk.WebView",
+        "com.tencent.xweb.WebView",
+        "com.tencent.xweb.pinus.PSWebview"
+      ],
+      value: ["www.qianwen.com", "chat2.qianwen.com"]
+    }],
+    share: {
+      prefix: "",
+      xurl: []
+    }
+  }),
+  [ActorKey.XhsAndroid]: createActorInfo({
+    key: ActorKey.XhsAndroid,
+    name: "\u5C0F\u7EA2\u4E66 Android",
+    webviews: [{
+      name: [
+        "android.webkit.WebView",
+        "com.baidu.webkit.sdk.WebView",
+        "com.tencent.smtt.sdk.WebView",
+        "com.tencent.xweb.WebView",
+        "com.tencent.xweb.pinus.PSWebview"
+      ],
+      value: ["xiaohongshu.com", "xhslink.com"]
+    }],
+    share: {
+      prefix: "",
+      xurl: []
+    }
+  }),
+  [ActorKey.YuanbaoAndroid]: createActorInfo({
+    key: ActorKey.YuanbaoAndroid,
+    name: "\u5143\u5B9D Android",
+    webviews: [{
+      name: [
+        "android.webkit.WebView",
+        "com.baidu.webkit.sdk.WebView",
+        "com.tencent.smtt.sdk.WebView",
+        "com.tencent.xweb.WebView",
+        "com.tencent.xweb.pinus.PSWebview"
+      ],
+      value: ["yuanbao.tencent.com", "hunyuan.tencent.com", "yb.tencent.com"]
+    }],
+    share: {
+      prefix: "https://yb.tencent.com/s/",
+      xurl: []
+    }
+  })
+});
+
+// src/context.js
+var Context = {
+  createAndroidContext,
+  firstNonEmpty,
+  requireNonEmpty
+};
+function createAndroidContext(input = {}, defaults = {}) {
+  const runtime = input.runtime && typeof input.runtime === "object" ? input.runtime : {};
+  const device = runtime.device && typeof runtime.device === "object" ? runtime.device : {};
+  return {
+    runId: firstNonEmpty(defaults.runId, runtime.runId, input.runId),
+    query: String(firstNonEmpty(defaults.query, input.query) || "").trim(),
+    serial: firstNonEmpty(defaults.serial, device.serial),
+    packageName: firstNonEmpty(defaults.packageName, device.packageName),
+    adbPath: firstNonEmpty(defaults.adbPath, process.env.ANDROID_TOOLKIT_ADB_PATH),
+    appVersion: firstNonEmpty(defaults.appVersion, device.appVersion),
+    slotKey: firstNonEmpty(defaults.slotKey, device.slotKey),
+    instanceId: firstNonEmpty(defaults.instanceId, device.instanceId),
+    externalIp: firstNonEmpty(defaults.externalIp, device.externalIp)
+  };
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const clean = String(value ?? "").trim();
+    if (clean) return clean;
+  }
+  return "";
+}
+function requireNonEmpty(value, name) {
+  const clean = String(value ?? "").trim();
+  if (!clean) throw new Error(`${name} is required`);
+  return clean;
+}
+
+// src/device.js
+var import_node_child_process = require("node:child_process");
+var import_node_util = require("node:util");
+
+// src/errors.js
+var errors_exports = {};
+__export(errors_exports, {
+  CrawlerError: () => CrawlerError,
+  serializeError: () => serializeError
+});
+var CrawlerError = class _CrawlerError extends Error {
+  constructor(input = {}, options = {}) {
+    const payload = typeof input === "string" ? { message: input } : input;
+    super(payload.message || "Android crawler error", options);
+    this.name = "CrawlerError";
+    this.code = payload.code || Code.UnknownError;
+    this.context = payload.context || {};
+  }
+  static isCrawlerError(error) {
+    return error instanceof _CrawlerError || error?.name === "CrawlerError";
+  }
+  static from(error, fallback = {}) {
+    if (_CrawlerError.isCrawlerError(error)) return error;
+    return new _CrawlerError({
+      message: error?.message || String(error),
+      code: fallback.code || Code.UnknownError,
+      context: fallback.context || {}
+    });
+  }
+};
+function serializeError(error) {
+  if (!error) return { message: "" };
+  return {
+    name: error.name || "Error",
+    message: error.message || String(error),
+    stack: error.stack || "",
+    code: error.code || "",
+    context: error.context || void 0
+  };
+}
+
+// src/logger.js
+var defaultLogger = {
+  info: (...args) => console.error(...args),
+  warning: (...args) => console.error(...args),
+  warn: (...args) => console.error(...args),
+  error: (...args) => console.error(...args),
+  debug: (...args) => console.error(...args)
+};
+var activeLogger = defaultLogger;
+var ANSI = {
+  reset: "\x1B[0m",
+  gray: "\x1B[90m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m"
+};
+var STEP_PREFIX = "\u6B65\u9AA4:";
+var STEP_SEPARATOR = " | ";
+var LOG_TAG_PREFIX = "[#log:";
+var LOG_TAG_SUFFIX = "]";
+var STEP_ICONS = [
+  { match: "\u4EFB\u52A1", icon: "\u{1F9ED}" },
+  { match: "Launch", icon: "\u{1F680}" },
+  { match: "Step", icon: "\u{1F9F1}" },
+  { match: "\u8F93\u5165\u6CD5", icon: "\u2328\uFE0F" },
+  { match: "ADB", icon: "\u{1F50C}" },
+  { match: "Mutation", icon: "\u{1F4E1}" },
+  { match: "WebView", icon: "\u{1F310}" },
+  { match: "\u622A\u56FE", icon: "\u{1F5BC}\uFE0F" },
+  { match: "\u5206\u4EAB", icon: "\u{1F517}" },
+  { match: "\u6570\u636E", icon: "\u{1F4E6}" }
+];
+var STATUS_ICONS = [
+  { match: "\u5F00\u59CB", icon: "\u{1F680}" },
+  { match: "\u5B8C\u6210", icon: "\u2705" },
+  { match: "\u6210\u529F", icon: "\u2705" },
+  { match: "\u5931\u8D25", icon: "\u274C" },
+  { match: "\u8DF3\u8FC7", icon: "\u23ED\uFE0F" },
+  { match: "\u91CD\u8BD5", icon: "\u{1F501}" },
+  { match: "\u7A33\u5B9A", icon: "\u{1F7E2}" }
+];
+var ATTENTION_RANK = {
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+var DEFAULT_ATTENTION_RANK = ATTENTION_RANK.high;
+var toErrorMessage = (error) => {
+  if (!error) return "";
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+};
+var detailToParts = (detail) => {
+  if (detail == null || detail === "") return [];
+  if (detail instanceof Error) return [`err=${detail.message}`];
+  if (typeof detail === "string") return [detail];
+  if (Array.isArray(detail)) return detail.flatMap(detailToParts).filter(Boolean);
+  if (typeof detail === "object") {
+    return Object.entries(detail).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${key}=${typeof value === "object" ? safeJson(value) : String(value)}`);
+  }
+  return [String(detail)];
+};
+var LOG_DEFINITIONS = [
+  {
+    key: "task_start",
+    method: "taskStart",
+    label: "\u4EFB\u52A1\u5F00\u59CB",
+    group: "\u4EFB\u52A1",
+    step: "\u4EFB\u52A1",
+    status: "\u5F00\u59CB",
+    level: "start",
+    attention: "low",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "task_success",
+    method: "taskSuccess",
+    label: "\u4EFB\u52A1\u5B8C\u6210",
+    group: "\u4EFB\u52A1",
+    step: "\u4EFB\u52A1",
+    status: "\u5B8C\u6210",
+    level: "success",
+    attention: "high",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "task_fail",
+    method: "taskFail",
+    label: "\u4EFB\u52A1\u5931\u8D25",
+    group: "\u4EFB\u52A1",
+    step: "\u4EFB\u52A1",
+    status: "\u5931\u8D25",
+    level: "error",
+    attention: "critical",
+    buildDetails: (detail, error) => [...detailToParts(detail), error ? `err=${toErrorMessage(error)}` : ""]
+  },
+  {
+    key: "launch_start",
+    method: "launchStart",
+    label: "Launch \u5F00\u59CB",
+    group: "Launch",
+    step: "Launch.run",
+    status: "\u5F00\u59CB",
+    level: "start",
+    attention: "low",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "launch_success",
+    method: "launchSuccess",
+    label: "Launch \u5B8C\u6210",
+    group: "Launch",
+    step: "Launch.run",
+    status: "\u5B8C\u6210",
+    level: "success",
+    attention: "high",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "launch_fail",
+    method: "launchFail",
+    label: "Launch \u5931\u8D25",
+    group: "Launch",
+    step: "Launch.run",
+    status: "\u5931\u8D25",
+    level: "error",
+    attention: "critical",
+    buildDetails: (detail, error) => [...detailToParts(detail), error ? `err=${toErrorMessage(error)}` : ""]
+  },
+  {
+    key: "input_method_snapshot_fail",
+    method: "inputMethodSnapshotFail",
+    label: "\u8F93\u5165\u6CD5\u5FEB\u7167\u5931\u8D25",
+    group: "\u8F93\u5165\u6CD5",
+    step: "\u8F93\u5165\u6CD5\u5FEB\u7167",
+    status: "\u5931\u8D25",
+    level: "warning",
+    attention: "medium",
+    buildDetails: (error) => [error ? `err=${toErrorMessage(error)}` : ""]
+  },
+  {
+    key: "input_method_restore_fail",
+    method: "inputMethodRestoreFail",
+    label: "\u8F93\u5165\u6CD5\u6062\u590D\u5931\u8D25",
+    group: "\u8F93\u5165\u6CD5",
+    step: "\u8F93\u5165\u6CD5\u6062\u590D",
+    status: "\u5931\u8D25",
+    level: "warning",
+    attention: "medium",
+    buildDetails: (error) => [error ? `err=${toErrorMessage(error)}` : ""]
+  },
+  {
+    key: "step_start",
+    method: "stepStart",
+    label: "\u6B65\u9AA4\u5F00\u59CB",
+    group: "Step",
+    step: "Step",
+    status: "\u5F00\u59CB",
+    level: "start",
+    attention: "low",
+    buildDetails: (step, detail) => [step ? `name=${step}` : "", ...detailToParts(detail)]
+  },
+  {
+    key: "step_success",
+    method: "stepSuccess",
+    label: "\u6B65\u9AA4\u5B8C\u6210",
+    group: "Step",
+    step: "Step",
+    status: "\u5B8C\u6210",
+    level: "success",
+    attention: "high",
+    buildDetails: (step, detail) => [step ? `name=${step}` : "", ...detailToParts(detail)]
+  },
+  {
+    key: "step_fail",
+    method: "stepFail",
+    label: "\u6B65\u9AA4\u5931\u8D25",
+    group: "Step",
+    step: "Step",
+    status: "\u5931\u8D25",
+    level: "error",
+    attention: "critical",
+    buildDetails: (step, error) => [step ? `name=${step}` : "", error ? `err=${toErrorMessage(error)}` : ""]
+  },
+  {
+    key: "step_retry",
+    method: "stepRetry",
+    label: "\u6B65\u9AA4\u91CD\u8BD5",
+    group: "Step",
+    step: "Step",
+    status: "\u91CD\u8BD5",
+    level: "warning",
+    attention: "medium",
+    buildDetails: (step, attempt) => [step ? `name=${step}` : "", attempt !== void 0 ? `attempt=${attempt}` : ""]
+  },
+  {
+    key: "adb_exec",
+    method: "adbExec",
+    label: "ADB \u6267\u884C",
+    group: "ADB",
+    step: "ADB",
+    status: "\u5B8C\u6210",
+    level: "debug",
+    attention: "low",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "adb_retry",
+    method: "adbRetry",
+    label: "ADB \u91CD\u8BD5",
+    group: "ADB",
+    step: "ADB",
+    status: "\u91CD\u8BD5",
+    level: "warning",
+    attention: "medium",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "mutation_wait_start",
+    method: "mutationWaitStart",
+    label: "Mutation \u7B49\u5F85\u5F00\u59CB",
+    group: "Mutation",
+    step: "Mutation",
+    status: "\u5F00\u59CB",
+    level: "start",
+    attention: "low",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "mutation_wait_success",
+    method: "mutationWaitSuccess",
+    label: "Mutation \u7A33\u5B9A",
+    group: "Mutation",
+    step: "Mutation",
+    status: "\u7A33\u5B9A",
+    level: "success",
+    attention: "medium",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "mutation_wait_warn",
+    method: "mutationWaitWarn",
+    label: "Mutation \u7B49\u5F85\u544A\u8B66",
+    group: "Mutation",
+    step: "Mutation",
+    status: "\u8DF3\u8FC7",
+    level: "warning",
+    attention: "medium",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "webview_command",
+    method: "webViewCommand",
+    label: "WebView \u547D\u4EE4",
+    group: "WebView",
+    step: "WebView",
+    status: "\u5F00\u59CB",
+    level: "start",
+    attention: "low",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "webview_success",
+    method: "webViewSuccess",
+    label: "WebView \u5B8C\u6210",
+    group: "WebView",
+    step: "WebView",
+    status: "\u5B8C\u6210",
+    level: "success",
+    attention: "medium",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "webview_warn",
+    method: "webViewWarn",
+    label: "WebView \u544A\u8B66",
+    group: "WebView",
+    step: "WebView",
+    status: "\u8DF3\u8FC7",
+    level: "warning",
+    attention: "medium",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "webview_fail",
+    method: "webViewFail",
+    label: "WebView \u5931\u8D25",
+    group: "WebView",
+    step: "WebView",
+    status: "\u5931\u8D25",
+    level: "error",
+    attention: "high",
+    buildDetails: (error) => [error ? `err=${toErrorMessage(error)}` : ""]
+  },
+  {
+    key: "screenshot_start",
+    method: "screenshotStart",
+    label: "\u622A\u56FE\u5F00\u59CB",
+    group: "\u622A\u56FE",
+    step: "\u622A\u56FE",
+    status: "\u5F00\u59CB",
+    level: "start",
+    attention: "low",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "screenshot_success",
+    method: "screenshotDone",
+    label: "\u622A\u56FE\u6210\u529F",
+    group: "\u622A\u56FE",
+    step: "\u622A\u56FE",
+    status: "\u6210\u529F",
+    level: "success",
+    attention: "high",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "share_start",
+    method: "shareStart",
+    label: "\u5206\u4EAB\u5F00\u59CB",
+    group: "\u5206\u4EAB",
+    step: "\u5206\u4EAB",
+    status: "\u5F00\u59CB",
+    level: "start",
+    attention: "low",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "share_success",
+    method: "shareSuccess",
+    label: "\u5206\u4EAB\u6210\u529F",
+    group: "\u5206\u4EAB",
+    step: "\u5206\u4EAB",
+    status: "\u6210\u529F",
+    level: "success",
+    attention: "high",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "share_fail",
+    method: "shareFail",
+    label: "\u5206\u4EAB\u5931\u8D25",
+    group: "\u5206\u4EAB",
+    step: "\u5206\u4EAB",
+    status: "\u5931\u8D25",
+    level: "warning",
+    attention: "high",
+    buildDetails: (error) => [error ? `err=${toErrorMessage(error)}` : ""]
+  },
+  {
+    key: "data_push_success",
+    method: "dataPush",
+    label: "\u6570\u636E\u63A8\u9001\u6210\u529F",
+    group: "\u6570\u636E",
+    step: "\u6570\u636E\u63A8\u9001",
+    status: "\u6210\u529F",
+    level: "success",
+    attention: "high",
+    buildDetails: (detail) => detailToParts(detail)
+  },
+  {
+    key: "data_push_fail",
+    method: "dataPushFail",
+    label: "\u6570\u636E\u63A8\u9001\u5931\u8D25",
+    group: "\u6570\u636E",
+    step: "\u6570\u636E\u63A8\u9001",
+    status: "\u5931\u8D25",
+    level: "error",
+    attention: "high",
+    buildDetails: (error) => [error ? `err=${toErrorMessage(error)}` : ""]
+  }
+];
+var buildLogTag = (key) => `${LOG_TAG_PREFIX}${key}${LOG_TAG_SUFFIX}`;
+var escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var buildStepPattern = (step, status) => {
+  if (!step) return null;
+  let pattern = `${STEP_PREFIX} .*${escapeRegExp(step)}`;
+  if (status) pattern += `.*${escapeRegExp(status)}`;
+  return new RegExp(pattern);
+};
+var LOG_TEMPLATES = Object.freeze(LOG_DEFINITIONS.map((definition) => {
+  const attention = definition.attention || "medium";
+  const attentionRank = ATTENTION_RANK[attention] || ATTENTION_RANK.medium;
+  const patterns = [new RegExp(`\\[#log:${escapeRegExp(definition.key)}\\]`)];
+  const fallback = buildStepPattern(definition.step, definition.status);
+  if (fallback) patterns.push(fallback);
+  return {
+    key: definition.key,
+    label: definition.label,
+    group: definition.group,
+    attention,
+    patterns,
+    defaultSelected: attentionRank >= DEFAULT_ATTENTION_RANK
+  };
+}));
+var Logger = {
+  setLogger(logger) {
+    activeLogger = logger || defaultLogger;
+  },
+  createLogger(scope) {
+    const prefix = scope ? String(scope) : "";
+    return {
+      start: (message, detail) => createBaseLogger(prefix).start(formatMessage(message, detail)),
+      success: (message, detail) => createBaseLogger(prefix).success(formatMessage(message, detail)),
+      fail: (message, error) => createBaseLogger(prefix).error(formatMessage(message, error?.message || error)),
+      warn: (message, detail) => createBaseLogger(prefix).warning(formatMessage(message, detail)),
+      warning: (message, detail) => createBaseLogger(prefix).warning(formatMessage(message, detail)),
+      info: (message, detail) => createBaseLogger(prefix).info(formatMessage(message, detail)),
+      debug: (message, detail) => createBaseLogger(prefix).debug(formatMessage(message, detail)),
+      useTemplate: () => createTemplateLogger(createBaseLogger(prefix))
+    };
+  },
+  useTemplate(logger) {
+    if (logger) return createTemplateLogger(createBaseLogger("", logger));
+    return createTemplateLogger(createBaseLogger(""));
+  },
+  start(message, detail = "") {
+    createBaseLogger("").start(formatMessage(message, detail));
+  },
+  success(message, detail = "") {
+    createBaseLogger("").success(formatMessage(message, detail));
+  },
+  fail(message, error = "") {
+    createBaseLogger("").error(formatMessage(message, error?.message || error));
+  },
+  warn(message, detail = "") {
+    createBaseLogger("").warning(formatMessage(message, detail));
+  },
+  warning(message, detail = "") {
+    Logger.warn(message, detail);
+  },
+  error(message, detail = "") {
+    createBaseLogger("").error(formatMessage(message, detail));
+  },
+  info(message, detail = "") {
+    createBaseLogger("").info(formatMessage(message, detail));
+  },
+  debug(message, detail = "") {
+    createBaseLogger("").debug(formatMessage(message, detail));
+  },
+  duration(startedAt) {
+    return `${((Date.now() - startedAt) / 1e3).toFixed(2)}s`;
+  }
+};
+function stripAnsi(value) {
+  return String(value || "").replace(/\u001b\[[0-9;]*m/g, "");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createBaseLogger(prefix = "", explicitLogger = null) {
+  const name = prefix ? String(prefix) : "";
+  const dispatch = (methodName, icon, message, color) => {
+    const timestamp = colorize(`[${formatTimestamp()}]`, ANSI.gray);
+    const line = formatLine(name, icon, message);
+    const coloredLine = colorize(line, color);
+    const writer = resolveLogMethod(resolveLogger(explicitLogger), methodName);
+    writer(`${timestamp} ${coloredLine}`.trim());
+  };
+  return {
+    info: (message) => dispatch("info", "\u{1F4D6}", message, ANSI.cyan),
+    success: (message) => dispatch("info", "\u2705", message, ANSI.green),
+    warning: (message) => dispatch("warning", "\u26A0\uFE0F", message, ANSI.yellow),
+    warn: (message) => dispatch("warning", "\u26A0\uFE0F", message, ANSI.yellow),
+    error: (message) => dispatch("error", "\u274C", message, ANSI.red),
+    debug: (message) => dispatch("debug", "\u{1F539}", message, ANSI.gray),
+    start: (message) => dispatch("info", "\u{1F537}", message, ANSI.blue)
+  };
+}
+function createTemplateLogger(baseLogger) {
+  const handlers = {
+    info: (line) => baseLogger.info(line),
+    success: (line) => baseLogger.success(line),
+    warning: (line) => baseLogger.warning(line),
+    warn: (line) => baseLogger.warning(line),
+    error: (line) => baseLogger.error(line),
+    debug: (line) => baseLogger.debug(line),
+    start: (line) => baseLogger.start(line)
+  };
+  const emitDefinition = (definition, details = []) => {
+    const handler = handlers[definition.level] || handlers.info;
+    handler(buildStepLine(definition.step, definition.status, [...details, buildLogTag(definition.key)]));
+  };
+  const definitionMethods = {};
+  for (const definition of LOG_DEFINITIONS) {
+    if (!definition.method) continue;
+    definitionMethods[definition.method] = (...args) => {
+      const details = definition.buildDetails ? definition.buildDetails(...args) : [];
+      emitDefinition(definition, details.filter(Boolean));
+    };
+  }
+  return {
+    step: (step, status, details, level = "info") => {
+      const handler = handlers[level] || handlers.info;
+      handler(buildStepLine(step, status, detailToParts(details)));
+    },
+    info: (message, detail) => baseLogger.info(formatMessage(message, detail)),
+    success: (message, detail) => baseLogger.success(formatMessage(message, detail)),
+    warning: (message, detail) => baseLogger.warning(formatMessage(message, detail)),
+    warn: (message, detail) => baseLogger.warning(formatMessage(message, detail)),
+    error: (message, detail) => baseLogger.error(formatMessage(message, detail)),
+    debug: (message, detail) => baseLogger.debug(formatMessage(message, detail)),
+    start: (message, detail) => baseLogger.start(formatMessage(message, detail)),
+    ...definitionMethods
+  };
+}
+function buildStepLine(step, status, details = []) {
+  const parts = [];
+  const decoratedStep = step ? decorateLabel(step, STEP_ICONS) : "";
+  parts.push(decoratedStep ? `${STEP_PREFIX} ${decoratedStep}` : STEP_PREFIX);
+  if (status) parts.push(decorateLabel(status, STATUS_ICONS));
+  const detailParts = details.flatMap(detailToParts).filter(Boolean);
+  parts.push(...detailParts);
+  return parts.join(STEP_SEPARATOR);
+}
+function decorateLabel(label, mappings) {
+  if (!label) return "";
+  const mapping = mappings.find((item) => String(label).includes(item.match));
+  if (!mapping) return label;
+  return `${mapping.icon} ${label}`;
+}
+function resolveLogger(explicitLogger) {
+  if (explicitLogger && typeof explicitLogger.info === "function") return explicitLogger;
+  return activeLogger || defaultLogger;
+}
+function resolveLogMethod(logger, name) {
+  if (logger && typeof logger[name] === "function") return logger[name].bind(logger);
+  if (name === "warning" && logger && typeof logger.warn === "function") return logger.warn.bind(logger);
+  return defaultLogger[name] || defaultLogger.info;
+}
+function formatLine(prefix, icon, message) {
+  const parts = [];
+  if (prefix) parts.push(`[${prefix}]`);
+  if (icon) parts.push(icon);
+  if (message) parts.push(message);
+  return parts.join(" ").trim();
+}
+function formatMessage(message, detail = "") {
+  const detailText = formatDetail(detail);
+  return detailText ? `${message} ${detailText}` : String(message || "");
+}
+function formatTimestamp(date = /* @__PURE__ */ new Date()) {
+  const pad = (value, size = 2) => String(value).padStart(size, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`;
+}
+function formatDetail(detail) {
+  return detailToParts(detail).join(" ");
+}
+function colorize(text2, color) {
+  if (!text2 || !color) return text2;
+  return `${color}${text2}${ANSI.reset}`;
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/device.js
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var DEFAULT_ADB_ATTEMPTS = 3;
+var DEFAULT_ADB_RETRY_DELAY_MS = 500;
+var Device = {
+  adbExec,
+  adbShell,
+  writeCacheFile,
+  forceStopApp,
+  clearAppCache,
+  startActivity,
+  startLauncher,
+  resolveLauncherActivity,
+  focusedActivity,
+  waitForActivity,
+  waitForForeground,
+  screenSize,
+  screenDensity,
+  tapAbsolute,
+  swipe,
+  pressKey,
+  pressBack,
+  pressEnter,
+  typeText,
+  screenshotPng,
+  screenshotBase64,
+  dumpUiXml,
+  wakeAndUnlock,
+  hideKeyboard,
+  isKeyboardVisible,
+  sleep,
+  ensureUnicodeIme,
+  currentInputMethod,
+  restoreInputMethod
+};
+async function adbExec(ctx, args, options = {}) {
+  const adbPath = requireDeviceField(ctx, "adbPath");
+  const startedAt = Date.now();
+  try {
+    const { stdout } = await execAdbWithRetry(adbPath, args, options);
+    Logger.useTemplate().adbExec({ duration: Logger.duration(startedAt), args: compactArgs(args) });
+    return stdout;
+  } catch (error) {
+    if (isAdbUnavailableError(error)) {
+      throw new CrawlerError({
+        message: `adb_unavailable: ${error?.message || String(error)}`,
+        code: Code.AdbUnavailable,
+        context: { args: compactArgs(args), adbPath }
+      });
+    }
+    throw error;
+  }
+}
+async function adbShell(ctx, args, options = {}) {
+  const serial = requireDeviceField(ctx, "serial");
+  return adbExec(ctx, ["-s", serial, "shell", ...args], options);
+}
+async function writeCacheFile(ctx, options = {}) {
+  const dataDir = appDataDir(ctx);
+  const dirPath = `${dataDir}/cache/${cleanCachePathName(options.dirName, "dirName")}`;
+  const filePath = `${dirPath}/${cleanCachePathName(options.fileName, "fileName")}`;
+  const command = [
+    `owner=$(stat -c %u:%g ${shellQuoteForRemote(dataDir)})`,
+    `mkdir -p ${shellQuoteForRemote(dirPath)}`,
+    `printf %s ${shellQuoteForRemote(String(options.text ?? ""))} > ${shellQuoteForRemote(filePath)}`,
+    `chown "$owner" ${shellQuoteForRemote(dirPath)} ${shellQuoteForRemote(filePath)}`,
+    `chmod 2775 ${shellQuoteForRemote(dirPath)}`,
+    `chmod 664 ${shellQuoteForRemote(filePath)}`
+  ].join(" && ");
+  await Device.adbShell(ctx, [`su -c ${shellQuoteForRemote(command)}`], {
+    timeoutMs: Number(options.timeoutMs || 1e4),
+    maxBuffer: Number(options.maxBuffer || 1024)
+  });
+  return filePath;
+}
+async function adbInput(ctx, args, options = {}) {
+  return adbShell(ctx, ["input", ...args], options);
+}
+async function forceStopApp(ctx, packageName = ctx.packageName) {
+  await adbShell(ctx, ["am", "force-stop", requireValue(packageName, "packageName")], { timeoutMs: 15e3 });
+}
+async function clearAppCache(ctx, packageName = ctx.packageName) {
+  const targetPackage = requireValue(packageName, "packageName");
+  if (!/^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)+$/.test(targetPackage)) {
+    throw new CrawlerError({ message: "invalid_request: invalid packageName for cache cleanup", code: Code.InvalidRequest });
+  }
+  const dataDir = `/data/data/${targetPackage}`;
+  const cacheDirs = [`${dataDir}/cache`, `${dataDir}/code_cache`, `/sdcard/Android/data/${targetPackage}/cache`];
+  const command = [
+    "set -e",
+    `test -d ${shellQuoteForRemote(dataDir)}`,
+    `for cache_dir in ${cacheDirs.map(shellQuoteForRemote).join(" ")}; do`,
+    '  if [ -L "$cache_dir" ]; then echo "refusing symlink cache directory: $cache_dir" >&2; exit 1; fi',
+    '  if [ -d "$cache_dir" ]; then',
+    `    find "$cache_dir" -mindepth 1 -maxdepth 1 ! -name ${shellQuoteForRemote(WebViewBridge.cacheDir)} ! -name 'network-capture' -exec rm -rf -- {} +`,
+    "  fi",
+    "done"
+  ].join("\n");
+  await Device.adbShell(ctx, [`su -c ${shellQuoteForRemote(command)}`], {
+    timeoutMs: 3e4,
+    maxBuffer: 4096
+  }).catch((error) => {
+    throw CrawlerError.from(error, { code: Code.AutomationFailed, context: { packageName: targetPackage } });
+  });
+  Logger.useTemplate().info("App \u4E34\u65F6\u7F13\u5B58\u5DF2\u6E05\u7406", { packageName: targetPackage });
+}
+async function startActivity(ctx, component, args = []) {
+  const target = requireValue(component, "component");
+  const output = await adbShell(ctx, ["am", "start", "-W", "-n", target, ...args], { timeoutMs: 2e4 });
+  assertActivityStartOk(output, target);
+  await sleep(1500);
+  return output;
+}
+async function startLauncher(ctx, packageName = ctx.packageName, launcherActivity) {
+  const targetPackage = requireValue(packageName, "packageName");
+  const component = launcherActivity ? `${targetPackage}/${requireValue(launcherActivity, "launcherActivity")}` : await resolveLauncherActivity(ctx, targetPackage);
+  return startActivity(ctx, component, [
+    "-a",
+    "android.intent.action.MAIN",
+    "-c",
+    "android.intent.category.LAUNCHER"
+  ]);
+}
+async function resolveLauncherActivity(ctx, packageName = ctx.packageName) {
+  const targetPackage = requireValue(packageName, "packageName");
+  const output = await adbShell(ctx, [
+    "cmd",
+    "package",
+    "resolve-activity",
+    "--brief",
+    "-a",
+    "android.intent.action.MAIN",
+    "-c",
+    "android.intent.category.LAUNCHER",
+    targetPackage
+  ], { timeoutMs: 15e3 });
+  const component = parseResolvedLauncherComponent(output, targetPackage);
+  if (!component) {
+    throw new CrawlerError({
+      message: `automation_failed: cannot resolve launcher activity packageName=${targetPackage} output=${compactOutput(output)}`,
+      code: Code.AutomationFailed,
+      context: { packageName: targetPackage, output: compactOutput(output, 2e3) }
+    });
+  }
+  return component;
+}
+async function focusedActivity(ctx) {
+  const resumed = await resumedActivity(ctx).catch(() => "");
+  if (resumed) return resumed;
+  const out = await adbShell(ctx, ["dumpsys", "window"], { timeoutMs: 15e3, maxBuffer: 12 * 1024 * 1024 });
+  for (const line of String(out || "").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.includes("mCurrentFocus=Window") && !trimmed.includes("=null")) return trimmed;
+  }
+  for (const line of String(out || "").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.includes("mFocusedApp=AppWindowToken") && !trimmed.includes("=null")) return trimmed;
+  }
+  return "";
+}
+async function resumedActivity(ctx) {
+  const out = await adbShell(ctx, ["dumpsys", "activity", "activities"], {
+    timeoutMs: 15e3,
+    maxBuffer: 12 * 1024 * 1024
+  });
+  let fallback = "";
+  for (const line of String(out || "").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.includes("ActivityRecord") || !trimmed.includes("/")) continue;
+    if (trimmed.includes("mTopResumedActivity") || trimmed.includes("topResumedActivity") || trimmed.startsWith("ResumedActivity:") || trimmed.startsWith("Resumed:")) {
+      return trimmed;
+    }
+    if (trimmed.includes("mResumedActivity")) fallback = trimmed;
+  }
+  return fallback;
+}
+async function waitForActivity(ctx, predicate, timeoutMs = 15e3, intervalMs = 700) {
+  const deadline = Date.now() + Number(timeoutMs);
+  let lastFocused = "";
+  while (Date.now() < deadline) {
+    lastFocused = await focusedActivity(ctx).catch((error) => `ERROR: ${error?.message || String(error)}`);
+    if (predicate(lastFocused)) return lastFocused;
+    await sleep(intervalMs);
+  }
+  throw new CrawlerError({
+    message: `automation_failed: waitForActivity timeout focused=${lastFocused}`,
+    code: Code.AutomationFailed
+  });
+}
+async function waitForForeground(ctx, packageName = ctx.packageName, timeoutMs = 6e3) {
+  const target = requireValue(packageName, "packageName");
+  return waitForActivity(ctx, (value) => String(value || "").includes(target), timeoutMs, 500);
+}
+async function screenSize(ctx) {
+  const out = await adbShell(ctx, ["wm", "size"], { timeoutMs: 15e3 });
+  const match = /(\d+)x(\d+)/.exec(String(out || ""));
+  if (!match) throw new CrawlerError({ message: `adb_unavailable: cannot parse screen size: ${out}`, code: Code.AdbUnavailable });
+  return { width: Number(match[1]), height: Number(match[2]) };
+}
+async function screenDensity(ctx) {
+  const out = await adbShell(ctx, ["wm", "density"], { timeoutMs: 15e3 });
+  const match = /(\d+)/.exec(String(out || ""));
+  if (!match) throw new CrawlerError({ message: `adb_unavailable: cannot parse screen density: ${out}`, code: Code.AdbUnavailable });
+  return Number(match[1]);
+}
+async function tapAbsolute(ctx, x, y) {
+  await adbInput(ctx, ["tap", Math.round(Number(x)), Math.round(Number(y))], { timeoutMs: 15e3 });
+}
+async function swipe(ctx, from, to, durationMs = 360) {
+  const args = [
+    "swipe",
+    Math.round(Number(from?.x)),
+    Math.round(Number(from?.y)),
+    Math.round(Number(to?.x)),
+    Math.round(Number(to?.y)),
+    Math.round(Number(durationMs))
+  ];
+  await adbInput(ctx, args, { timeoutMs: 3e4 });
+}
+async function pressKey(ctx, key) {
+  await adbInput(ctx, ["keyevent", String(key)], { timeoutMs: 15e3 });
+}
+async function pressBack(ctx) {
+  await pressKey(ctx, "BACK");
+}
+async function pressEnter(ctx) {
+  await pressKey(ctx, "KEYCODE_ENTER");
+}
+async function typeText(ctx, text2) {
+  await ensureUnicodeIme(ctx);
+  const value = String(text2 ?? "");
+  if (!value) return;
+  await sendUnicodeImeText(ctx, encodeUnicodeImeText(value), {
+    timeoutMs: Math.max(15e3, value.length * 300)
+  });
+  await sleep(1200);
+}
+async function ensureUnicodeIme(ctx) {
+  const out = await adbShell(ctx, ["ime", "list", "-s"], { timeoutMs: 15e3 });
+  if (!String(out || "").split(/\s+/).includes(UnicodeIme.component)) {
+    throw new CrawlerError({
+      message: `adb_unavailable: UnicodeIME \u672A\u5B89\u88C5\u6216\u4E0D\u53EF\u7528 ${UnicodeIme.component}`,
+      code: Code.AdbUnavailable,
+      context: { component: UnicodeIme.component }
+    });
+  }
+  await adbShell(ctx, ["ime", "set", UnicodeIme.component], { timeoutMs: 15e3 });
+}
+async function currentInputMethod(ctx) {
+  const value = await adbShell(ctx, ["settings", "get", "secure", "default_input_method"], { timeoutMs: 15e3 });
+  return String(value || "").trim();
+}
+async function restoreInputMethod(ctx, component) {
+  const value = String(component || "").trim();
+  if (!value || value === "null" || value === UnicodeIme.component) return false;
+  await adbShell(ctx, ["ime", "set", value], { timeoutMs: 15e3 });
+  return true;
+}
+async function screenshotPng(ctx) {
+  const serial = requireDeviceField(ctx, "serial");
+  const adbPath = requireDeviceField(ctx, "adbPath");
+  try {
+    const { stdout } = await execAdbWithRetry(adbPath, ["-s", serial, "exec-out", "screencap", "-p"], {
+      timeoutMs: 3e4,
+      maxBuffer: 40 * 1024 * 1024,
+      encoding: "buffer",
+      label: "screencap"
+    });
+    return Buffer.from(stdout);
+  } catch (error) {
+    if (isAdbUnavailableError(error)) {
+      throw new CrawlerError({
+        message: `adb_unavailable: screencap failed ${error?.message || String(error)}`,
+        code: Code.AdbUnavailable,
+        context: { serial, adbPath }
+      });
+    }
+    throw new CrawlerError({
+      message: `source_extraction_failed: screencap failed ${error?.message || String(error)}`,
+      code: Code.SourceExtractionFailed,
+      context: { serial }
+    });
+  }
+}
+async function screenshotBase64(ctx) {
+  return `data:image/png;base64,${(await screenshotPng(ctx)).toString("base64")}`;
+}
+async function readClipboardForShare(ctx) {
+  const out = await adbShell(ctx, [
+    "am",
+    "broadcast",
+    "-n",
+    AppiumSettings.clipboardReceiver,
+    "-a",
+    AppiumSettings.clipboardGetAction
+  ], {
+    timeoutMs: 8e3,
+    maxBuffer: 1024 * 1024
+  }).catch((error) => {
+    throw new CrawlerError({
+      message: `source_extraction_failed: Appium Settings clipboard receiver unavailable ${error?.message || String(error)}`,
+      code: Code.SourceExtractionFailed,
+      context: { receiver: AppiumSettings.clipboardReceiver }
+    });
+  });
+  const text2 = normalizeAppiumClipboardBroadcast(out);
+  if (!text2) {
+    throw new CrawlerError({
+      message: "source_extraction_failed: ADB clipboard is empty",
+      code: Code.SourceExtractionFailed,
+      context: { receiver: AppiumSettings.clipboardReceiver, output: String(out || "").slice(0, 1e3) }
+    });
+  }
+  return text2;
+}
+async function dumpUiXml(ctx) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    const dumpPath = `/data/local/tmp/android-toolkit-window-${Date.now()}-${Math.random().toString(16).slice(2)}.xml`;
+    await adbShell(ctx, ["rm", "-f", dumpPath], { timeoutMs: 1e4 }).catch(() => {
+    });
+    try {
+      await adbShell(ctx, ["uiautomator", "dump", dumpPath], {
+        timeoutMs: 3e4,
+        maxBuffer: 4 * 1024 * 1024
+      });
+      const raw = await adbShell(ctx, ["cat", dumpPath], {
+        timeoutMs: 3e4,
+        maxBuffer: 16 * 1024 * 1024
+      });
+      const start = String(raw || "").indexOf("<?xml");
+      if (start < 0) throw new CrawlerError({ message: `automation_failed: uiautomator dump missing xml: ${raw}`, code: Code.AutomationFailed });
+      return String(raw || "").slice(start).trim();
+    } catch (error) {
+      lastError = error;
+      Logger.useTemplate().adbRetry({ label: "uiautomator dump", attempt, message: error?.message || String(error) });
+      await sleep(350 * attempt);
+    } finally {
+      await adbShell(ctx, ["rm", "-f", dumpPath], { timeoutMs: 1e4 }).catch(() => {
+      });
+    }
+  }
+  throw CrawlerError.isCrawlerError(lastError) ? lastError : new CrawlerError({
+    message: `automation_failed: uiautomator dump failed ${lastError?.message || String(lastError || "")}`.trim(),
+    code: Code.AutomationFailed,
+    context: { lastError: lastError?.message || String(lastError || "") }
+  });
+}
+async function wakeAndUnlock(ctx) {
+  await pressKey(ctx, "KEYCODE_WAKEUP").catch(() => {
+  });
+  await sleep(300);
+  await pressKey(ctx, "MENU").catch(() => {
+  });
+  await sleep(300);
+  const size = await screenSize(ctx);
+  await swipe(ctx, { x: size.width * 0.5, y: size.height * 0.82 }, { x: size.width * 0.5, y: size.height * 0.25 }, 350).catch(() => {
+  });
+  await sleep(600);
+}
+async function isKeyboardVisible(ctx) {
+  const out = await adbShell(ctx, ["dumpsys", "input_method"], { timeoutMs: 15e3, maxBuffer: 4 * 1024 * 1024 });
+  return /mInputShown=true|mIsInputViewShown=true|inputShown=true/i.test(String(out || ""));
+}
+async function hideKeyboard(ctx, options = {}) {
+  const attempts = Math.max(1, Math.trunc(Number(options.attempts || 2)));
+  for (let i = 0; i < attempts; i += 1) {
+    if (!await isKeyboardVisible(ctx).catch(() => false)) return true;
+    await pressBack(ctx).catch(() => {
+    });
+    await sleep(Number(options.settleMs || 400));
+  }
+  return !await isKeyboardVisible(ctx).catch(() => false);
+}
+async function execAdbWithRetry(adbPath, args, options = {}) {
+  const attempts = Math.max(1, Math.trunc(Number(options.attempts || DEFAULT_ADB_ATTEMPTS)));
+  const delayMs = Math.max(0, Number(options.retryDelayMs || DEFAULT_ADB_RETRY_DELAY_MS));
+  const commandArgs = args.map(String);
+  let lastError = null;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      return await execFileAsync(adbPath, commandArgs, {
+        timeout: Number(options.timeoutMs || 15e3),
+        maxBuffer: Number(options.maxBuffer || 12 * 1024 * 1024),
+        encoding: options.encoding || "utf8"
+      });
+    } catch (error) {
+      lastError = error;
+      if (attempt >= attempts || !isRetryableAdbError(error)) {
+        throw error;
+      }
+      Logger.useTemplate().adbRetry({
+        label: options.label || "adb",
+        attempt,
+        attempts,
+        args: compactArgs(args),
+        message: error?.message || String(error)
+      });
+      await sleep(delayMs * attempt);
+    }
+  }
+  throw lastError;
+}
+function requireDeviceField(ctx, key) {
+  return requireValue(ctx?.[key], key);
+}
+function appDataDir(ctx) {
+  return `/data/data/${requireDeviceField(ctx, "packageName")}`;
+}
+function cleanCachePathName(value, name) {
+  const text2 = requireValue(value, name);
+  if (text2.includes("/") || text2.includes("\\") || text2 === "." || text2 === "..") {
+    throw new CrawlerError({ message: `invalid_request: invalid cache ${name}`, code: Code.InvalidRequest });
+  }
+  return text2;
+}
+function requireValue(value, name) {
+  const clean = String(value ?? "").trim();
+  if (!clean) throw new CrawlerError({ message: `invalid_request: ${name} is required`, code: Code.InvalidRequest });
+  return clean;
+}
+function isAdbUnavailableError(error) {
+  const message = String(error?.message || error || "");
+  return /ENOENT|spawn .*adb|device .* not found|no devices|offline/i.test(message);
+}
+function isAdbInputTimeout(error) {
+  const message = String(error?.message || error || "");
+  return /timed out|timeout|SIGTERM|killed/i.test(message) || error?.signal === "SIGTERM" || error?.killed === true;
+}
+function isRetryableAdbError(error) {
+  const message = String(error?.message || error || "");
+  return isAdbInputTimeout(error) || /device .* not found|no devices|offline|closed|broken pipe|protocol fault|transport/i.test(message);
+}
+function compactArgs(args) {
+  return args.map(String).join(" ").slice(0, 500);
+}
+function parseResolvedLauncherComponent(output, packageName) {
+  const prefix = `${packageName}/`;
+  const lines = String(output || "").replace(/\r/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index];
+    if (line.startsWith(prefix) && /^[^\s/]+\/[^\s/]+$/.test(line)) return line;
+  }
+  return "";
+}
+function assertActivityStartOk(output, component) {
+  const text2 = String(output || "");
+  const status = /^\s*Status:\s*([^\s]+)/im.exec(text2)?.[1];
+  const failed = /(^|\n)\s*(Error type \d+|Error:|Exception occurred|SecurityException|java\.[A-Za-z.]*Exception)/i.test(text2) || status && status.toLowerCase() !== "ok";
+  if (!failed) return;
+  throw new CrawlerError({
+    message: `automation_failed: am start failed component=${component} output=${compactOutput(text2)}`,
+    code: Code.AutomationFailed,
+    context: { component, output: compactOutput(text2, 2e3) }
+  });
+}
+function compactOutput(value, maxLength = 500) {
+  return String(value || "").replace(/\s+/g, " ").trim().slice(0, maxLength);
+}
+function encodeUnicodeImeText(text2) {
+  let out = "";
+  let buffer = "";
+  const flush = () => {
+    if (!buffer) return;
+    const bytes = Buffer.alloc(buffer.length * 2);
+    for (let index = 0; index < buffer.length; index += 1) {
+      bytes.writeUInt16BE(buffer.charCodeAt(index), index * 2);
+    }
+    out += `&${bytes.toString("base64").replace(/\//g, ",").replace(/=+$/g, "")}-`;
+    buffer = "";
+  };
+  for (const char of String(text2 || "")) {
+    const code = char.charCodeAt(0);
+    if (code >= 32 && code <= 126) {
+      flush();
+      out += char === "&" ? "&-" : char;
+    } else {
+      buffer += char;
+    }
+  }
+  flush();
+  return out;
+}
+async function sendUnicodeImeText(ctx, encoded, options = {}) {
+  await adbShell(ctx, ["input", "text", shellQuoteForRemote(encoded)], options);
+}
+function shellQuoteForRemote(value) {
+  return `'${String(value ?? "").replace(/'/g, `'\\''`)}'`;
+}
+function normalizeAppiumClipboardBroadcast(value) {
+  const out = String(value || "");
+  if (!/Broadcast completed:\s*result=-1\b/.test(out)) return "";
+  const match = /data="([^"]*)"/.exec(out) || /data=([^\s]+)/.exec(out);
+  const base64 = match ? String(match[1] || "").trim() : "";
+  if (!base64) return "";
+  try {
+    return Buffer.from(base64, "base64").toString("utf8").trim();
+  } catch {
+    return "";
+  }
+}
+var $DeviceInternalsForTest = Object.freeze({
+  isAdbInputTimeout,
+  isRetryableAdbError,
+  encodeUnicodeImeText,
+  shellQuoteForRemote
+});
+
+// src/apify-kit.js
+var { decycle } = import_json_cycle.default;
+var instance = null;
+var ApifyKit = {
+  useApifyKit
+};
+async function useApifyKit(options = {}) {
+  if (!instance || options.reset) {
+    instance = createApifyKit(options);
+  }
+  return instance;
+}
+function createApifyKit(options = {}) {
+  const inputPath = StoragePath.Input;
+  const outputPath = options.outputPath || StoragePath.Output;
+  const input = options.input || JSON.parse(import_node_fs.default.readFileSync(inputPath, "utf8"));
+  const ctx = options.ctx || Context.createAndroidContext(input, options.contextDefaults || {});
+  const logTemplate = Logger.useTemplate();
+  let pushed = false;
+  return {
+    ctx,
+    input,
+    inputPath,
+    outputPath,
+    async runStep(step, target, actionFn, options2 = {}) {
+      const { failActor = true, retry = {} } = options2;
+      const retryTimes = Math.max(0, Number(retry.times || 0));
+      const startedAt = Date.now();
+      let lastError = null;
+      for (let attempt = 0; attempt <= retryTimes; attempt += 1) {
+        const attemptLabel = attempt > 0 ? ` (\u91CD\u8BD5 #${attempt})` : "";
+        if (attempt > 0) logTemplate.stepRetry(step, attempt);
+        logTemplate.stepStart(`${step}${attemptLabel}`, stepDetail(target));
+        try {
+          const result = await actionFn();
+          logTemplate.stepSuccess(`${step}${attemptLabel}`, { duration: Logger.duration(startedAt) });
+          return result;
+        } catch (error) {
+          lastError = error;
+          logTemplate.stepFail(`${step}${attemptLabel}`, error);
+          if (attempt < retryTimes) {
+            if (typeof retry.before === "function") {
+              await retry.before(ctx, attempt + 1);
+            } else {
+              await sleep(3e3);
+            }
+          }
+        }
+      }
+      if (failActor) {
+        let base64 = "";
+        try {
+          base64 = await Device.screenshotBase64(ctx);
+        } catch (error) {
+          base64 = `\u622A\u56FE\u5931\u8D25: ${error?.message || String(error)}`;
+        }
+        await this.pushFailed(lastError, { step, base64, retryAttempts: retryTimes });
+      }
+      throw lastError;
+    },
+    async runStepLoose(step, target, actionFn, options2 = {}) {
+      return this.runStep(step, target, actionFn, { ...options2, failActor: false });
+    },
+    async pushSuccess(data = {}, options2 = {}) {
+      pushed = true;
+      appendOutput(outputPath, {
+        code: Number.isFinite(Number(options2.code)) ? Number(options2.code) : Code.Success,
+        status: Status.Success,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: sanitizeData(data),
+        ...options2.meta ? { meta: sanitizeData(options2.meta) } : {}
+      });
+      logTemplate.dataPush({ type: "success", outputPath, keys: Object.keys(data || {}).join(",") });
+    },
+    async pushArtifact(data = {}) {
+      appendOutput(outputPath, sanitizeData(data));
+      logTemplate.dataPush({ type: "artifact", outputPath, keys: Object.keys(data || {}).join(",") });
+    },
+    async pushFailed(error, meta = {}) {
+      const normalized = CrawlerError.isCrawlerError(error) ? error : CrawlerError.from(error, { code: Code.UnknownError, context: meta });
+      pushed = true;
+      appendOutput(outputPath, {
+        code: normalized.code,
+        status: Status.Failed,
+        error: sanitizeData(serializeError(normalized)),
+        meta: sanitizeData(meta),
+        context: sanitizeData(normalized.context),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      logTemplate.dataPush({ type: "failed", outputPath, code: normalized.code, message: normalized.message });
+    },
+    hasPushed() {
+      return pushed;
+    }
+  };
+}
+function appendOutput(outputPath, item) {
+  const items = readOutputArray(outputPath);
+  items.push(item);
+  import_node_fs.default.writeFileSync(outputPath, JSON.stringify(items, null, 2) + "\n", "utf8");
+}
+function readOutputArray(outputPath) {
+  if (!import_node_fs.default.existsSync(outputPath)) return [];
+  const raw = import_node_fs.default.readFileSync(outputPath, "utf8").trim();
+  if (!raw) return [];
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) throw new Error(`Android output must be a JSON array: ${outputPath}`);
+  return parsed;
+}
+function stepDetail(target) {
+  if (!target) return {};
+  if (typeof target === "string") return { target };
+  if (typeof target === "object") {
+    return {
+      serial: target.serial,
+      packageName: target.packageName,
+      runId: target.runId
+    };
+  }
+  return { target: String(target) };
+}
+function sanitizeData(value) {
+  return decycle(prepareForJson(value, /* @__PURE__ */ new WeakMap()));
+}
+function prepareForJson(value, seen) {
+  if (value == null) return value;
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") return value;
+  if (type === "bigint") return value.toString();
+  if (type === "function" || type === "symbol") return void 0;
+  if (type !== "object") return String(value);
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Error) {
+    const out2 = {};
+    seen.set(value, out2);
+    copyEntries(out2, serializeError(value), seen);
+    return out2;
+  }
+  if (Array.isArray(value)) {
+    const out2 = [];
+    seen.set(value, out2);
+    for (const item of value) {
+      const safe = prepareForJson(item, seen);
+      out2.push(safe === void 0 ? null : safe);
+    }
+    return out2;
+  }
+  if (value instanceof Map) {
+    const out2 = [];
+    seen.set(value, out2);
+    for (const [key, item] of value.entries()) {
+      out2.push([prepareForJson(key, seen), prepareForJson(item, seen)]);
+    }
+    return out2;
+  }
+  if (value instanceof Set) {
+    const out2 = [];
+    seen.set(value, out2);
+    for (const item of value.values()) {
+      const safe = prepareForJson(item, seen);
+      out2.push(safe === void 0 ? null : safe);
+    }
+    return out2;
+  }
+  const out = {};
+  seen.set(value, out);
+  copyEntries(out, value, seen);
+  return out;
+}
+function copyEntries(out, value, seen) {
+  for (const [key, item] of Object.entries(value)) {
+    const safe = prepareForJson(item, seen);
+    if (safe !== void 0) out[key] = safe;
+  }
+}
+
+// src/device-input.js
+var import_node_crypto2 = require("node:crypto");
+
+// src/device-view.js
+var import_node_crypto = require("node:crypto");
+var import_fast_xml_parser = require("fast-xml-parser");
+var parser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "",
+  allowBooleanAttributes: true
+});
+var DeviceView = {
+  snapshot,
+  find,
+  findAll,
+  waitFor,
+  bounds,
+  text,
+  exists,
+  isScrollable,
+  hashNode,
+  normalizeSelector
+};
+async function snapshot(ctx, options = {}) {
+  const xml = options.xml || await Device.dumpUiXml(ctx);
+  const parsed = parser.parse(xml);
+  const roots = toArray(parsed?.hierarchy?.node).map((node) => normalizeNode(node, null, 0));
+  const flat = [];
+  for (const root of roots) collectFlat(root, flat);
+  return { xml, tree: roots, roots, flat, nodes: flat };
+}
+async function find(ctx, selector, options = {}) {
+  const nodes = await findAll(ctx, selector, options);
+  if (nodes.length > 0) return nodes[0];
+  if (options.optional) return null;
+  throw new CrawlerError({
+    message: `automation_failed: View \u672A\u627E\u5230 ${selectorLabel(selector)}`,
+    code: Code.AutomationFailed,
+    context: { selector }
+  });
+}
+async function findAll(ctx, selector, options = {}) {
+  const view = options.snapshot || await snapshot(ctx, options);
+  const normalized = normalizeSelector(selector);
+  return view.flat.filter((node) => matchesSelector(node, normalized, options));
+}
+async function waitFor(ctx, selector, options = {}) {
+  const timeoutMs = Number(options.timeoutMs || options.timeout || 3e4);
+  const intervalMs = Number(options.intervalMs || options.pollIntervalMs || 500);
+  const deadline = Date.now() + timeoutMs;
+  let lastError = null;
+  let sawCleanPoll = false;
+  while (Date.now() < deadline) {
+    try {
+      const node = await find(ctx, selector, { ...options, optional: true });
+      sawCleanPoll = true;
+      lastError = null;
+      if (node) return node;
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(intervalMs);
+  }
+  if (lastError && !sawCleanPoll) throw lastError;
+  throw new CrawlerError({
+    message: `automation_failed: \u7B49\u5F85 View \u8D85\u65F6 ${selectorLabel(selector)}`,
+    code: Code.AutomationFailed,
+    context: { selector, timeoutMs }
+  });
+}
+async function bounds(ctx, selector, options = {}) {
+  return (await find(ctx, selector, options)).bounds;
+}
+async function text(ctx, selector, options = {}) {
+  const node = await find(ctx, selector, options);
+  return node.text || node.contentDesc || "";
+}
+async function exists(ctx, selector, options = {}) {
+  return Boolean(await find(ctx, selector, { ...options, optional: true }));
+}
+async function isScrollable(ctx, selector, options = {}) {
+  const node = await find(ctx, selector, options);
+  return Boolean(node.scrollable);
+}
+function normalizeSelector(selector) {
+  if (!selector || typeof selector !== "object" || Array.isArray(selector)) {
+    throw new CrawlerError({
+      message: "invalid_request: DeviceView selector must be an object",
+      code: Code.InvalidRequest,
+      context: { selector }
+    });
+  }
+  const out = {};
+  for (const key of ["id", "text", "textContains", "contentDesc", "className"]) {
+    if (selector[key] != null && String(selector[key]).trim()) out[key] = String(selector[key]).trim();
+  }
+  if (Object.keys(out).length === 0) {
+    throw new CrawlerError({
+      message: "invalid_request: DeviceView selector requires id/text/textContains/contentDesc/className",
+      code: Code.InvalidRequest,
+      context: { selector }
+    });
+  }
+  return out;
+}
+function hashNode(node) {
+  return (0, import_node_crypto.createHash)("sha256").update(stableNodeString(node)).digest("hex");
+}
+function normalizeNode(raw, parent, index) {
+  const childrenRaw = toArray(raw?.node);
+  const bounds2 = parseBounds(raw?.bounds);
+  const node = {
+    resourceId: String(raw?.["resource-id"] || ""),
+    id: shortResourceId(raw?.["resource-id"]),
+    text: String(raw?.text || ""),
+    contentDesc: String(raw?.["content-desc"] || ""),
+    className: String(raw?.class || ""),
+    packageName: String(raw?.package || ""),
+    bounds: bounds2,
+    clickable: toBoolean(raw?.clickable),
+    enabled: toBoolean(raw?.enabled),
+    focusable: toBoolean(raw?.focusable),
+    focused: toBoolean(raw?.focused),
+    scrollable: toBoolean(raw?.scrollable),
+    visible: bounds2.right > bounds2.left && bounds2.bottom > bounds2.top,
+    index: Number(raw?.index ?? index),
+    parent: null,
+    children: []
+  };
+  node.parent = parent || null;
+  node.children = childrenRaw.map((child, childIndex) => normalizeNode(child, node, childIndex));
+  return node;
+}
+function matchesSelector(node, selector, options = {}) {
+  if (options.visibleOnly !== false && !node.visible) return false;
+  if (options.enabledOnly === true && !node.enabled) return false;
+  if (selector.id && !matchesId(node, selector.id)) return false;
+  if (selector.text && node.text !== selector.text) return false;
+  if (selector.textContains && !node.text.includes(selector.textContains)) return false;
+  if (selector.contentDesc && node.contentDesc !== selector.contentDesc) return false;
+  if (selector.className && node.className !== selector.className) return false;
+  return true;
+}
+function matchesId(node, expected) {
+  const actual = node.resourceId || "";
+  if (!actual) return false;
+  if (actual === expected) return true;
+  return actual.endsWith(`:id/${expected}`) || node.id === expected;
+}
+function collectFlat(node, out) {
+  out.push(node);
+  for (const child of node.children) collectFlat(child, out);
+}
+function toArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function parseBounds(value) {
+  const match = /\[(\d+),(\d+)]\[(\d+),(\d+)]/.exec(String(value || ""));
+  if (!match) return { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0, centerX: 0, centerY: 0 };
+  const left = Number(match[1]);
+  const top = Number(match[2]);
+  const right = Number(match[3]);
+  const bottom = Number(match[4]);
+  return {
+    left,
+    top,
+    right,
+    bottom,
+    width: Math.max(0, right - left),
+    height: Math.max(0, bottom - top),
+    centerX: (left + right) / 2,
+    centerY: (top + bottom) / 2
+  };
+}
+function shortResourceId(value) {
+  const raw = String(value || "");
+  const marker = ":id/";
+  const index = raw.indexOf(marker);
+  return index >= 0 ? raw.slice(index + marker.length) : raw;
+}
+function toBoolean(value) {
+  return value === true || String(value).toLowerCase() === "true";
+}
+function stableNodeString(node) {
+  if (!node) return "";
+  return JSON.stringify({
+    resourceId: node.resourceId,
+    text: node.text,
+    contentDesc: node.contentDesc,
+    className: node.className,
+    bounds: node.bounds,
+    clickable: node.clickable,
+    enabled: node.enabled,
+    focusable: node.focusable,
+    focused: node.focused,
+    scrollable: node.scrollable,
+    children: node.children.map((child) => JSON.parse(stableNodeString(child) || "{}"))
+  });
+}
+function selectorLabel(selector) {
+  try {
+    return JSON.stringify(selector);
+  } catch {
+    return String(selector);
+  }
+}
+
+// src/device-input.js
+var SCROLL_MAX_SWIPES = 24;
+var SCROLL_STABLE_ROUNDS = 1;
+var SCROLL_SWIPE_RATIO = 0.72;
+var SCROLL_DURATION_MS = 360;
+var SCROLL_SETTLE_MS = 500;
+var SCROLL_HASH_SOURCE = "screenshot";
+var SCROLL_IDLE_SETTLE_MS = 900;
+var DeviceInput = {
+  click,
+  tap: click,
+  fill,
+  type: fill,
+  press,
+  pressEnter: pressEnter2,
+  scroll,
+  scrollStep,
+  scrollToEnd,
+  scrollToTop
+};
+async function click(ctx, selectorOrPoint, options = {}) {
+  if (isPoint(selectorOrPoint)) {
+    await Device.tapAbsolute(ctx, selectorOrPoint.x, selectorOrPoint.y);
+    await sleep(Number(options.settleMs || 250));
+    return { point: selectorOrPoint };
+  }
+  if (isBounds(selectorOrPoint)) {
+    const point2 = centerOf(selectorOrPoint);
+    await Device.tapAbsolute(ctx, point2.x, point2.y);
+    await sleep(Number(options.settleMs || 250));
+    return { point: point2 };
+  }
+  const target = await DeviceView.find(ctx, selectorOrPoint, options);
+  const actual = nearestClickable(target);
+  if (!actual) {
+    throw new CrawlerError({
+      message: `automation_failed: View \u4E0D\u53EF\u70B9\u51FB ${JSON.stringify(selectorOrPoint)}`,
+      code: Code.AutomationFailed,
+      context: { selector: selectorOrPoint, target: simplifyNode(target) }
+    });
+  }
+  const point = centerOf(actual.bounds);
+  Logger.info("DeviceInput.click", {
+    selector: selectorOrPoint,
+    target: simplifyNode(target),
+    actual: simplifyNode(actual),
+    point
+  });
+  await Device.tapAbsolute(ctx, point.x, point.y);
+  await sleep(Number(options.settleMs || 250));
+  return { target, actual, point };
+}
+async function fill(ctx, selector, text2, options = {}) {
+  const value = String(text2 ?? "");
+  const clicked = await click(ctx, selector, {
+    ...options,
+    settleMs: Number(options.focusSettleMs || 350)
+  });
+  try {
+    await Device.typeText(ctx, value);
+  } catch (error) {
+    throw new CrawlerError({
+      message: `automation_failed: View \u5199\u5165\u6587\u672C\u5931\u8D25 ${JSON.stringify(selector)}`,
+      code: Code.AutomationFailed,
+      context: { selector, error: error?.message || String(error) }
+    });
+  }
+  Logger.info("DeviceInput.fill", {
+    selector,
+    target: simplifyNode(clicked.actual || clicked.target),
+    chars: value.length
+  });
+  await sleep(Number(options.settleMs || 350));
+  return { target: clicked.actual || clicked.target, chars: value.length };
+}
+async function press(ctx, key) {
+  await Device.pressKey(ctx, key);
+}
+async function pressEnter2(ctx) {
+  await Device.pressEnter(ctx);
+}
+async function scroll(ctx, selector, direction, options = {}) {
+  const node = await DeviceView.find(ctx, selector, options);
+  await scrollBounds(ctx, node.bounds, direction, {});
+}
+async function scrollStep(ctx, selector, direction, options = {}) {
+  const node = await DeviceView.find(ctx, selector, options);
+  await scrollBounds(ctx, node.bounds, direction, options);
+}
+async function scrollBounds(ctx, bounds2, direction, options = {}) {
+  const box = bounds2;
+  const ratio = Number(options.swipeRatio || SCROLL_SWIPE_RATIO);
+  const durationMs = Number(options.durationMs || SCROLL_DURATION_MS);
+  const x = box.centerX;
+  const distance = Math.max(40, box.height * ratio);
+  const down = String(direction || "").toLowerCase() === "down";
+  const from = {
+    x,
+    y: down ? box.top + box.height * 0.25 : box.bottom - box.height * 0.25
+  };
+  const to = {
+    x,
+    y: down ? Math.min(box.bottom - 10, from.y + distance) : Math.max(box.top + 10, from.y - distance)
+  };
+  await Device.swipe(ctx, from, to, durationMs);
+  await sleep(Number(options.settleMs || SCROLL_SETTLE_MS));
+}
+async function scrollToEnd(ctx, selector, options = {}) {
+  return scrollUntilStable(ctx, selector, "up", options);
+}
+async function scrollToTop(ctx, selector, options = {}) {
+  return scrollUntilStable(ctx, selector, "down", options);
+}
+async function scrollUntilStable(ctx, selector, direction, options = {}) {
+  const maxSwipes = SCROLL_MAX_SWIPES;
+  const stableRoundsTarget = SCROLL_STABLE_ROUNDS;
+  const node = await DeviceView.find(ctx, selector, options);
+  const bounds2 = node.bounds;
+  let lastHash = await scrollStateHash(ctx);
+  let stableRounds = 0;
+  for (let index = 0; index < maxSwipes; index += 1) {
+    await scrollBounds(ctx, bounds2, direction, options);
+    const currentHash = await scrollStateHash(ctx);
+    if (currentHash === lastHash) {
+      stableRounds += 1;
+      if (stableRounds >= stableRoundsTarget) {
+        return { swipes: index + 1, stableRounds, hash: currentHash, hashSource: SCROLL_HASH_SOURCE, capped: false };
+      }
+    } else {
+      stableRounds = 0;
+      lastHash = currentHash;
+    }
+  }
+  const idle = await confirmScrollIdle(ctx, lastHash, options);
+  if (idle.stable) {
+    return {
+      swipes: maxSwipes,
+      stableRounds: stableRoundsTarget,
+      hash: idle.hash,
+      hashSource: `${SCROLL_HASH_SOURCE}:idle`,
+      capped: false,
+      inferredBoundary: true
+    };
+  }
+  return { swipes: maxSwipes, stableRounds, hash: lastHash, hashSource: SCROLL_HASH_SOURCE, capped: true };
+}
+async function scrollStateHash(ctx) {
+  const png = await Device.screenshotPng(ctx);
+  return (0, import_node_crypto2.createHash)("sha256").update(png).digest("hex");
+}
+async function confirmScrollIdle(ctx, previousHash, options = {}) {
+  const settleMs = Number(options.idleSettleMs || SCROLL_IDLE_SETTLE_MS);
+  await sleep(settleMs);
+  const hash = await scrollStateHash(ctx);
+  if (hash !== previousHash) return { stable: false, hash };
+  return { stable: true, hash };
+}
+function nearestClickable(node) {
+  let current = node;
+  while (current) {
+    if (current.visible && current.enabled && current.clickable) return current;
+    current = current.parent;
+  }
+  return null;
+}
+function isPoint(value) {
+  return value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
+}
+function isBounds(value) {
+  return value && typeof value === "object" && Number.isFinite(Number(value.left)) && Number.isFinite(Number(value.top)) && Number.isFinite(Number(value.right)) && Number.isFinite(Number(value.bottom));
+}
+function centerOf(bounds2) {
+  return {
+    x: (Number(bounds2.left) + Number(bounds2.right)) / 2,
+    y: (Number(bounds2.top) + Number(bounds2.bottom)) / 2
+  };
+}
+function simplifyNode(node) {
+  if (!node) return null;
+  return {
+    id: node.id,
+    resourceId: node.resourceId,
+    text: node.text,
+    contentDesc: node.contentDesc,
+    className: node.className,
+    clickable: node.clickable,
+    enabled: node.enabled,
+    bounds: node.bounds
+  };
+}
+
+// src/device-sqlite.js
+var import_node_child_process2 = require("node:child_process");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_util2 = require("node:util");
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var DeviceSQLite = {
+  query,
+  health
+};
+async function query(ctx, options = {}) {
+  if (!options.sql) {
+    throw new CrawlerError({
+      message: "invalid_request: sql is required",
+      code: Code.InvalidRequest
+    });
+  }
+  const config = {
+    dbPath: String(options.dbPath || ""),
+    dbDir: String(options.dbDir || ""),
+    dbNamePrefix: String(options.dbNamePrefix || ""),
+    dbNameIncludes: String(options.dbNameIncludes || ""),
+    dbNameExcludes: normalizeStringArray(options.dbNameExcludes),
+    sql: String(options.sql || ""),
+    args: normalizeStringArray(options.args),
+    maxRows: Math.max(1, Number(options.maxRows || 200)),
+    label: String(options.label || "query-sqlite")
+  };
+  if (!config.dbPath && !config.dbDir) {
+    throw new CrawlerError({
+      message: "invalid_request: dbPath or dbDir is required",
+      code: Code.InvalidRequest
+    });
+  }
+  const startedAt = Date.now();
+  const dir = await (0, import_promises.mkdtemp)(import_node_path.default.join((0, import_node_os.tmpdir)(), "android-toolkit-sqlite-"));
+  try {
+    const dbPaths = await resolveDeviceDbPaths(ctx, config);
+    if (dbPaths.length === 0) {
+      throw new CrawlerError({
+        message: "app_runtime_unavailable: sqlite database not found",
+        code: Code.AppRuntimeUnavailable,
+        context: { dbDir: config.dbDir, dbPath: config.dbPath, dbNamePrefix: config.dbNamePrefix }
+      });
+    }
+    const databases = [];
+    for (const dbPath of dbPaths) {
+      const localDbPath = await pullDatabaseSnapshot(ctx, dbPath, dir);
+      const result = await queryLocalSQLite(localDbPath, config);
+      databases.push({
+        dbPath,
+        columns: result.columns,
+        rows: result.rows,
+        rowCount: result.rows.length,
+        truncated: result.truncated
+      });
+    }
+    Logger.info("DeviceSQLite.query", {
+      label: config.label,
+      databaseCount: databases.length,
+      rowCount: databases.reduce((total, item) => total + item.rowCount, 0),
+      duration: Logger.duration(startedAt)
+    });
+    return { ok: true, databases, rows: databases.length === 1 ? databases[0].rows : [] };
+  } finally {
+    await (0, import_promises.rm)(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function health(ctx, options = {}) {
+  const packageName = String(options.packageName || ctx?.packageName || "").trim();
+  if (!packageName) {
+    throw new CrawlerError({
+      message: "invalid_request: packageName is required",
+      code: Code.InvalidRequest
+    });
+  }
+  await adbSuShell(ctx, `test -d ${shellQuote(`/data/data/${packageName}`)}`, {
+    timeoutMs: Number(options.timeoutMs || 1e4)
+  });
+  return { ok: true, packageName };
+}
+async function resolveDeviceDbPaths(ctx, config) {
+  if (config.dbPath) return [config.dbPath];
+  const command = `cd ${shellQuote(config.dbDir)} || exit 1; for file in *; do [ -f "$file" ] || continue; case "$file" in *-wal|*-shm) continue ;; esac; printf "%s\\n" "$file"; done`;
+  const out = await adbSuShell(ctx, command, {
+    timeoutMs: 15e3,
+    maxBuffer: 2 * 1024 * 1024
+  }).catch((error) => {
+    throw new CrawlerError({
+      message: `app_runtime_unavailable: sqlite dbDir unavailable ${error?.message || String(error)}`,
+      code: Code.AppRuntimeUnavailable,
+      context: { dbDir: config.dbDir }
+    });
+  });
+  return String(out || "").split("\n").map((line) => line.trim()).filter(Boolean).filter((name) => matchesName(name, config)).map((name) => `${config.dbDir.replace(/\/+$/, "")}/${name}`).sort();
+}
+async function pullDatabaseSnapshot(ctx, dbPath, localDir) {
+  const baseName = import_node_path.default.basename(dbPath);
+  const remoteDir = `/data/local/tmp/android-toolkit-sqlite-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const remoteDb = `${remoteDir}/${baseName}`;
+  const localDb = import_node_path.default.join(localDir, baseName);
+  const copyCommand = [
+    `rm -rf ${shellQuote(remoteDir)}`,
+    `mkdir -p ${shellQuote(remoteDir)}`,
+    `cp ${shellQuote(dbPath)} ${shellQuote(remoteDb)}`,
+    `[ -f ${shellQuote(`${dbPath}-wal`)} ] && cp ${shellQuote(`${dbPath}-wal`)} ${shellQuote(`${remoteDb}-wal`)} || true`,
+    `[ -f ${shellQuote(`${dbPath}-shm`)} ] && cp ${shellQuote(`${dbPath}-shm`)} ${shellQuote(`${remoteDb}-shm`)} || true`,
+    `chmod 644 ${shellQuote(remoteDir)}/*`
+  ].join(" && ");
+  try {
+    await adbSuShell(ctx, copyCommand, { timeoutMs: 3e4, maxBuffer: 4 * 1024 * 1024 });
+    await adbPull(ctx, remoteDb, localDb).catch((error) => {
+      throw new CrawlerError({
+        message: `app_runtime_unavailable: sqlite snapshot pull failed ${error?.message || String(error)}`,
+        code: Code.AppRuntimeUnavailable,
+        context: { dbPath }
+      });
+    });
+    await adbPullOptional(ctx, `${remoteDb}-wal`, `${localDb}-wal`);
+    await adbPullOptional(ctx, `${remoteDb}-shm`, `${localDb}-shm`);
+    return localDb;
+  } finally {
+    await adbSuShell(ctx, `rm -rf ${shellQuote(remoteDir)}`, { timeoutMs: 1e4 }).catch(() => {
+    });
+  }
+}
+async function adbSuShell(ctx, command, options = {}) {
+  return Device.adbShell(ctx, [`su -c ${shellQuote(command)}`], options);
+}
+async function queryLocalSQLite(dbPath, config) {
+  const payloadPath = `${dbPath}.query.json`;
+  const outputPath = `${dbPath}.rows.json`;
+  await (0, import_promises.writeFile)(payloadPath, JSON.stringify({
+    dbPath,
+    sql: config.sql,
+    args: config.args,
+    maxRows: config.maxRows,
+    outputPath
+  }), "utf8");
+  const code = `
+const fs = require('node:fs');
+const { DatabaseSync } = require('node:sqlite');
+const payload = JSON.parse(fs.readFileSync(process.argv[1], 'utf8'));
+const db = new DatabaseSync(payload.dbPath, { open: true, readOnly: true });
+try {
+  const stmt = db.prepare(payload.sql);
+  const columns = stmt.columns().map((column) => String(column.name || ''));
+  const rows = [];
+  let truncated = false;
+  for (const row of stmt.iterate(...payload.args)) {
+    if (rows.length >= payload.maxRows) { truncated = true; break; }
+    const out = {};
+    for (const column of columns) out[column] = row[column] == null ? '' : String(row[column]);
+    rows.push(out);
+  }
+  fs.writeFileSync(payload.outputPath, JSON.stringify({ columns, rows, truncated }), 'utf8');
+} finally {
+  db.close();
+}
+`;
+  await execFileAsync2(process.execPath, ["-e", code, payloadPath], {
+    timeout: 3e4,
+    maxBuffer: 4 * 1024 * 1024,
+    encoding: "utf8"
+  });
+  return JSON.parse(await import("node:fs/promises").then((fs3) => fs3.readFile(outputPath, "utf8")));
+}
+async function adbPull(ctx, remotePath, localPath) {
+  const serial = requireNonEmpty2(ctx?.serial, "serial");
+  await Device.adbExec(ctx, ["-s", serial, "pull", remotePath, localPath], {
+    timeoutMs: 3e4,
+    maxBuffer: 8 * 1024 * 1024,
+    label: "adb pull"
+  });
+}
+async function adbPullOptional(ctx, remotePath, localPath) {
+  await adbPull(ctx, remotePath, localPath).catch(() => {
+  });
+}
+function matchesName(name, config) {
+  if (config.dbNamePrefix && !name.startsWith(config.dbNamePrefix)) return false;
+  if (config.dbNameIncludes && !name.includes(config.dbNameIncludes)) return false;
+  for (const item of config.dbNameExcludes || []) {
+    if (item && name.includes(item)) return false;
+  }
+  return true;
+}
+function normalizeStringArray(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item ?? ""));
+  if (value == null) return [];
+  return [String(value)];
+}
+function requireNonEmpty2(value, name) {
+  const clean = String(value ?? "").trim();
+  if (!clean) throw new CrawlerError({ message: `invalid_request: ${name} is required`, code: Code.InvalidRequest });
+  return clean;
+}
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+// src/launch.js
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+
+// src/webview.js
+var import_node_crypto3 = require("node:crypto");
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_STABLE_TIME_MS = 5e3;
+var DEFAULT_POLL_INTERVAL_MS = 500;
+var WebView = {
+  configureHook,
+  evaluate,
+  list,
+  snapshot: snapshot2,
+  waitForStable,
+  click: click2
+};
+async function configureHook(ctx, actorInfo, options = {}) {
+  const webviews = Array.isArray(actorInfo?.webviews) ? actorInfo.webviews : [];
+  if (webviews.length === 0) return false;
+  const packageName = requireNonEmpty3(ctx?.packageName, "packageName");
+  const dataDir = appDataDir2(packageName);
+  const baseDir = `${dataDir}/cache/${WebViewBridge.cacheDir}`;
+  const configPath = `${baseDir}/${WebViewBridge.hookConfigFile}`;
+  const configJson = JSON.stringify({ webviews });
+  await Device.writeCacheFile(ctx, {
+    dirName: WebViewBridge.cacheDir,
+    fileName: WebViewBridge.hookConfigFile,
+    text: configJson,
+    timeoutMs: Math.max(5e3, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS)),
+    maxBuffer: 2 * 1024 * 1024
+  }).catch((error) => {
+    throw new CrawlerError({
+      message: `app_runtime_unavailable: WebView hook \u914D\u7F6E\u5199\u5165\u5931\u8D25 ${error?.message || String(error)}`,
+      code: Code.AppRuntimeUnavailable,
+      context: { configPath }
+    });
+  });
+  return true;
+}
+async function list(ctx, options = {}) {
+  const command = {
+    id: String(options.id || (0, import_node_crypto3.randomUUID)()),
+    action: "list",
+    urlIncludes: normalizeStringArray2(options.webviews || options.urlIncludes || options.actorInfo?.webviews),
+    timeoutMs: Math.max(1, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS))
+  };
+  const result = normalizeBridgeResult(await runBridgeCommand(ctx, command, options));
+  if (!result.ok) {
+    throw new CrawlerError({
+      message: `app_runtime_unavailable: WebView bridge \u5217\u8868\u8BFB\u53D6\u5931\u8D25 ${result.error || "unknown error"}`,
+      code: Code.AppRuntimeUnavailable,
+      context: { id: command.id }
+    });
+  }
+  const value = parseBridgeValue(result.value);
+  return Array.isArray(value) ? value : [];
+}
+async function evaluate(ctx, js, options = {}) {
+  const command = {
+    id: String(options.id || (0, import_node_crypto3.randomUUID)()),
+    action: "evaluate",
+    urlIncludes: normalizeStringArray2(options.webviews || options.urlIncludes || options.actorInfo?.webviews),
+    js: String(js || ""),
+    timeoutMs: Math.max(1, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS))
+  };
+  if (!command.js.trim()) {
+    throw new CrawlerError({
+      message: "invalid_request: WebView.evaluate \u7F3A\u5C11 js",
+      code: Code.InvalidRequest
+    });
+  }
+  const result = normalizeBridgeResult(await runBridgeCommand(ctx, command, options));
+  if (!result.ok) {
+    throw new CrawlerError({
+      message: `app_runtime_unavailable: WebView bridge \u6267\u884C\u5931\u8D25 ${result.error || "unknown error"}`,
+      code: Code.AppRuntimeUnavailable,
+      context: { id: command.id, url: result.url || "", title: result.title || "" }
+    });
+  }
+  return result;
+}
+async function snapshot2(ctx, options = {}) {
+  const result = await evaluate(ctx, `(() => ({
+        url: location.href,
+        title: document.title,
+        text: document.body ? document.body.innerText : '',
+        html: document.documentElement ? document.documentElement.outerHTML : ''
+    }))()`, options);
+  const value = parseBridgeValue(result.value);
+  const out = value && typeof value === "object" ? value : {};
+  return {
+    url: String(out.url || result.url || ""),
+    title: String(out.title || result.title || ""),
+    text: String(out.text || ""),
+    html: String(out.html || ""),
+    raw: result
+  };
+}
+async function waitForStable(ctx, options = {}) {
+  const timeout = Math.max(0, Number(options.timeout ?? options.timeoutMs ?? 12e4));
+  const stableTime = Math.max(0, Number(options.stableTime ?? DEFAULT_STABLE_TIME_MS));
+  const pollIntervalMs = Math.max(1, Number(options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS));
+  const startedAt = Date.now();
+  const deadline = timeout === 0 ? Infinity : startedAt + timeout;
+  let lastSnapshot = null;
+  let stableSince = 0;
+  let mutationCount = 0;
+  let snapshotErrorCount = 0;
+  let lastSnapshotError = null;
+  const logTemplate = Logger.useTemplate();
+  logTemplate.webViewCommand({
+    action: "waitForStable",
+    webviews: normalizeStringArray2(options.webviews || options.urlIncludes || options.actorInfo?.webviews).join(","),
+    stableTime,
+    timeout,
+    pollIntervalMs
+  });
+  while (Date.now() < deadline) {
+    const current = await snapshot2(ctx, options).catch((error) => {
+      snapshotErrorCount += 1;
+      lastSnapshotError = error;
+      if (snapshotErrorCount === 1 || snapshotErrorCount % 5 === 0) {
+        logTemplate.webViewWarn({
+          action: "waitForStable.snapshot",
+          snapshotErrorCount,
+          message: error?.message || String(error)
+        });
+      }
+      return null;
+    });
+    if (!current) {
+      await sleep(pollIntervalMs);
+      continue;
+    }
+    const hash = hashSnapshot(current);
+    const changed = !lastSnapshot || hash !== lastSnapshot.hash;
+    if (changed) {
+      if (lastSnapshot) mutationCount += 1;
+      lastSnapshot = { ...current, hash };
+      stableSince = Date.now();
+    } else if (Date.now() - stableSince >= stableTime) {
+      const result = {
+        mutationCount,
+        stableTime,
+        html: current.html,
+        text: current.text,
+        url: current.url,
+        title: current.title,
+        mutationNodes: [{
+          html: current.html,
+          text: current.text,
+          mutationType: "stable",
+          url: current.url,
+          title: current.title
+        }]
+      };
+      logTemplate.webViewSuccess({
+        action: "waitForStable",
+        duration: Logger.duration(startedAt),
+        mutationCount,
+        textChars: current.text.length,
+        htmlChars: current.html.length
+      });
+      return result;
+    }
+    await sleep(pollIntervalMs);
+  }
+  throw new CrawlerError({
+    message: `app_runtime_unavailable: WebView DOM \u7A33\u5B9A\u7B49\u5F85\u8D85\u65F6 (${timeout}ms), snapshotErrorCount=${snapshotErrorCount}, lastSnapshotError=${lastSnapshotError?.message || ""}`,
+    code: Code.AppRuntimeUnavailable
+  });
+}
+async function click2(ctx, target, options = {}) {
+  const request = target && typeof target === "object" && !Array.isArray(target) ? target : { selector: target };
+  const js = request.js || options.js || buildClickScript(request.selector, {
+    textContains: request.textContains || options.textContains,
+    last: request.last ?? options.last
+  });
+  const result = await evaluate(ctx, js, options);
+  const value = parseBridgeValue(result.value);
+  if (value === false || value?.ok === false) {
+    throw new CrawlerError({
+      message: `app_runtime_unavailable: WebView \u70B9\u51FB\u5931\u8D25 ${value?.reason || value?.error || options.label || request.selector || ""}`.trim(),
+      code: Code.AppRuntimeUnavailable,
+      context: { value }
+    });
+  }
+  Logger.useTemplate().webViewSuccess({
+    action: "click",
+    label: options.label || request.selector || "",
+    value: typeof value === "object" ? value : void 0
+  });
+  return value ?? result.value;
+}
+async function runBridgeCommand(ctx, command, options = {}) {
+  if (typeof options.commandRunner === "function") return options.commandRunner(ctx, command);
+  const packageName = requireNonEmpty3(ctx?.packageName, "packageName");
+  const dataDir = appDataDir2(packageName);
+  const baseDir = `${dataDir}/cache/${WebViewBridge.cacheDir}`;
+  const commandPath = `${baseDir}/${WebViewBridge.commandDir}/${command.id}.json`;
+  const resultPath = `${baseDir}/${WebViewBridge.resultDir}/${command.id}.json`;
+  const commandJson = JSON.stringify(command);
+  await adbSuShell2(ctx, [
+    `owner=$(stat -c %u:%g ${shellQuote2(dataDir)})`,
+    `mkdir -p ${shellQuote2(`${baseDir}/${WebViewBridge.commandDir}`)} ${shellQuote2(`${baseDir}/${WebViewBridge.resultDir}`)}`,
+    `chown "$owner" ${shellQuote2(baseDir)} ${shellQuote2(`${baseDir}/${WebViewBridge.commandDir}`)} ${shellQuote2(`${baseDir}/${WebViewBridge.resultDir}`)}`,
+    `chmod 2775 ${shellQuote2(baseDir)} ${shellQuote2(`${baseDir}/${WebViewBridge.commandDir}`)} ${shellQuote2(`${baseDir}/${WebViewBridge.resultDir}`)}`,
+    `rm -f ${shellQuote2(resultPath)}`,
+    `printf %s ${shellQuote2(commandJson)} > ${shellQuote2(commandPath)}`,
+    `chown "$owner" ${shellQuote2(commandPath)}`,
+    `chmod 664 ${shellQuote2(commandPath)}`
+  ].join(" && "), {
+    timeoutMs: Math.max(5e3, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS)),
+    maxBuffer: 2 * 1024 * 1024
+  }).catch((error) => {
+    throw new CrawlerError({
+      message: `app_runtime_unavailable: WebView bridge \u547D\u4EE4\u5199\u5165\u5931\u8D25 ${error?.message || String(error)}`,
+      code: Code.AppRuntimeUnavailable,
+      context: { commandPath }
+    });
+  });
+  await Device.adbShell(ctx, [
+    "am",
+    "broadcast",
+    "-a",
+    WebViewBridge.actionCommand,
+    "--es",
+    "id",
+    command.id,
+    "-p",
+    packageName
+  ], {
+    timeoutMs: 8e3,
+    maxBuffer: 1024 * 1024
+  }).catch((error) => {
+    throw new CrawlerError({
+      message: `app_runtime_unavailable: WebView bridge \u5E7F\u64AD\u5931\u8D25 ${error?.message || String(error)}`,
+      code: Code.AppRuntimeUnavailable,
+      context: { action: WebViewBridge.actionCommand, id: command.id }
+    });
+  });
+  const deadline = Date.now() + Math.max(1, Number(options.timeoutMs || command.timeoutMs || DEFAULT_TIMEOUT_MS));
+  let lastRaw = "";
+  while (Date.now() < deadline) {
+    lastRaw = await adbSuShell2(ctx, `[ -f ${shellQuote2(resultPath)} ] && cat ${shellQuote2(resultPath)} || true`, {
+      timeoutMs: 5e3,
+      maxBuffer: Number(options.maxBuffer || 4 * 1024 * 1024)
+    }).catch(() => "");
+    if (String(lastRaw || "").trim()) {
+      await adbSuShell2(ctx, `rm -f ${shellQuote2(commandPath)} ${shellQuote2(resultPath)}`, { timeoutMs: 5e3 }).catch(() => {
+      });
+      try {
+        return JSON.parse(lastRaw);
+      } catch (error) {
+        throw new CrawlerError({
+          message: `app_runtime_unavailable: WebView bridge \u8FD4\u56DE\u4E86\u65E0\u6548 JSON ${error?.message || String(error)}`,
+          code: Code.AppRuntimeUnavailable,
+          context: { id: command.id, resultPath, raw: String(lastRaw || "").slice(0, 1e3) }
+        });
+      }
+    }
+    await sleep(Math.max(100, Number(options.resultPollIntervalMs || 250)));
+  }
+  throw new CrawlerError({
+    message: `app_runtime_unavailable: WebView bridge \u672A\u8FD4\u56DE\u7ED3\u679C (${command.timeoutMs}ms)`,
+    code: Code.AppRuntimeUnavailable,
+    context: { id: command.id, resultPath, lastRaw: String(lastRaw || "").slice(0, 500) }
+  });
+}
+function buildClickScript(selector, options = {}) {
+  const selectorJson = JSON.stringify(String(selector || 'button,a,[role="button"],[onclick],[aria-label],[title]'));
+  const textJson = JSON.stringify(String(options.textContains || ""));
+  const useLast = options.last !== false;
+  return `(() => {
+        const selector = ${selectorJson};
+        const textContains = ${textJson};
+        const visible = (el) => {
+            const rect = el.getBoundingClientRect();
+            const style = getComputedStyle(el);
+            return rect.width > 0 && rect.height > 0 && style.display !== 'none' && style.visibility !== 'hidden';
+        };
+        const inViewport = (el) => {
+            const rect = el.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0 && rect.bottom > 0 && rect.right > 0 && rect.top < window.innerHeight && rect.left < window.innerWidth;
+        };
+        const label = (el) => [el.innerText, el.textContent, el.getAttribute('aria-label'), el.getAttribute('title'), el.getAttribute('class')]
+            .filter(Boolean).join(' ').trim();
+        const elements = Array.from(document.querySelectorAll(selector))
+            .map((el) => el.closest('button,a,[role="button"],[onclick]') || el)
+            .filter((el, index, arr) => el && arr.indexOf(el) === index && visible(el))
+            .filter((el) => !textContains || label(el).includes(textContains));
+        const el = elements[${useLast ? "elements.length - 1" : "0"}];
+        if (!el) return { ok: false, reason: 'element_not_found', selector, textContains, candidateCount: elements.length };
+        el.scrollIntoView({ block: 'center', inline: 'center' });
+        if (!inViewport(el)) return { ok: false, reason: 'element_out_of_viewport', selector, textContains, candidateCount: elements.length };
+        el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+        if (typeof el.click === 'function') el.click();
+        const rect = el.getBoundingClientRect();
+        return { ok: true, selector, text: label(el).slice(0, 120), rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height }, candidateCount: elements.length };
+    })()`;
+}
+function normalizeBridgeResult(value) {
+  const result = value && typeof value === "object" ? value : {};
+  return {
+    id: String(result.id || ""),
+    ok: result.ok !== false,
+    url: String(result.url || ""),
+    title: String(result.title || ""),
+    value: result.value,
+    error: String(result.error || "")
+  };
+}
+function parseBridgeValue(value) {
+  let current = value;
+  for (let i = 0; i < 2; i += 1) {
+    if (typeof current !== "string") return current;
+    const text2 = current.trim();
+    if (!text2) return "";
+    try {
+      current = JSON.parse(text2);
+    } catch {
+      return current;
+    }
+  }
+  return current;
+}
+function hashSnapshot(value) {
+  return (0, import_node_crypto3.createHash)("sha256").update(String(value?.url || "")).update("\n").update(String(value?.title || "")).update("\n").update(String(value?.html || value?.text || "")).digest("hex");
+}
+async function adbSuShell2(ctx, command, options = {}) {
+  return Device.adbShell(ctx, [`su -c ${shellQuote2(command)}`], options);
+}
+function appDataDir2(packageName) {
+  return `/data/data/${String(packageName || "").trim()}`;
+}
+function normalizeStringArray2(value) {
+  const result = [];
+  const add = (item) => {
+    if (Array.isArray(item)) {
+      item.forEach(add);
+      return;
+    }
+    if (item && typeof item === "object") {
+      add(item.value);
+      return;
+    }
+    const text2 = String(item ?? "").trim();
+    if (text2) result.push(text2);
+  };
+  add(value);
+  return result;
+}
+function requireNonEmpty3(value, name) {
+  const clean = String(value ?? "").trim();
+  if (!clean) throw new CrawlerError({ message: `invalid_request: ${name} is required`, code: Code.InvalidRequest });
+  return clean;
+}
+function shellQuote2(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+// src/mutation.js
+var MUTATION_MONITOR_MODE = Object.freeze({
+  Added: "added",
+  Changed: "changed",
+  All: "all"
+});
+var Mutation = {
+  Mode: MUTATION_MONITOR_MODE,
+  waitForStable: waitForStable2,
+  waitForStableAcrossRoots,
+  useMonitor
+};
+async function waitForStable2(ctx, selectors, options = {}) {
+  if (options.mode === "webView") {
+    return WebView.waitForStable(ctx, options);
+  }
+  const selectorList = normalizeSelectors(selectors);
+  const initialTimeout = Math.max(0, Number(options.initialTimeout ?? 3e4));
+  const stableTime = Math.max(0, Number(options.stableTime ?? 5e3));
+  const timeout = Math.max(0, Number(options.timeout ?? 12e4));
+  const pollIntervalMs = Math.max(100, Number(options.pollIntervalMs ?? 500));
+  const onMutation = typeof options.onMutation === "function" ? options.onMutation : null;
+  const startedAt = Date.now();
+  const deadline = timeout === 0 ? Infinity : startedAt + timeout;
+  const initialDeadline = initialTimeout === 0 ? startedAt : startedAt + initialTimeout;
+  const logTemplate = Logger.useTemplate();
+  logTemplate.mutationWaitStart({
+    selectors: selectorList.map(selectorLabel2).join(","),
+    stableTime,
+    timeout,
+    pollIntervalMs
+  });
+  let foundInitial = false;
+  let lastSnapshot = null;
+  let stableSince = 0;
+  let mutationCount = 0;
+  let wasPaused = false;
+  let snapshotErrorCount = 0;
+  let lastSnapshotError = null;
+  while (Date.now() < deadline) {
+    const snapshot3 = await captureSnapshot(ctx, selectorList, options).catch((error) => {
+      snapshotErrorCount += 1;
+      lastSnapshotError = error;
+      if (snapshotErrorCount === 1 || snapshotErrorCount % 5 === 0) {
+        logTemplate.mutationWaitWarn({
+          snapshotErrorCount,
+          message: error?.message || String(error)
+        });
+      }
+      return null;
+    });
+    if (!snapshot3) {
+      await sleep(pollIntervalMs);
+      continue;
+    }
+    if (!foundInitial) {
+      if (snapshot3.found || Date.now() >= initialDeadline) {
+        foundInitial = true;
+        if (!snapshot3.found) logTemplate.mutationWaitWarn({ message: "\u521D\u59CB\u7B49\u5F85\u672A\u627E\u5230\u8282\u70B9", initialTimeout });
+      } else {
+        await sleep(pollIntervalMs);
+        continue;
+      }
+    }
+    const changed = !lastSnapshot || snapshot3.hash !== lastSnapshot.hash;
+    if (changed) {
+      if (lastSnapshot) mutationCount += 1;
+      lastSnapshot = snapshot3;
+    }
+    let paused = false;
+    if ((changed || !stableSince) && onMutation) {
+      const signal = await onMutation({
+        mutationCount,
+        html: snapshot3.html,
+        text: snapshot3.text,
+        mutationNodes: snapshot3.mutationNodes
+      });
+      paused = !(signal === null || signal === void 0);
+      wasPaused = wasPaused || paused;
+    }
+    if (paused) {
+      stableSince = 0;
+    } else if (changed || !stableSince) {
+      stableSince = Date.now();
+    } else if (Date.now() - stableSince >= stableTime) {
+      const result = {
+        mutationCount,
+        stableTime,
+        wasPaused,
+        html: snapshot3.html,
+        text: snapshot3.text,
+        mutationNodes: snapshot3.mutationNodes
+      };
+      logTemplate.mutationWaitSuccess({
+        duration: Logger.duration(startedAt),
+        mutationCount,
+        wasPaused
+      });
+      return result;
+    }
+    await sleep(pollIntervalMs);
+  }
+  throw new Error(`Mutation.waitForStable \u8D85\u65F6 (${timeout}ms), \u5DF2\u68C0\u6D4B\u5230 ${mutationCount} \u6B21\u53D8\u5316, snapshotErrorCount=${snapshotErrorCount}, lastSnapshotError=${lastSnapshotError?.message || ""}`);
+}
+async function waitForStableAcrossRoots(ctx, selectors, options = {}) {
+  return waitForStable2(ctx, selectors, options);
+}
+async function useMonitor(ctx, selectors, options = {}) {
+  const selectorList = normalizeSelectors(selectors);
+  const pollIntervalMs = Math.max(100, Number(options.pollIntervalMs ?? 500));
+  const onMutation = typeof options.onMutation === "function" ? options.onMutation : null;
+  let stopped = false;
+  let totalMutations = 0;
+  let lastHash = "";
+  const loop = async () => {
+    while (!stopped) {
+      const snapshot3 = await captureSnapshot(ctx, selectorList, options).catch(() => null);
+      if (snapshot3 && snapshot3.hash !== lastHash) {
+        if (lastHash) totalMutations += 1;
+        lastHash = snapshot3.hash;
+        if (onMutation) {
+          await onMutation({
+            mutationCount: totalMutations,
+            html: snapshot3.html,
+            text: snapshot3.text,
+            mutationNodes: snapshot3.mutationNodes
+          });
+        }
+      }
+      await sleep(pollIntervalMs);
+    }
+  };
+  loop();
+  return {
+    stop: async () => {
+      stopped = true;
+      return { totalMutations };
+    }
+  };
+}
+async function captureSnapshot(ctx, selectors, options = {}) {
+  const view = await DeviceView.snapshot(ctx, options);
+  const matched = selectors.length ? selectors.flatMap((selector) => view.flat.filter((node) => matchesSelector2(node, selector, options))) : view.flat;
+  const unique = uniqueNodes(matched);
+  const mutationNodes = unique.map((node) => ({
+    html: nodeToText(node),
+    text: [node.text, node.contentDesc].filter(Boolean).join(" ").trim(),
+    mutationType: "stable",
+    resourceId: node.resourceId,
+    className: node.className,
+    bounds: node.bounds
+  }));
+  const html = mutationNodes.map((node) => node.html).join("\n");
+  const text2 = mutationNodes.map((node) => node.text).filter(Boolean).join("\n");
+  return {
+    found: unique.length > 0,
+    html,
+    text: text2,
+    mutationNodes,
+    hash: unique.map((node) => DeviceView.hashNode(node)).join("|")
+  };
+}
+function normalizeSelectors(selectors) {
+  if (selectors == null) return [];
+  const values = Array.isArray(selectors) ? selectors : [selectors];
+  return values.map(normalizeSelector2).filter(Boolean);
+}
+function normalizeSelector2(selector) {
+  if (selector === "*" || selector == null) return null;
+  if (typeof selector === "object") return selector;
+  const text2 = String(selector || "").trim();
+  if (!text2) return null;
+  return { id: text2.replace(/^#/, "") };
+}
+function matchesSelector2(node, selector, options) {
+  if (!selector) return true;
+  if (options.visibleOnly !== false && !node.visible) return false;
+  if (selector.id) {
+    const id = String(selector.id || "");
+    if (node.resourceId !== id && node.id !== id && !node.resourceId.endsWith(`:id/${id}`)) return false;
+  }
+  if (selector.text && node.text !== selector.text) return false;
+  if (selector.textContains && !node.text.includes(selector.textContains)) return false;
+  if (selector.contentDesc && node.contentDesc !== selector.contentDesc) return false;
+  return true;
+}
+function uniqueNodes(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const node of nodes) {
+    const key = `${node.resourceId}|${node.bounds.left},${node.bounds.top},${node.bounds.right},${node.bounds.bottom}|${node.text}|${node.contentDesc}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(node);
+  }
+  return out;
+}
+function nodeToText(node) {
+  return JSON.stringify({
+    resourceId: node.resourceId,
+    text: node.text,
+    contentDesc: node.contentDesc,
+    className: node.className,
+    bounds: node.bounds,
+    children: node.children?.length || 0
+  });
+}
+function selectorLabel2(selector) {
+  try {
+    return JSON.stringify(selector);
+  } catch {
+    return String(selector);
+  }
+}
+
+// src/network-capture.js
+var CAPTURE_DIR_NAME = "network-capture";
+var RULES_FILE = "rules.json";
+var DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
+var NetworkCapture = {
+  path: path2,
+  clear,
+  writeRules,
+  readText
+};
+function path2(ctx, fileName = "") {
+  const base = `${appDataDir3(ctx)}/cache/${CAPTURE_DIR_NAME}`;
+  return fileName ? `${base}/${cleanFileName(fileName)}` : base;
+}
+async function clear(ctx, options = {}) {
+  const dirPath = options.dirPath || path2(ctx);
+  await adbSuShell3(ctx, `rm -rf ${shellQuote3(dirPath)}`, {
+    timeoutMs: 1e4,
+    maxBuffer: 1024
+  });
+  return true;
+}
+async function writeRules(ctx, { rulesJson } = {}) {
+  const text2 = typeof rulesJson === "string" ? rulesJson : JSON.stringify(rulesJson || { rules: [] });
+  await Device.writeCacheFile(ctx, {
+    dirName: CAPTURE_DIR_NAME,
+    fileName: RULES_FILE,
+    text: text2,
+    timeoutMs: 1e4,
+    maxBuffer: 2 * 1024 * 1024
+  });
+  return true;
+}
+async function readText(ctx, fileName, options = {}) {
+  return adbSuShell3(ctx, `cat ${shellQuote3(path2(ctx, fileName))} 2>/dev/null || true`, {
+    timeoutMs: 1e4,
+    maxBuffer: Number(options.maxBuffer || DEFAULT_MAX_BYTES)
+  }).catch(() => "");
+}
+async function adbSuShell3(ctx, command, options = {}) {
+  return Device.adbShell(ctx, [`su -c ${shellQuote3(command)}`], options);
+}
+function appDataDir3(ctx) {
+  const packageName = String(ctx?.packageName || "").trim();
+  if (!packageName) throw new Error("packageName is required");
+  return `/data/data/${packageName}`;
+}
+function cleanFileName(value) {
+  const text2 = String(value || "").trim();
+  if (!text2 || text2.includes("/") || text2.includes("\\") || text2 === "." || text2 === "..") {
+    throw new Error("invalid network capture file name");
+  }
+  return text2;
+}
+function shellQuote3(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+// src/share.js
+var import_node_crypto4 = require("node:crypto");
+var import_jimp2 = require("jimp");
+
+// src/internals/compression.js
+var import_jimp = require("jimp");
+var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_SCREENSHOT_OUTPUT_TYPE = "jpeg";
+var DEFAULT_SCREENSHOT_QUALITY = 0.72;
+var DEFAULT_SCREENSHOT_MIN_QUALITY = 0.38;
+var DEFAULT_SCREENSHOT_MIN_SCALE = 0.25;
+var SUPPORTED_SCREENSHOT_OUTPUT_TYPES = /* @__PURE__ */ new Set(["jpeg"]);
+var toPositiveInteger = (value, fallback = 0) => {
+  const number = Math.floor(Number(value) || 0);
+  return number > 0 ? number : fallback;
+};
+var normalizeQuality = (value, fallback) => {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return fallback;
+  const normalized = number > 1 ? number / 100 : number;
+  return Math.min(1, Math.max(0.01, normalized));
+};
+var normalizeScale = (value, fallback) => {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return fallback;
+  return Math.min(1, Math.max(0.05, number));
+};
+var normalizeScreenshotOutputType = (value) => {
+  const raw = String(value || DEFAULT_SCREENSHOT_OUTPUT_TYPE).trim().toLowerCase();
+  const normalized = raw === "jpg" ? "jpeg" : raw;
+  return SUPPORTED_SCREENSHOT_OUTPUT_TYPES.has(normalized) ? normalized : DEFAULT_SCREENSHOT_OUTPUT_TYPE;
+};
+var getBase64BytesFromBuffer = (buffer) => Math.ceil(buffer.length / 3) * 4;
+var toJpegQuality = (value) => Math.round(normalizeQuality(value, DEFAULT_SCREENSHOT_QUALITY) * 100);
+var resolveImageCompression = (options = {}) => {
+  const explicit = options.compression;
+  const source = explicit && typeof explicit === "object" && !Array.isArray(explicit) ? explicit : {};
+  const enabled = explicit !== false && source.enabled !== false && options.compress !== false;
+  const quality = normalizeQuality(
+    source.quality ?? options.quality,
+    DEFAULT_SCREENSHOT_QUALITY
+  );
+  const minQuality = Math.min(
+    quality,
+    normalizeQuality(source.minQuality ?? options.minQuality, DEFAULT_SCREENSHOT_MIN_QUALITY)
+  );
+  return {
+    enabled,
+    maxBytes: toPositiveInteger(
+      source.maxBytes ?? source.maxBase64Bytes ?? options.maxBytes ?? options.maxBase64Bytes,
+      DEFAULT_SCREENSHOT_MAX_BYTES
+    ),
+    outputType: normalizeScreenshotOutputType(
+      source.type ?? source.outputType ?? options.type ?? options.outputType
+    ),
+    quality,
+    minQuality,
+    minScale: normalizeScale(
+      source.minScale ?? options.minScale,
+      DEFAULT_SCREENSHOT_MIN_SCALE
+    )
+  };
+};
+var encodeJpeg = async (sourceImage, compression, scale, quality) => {
+  const width = Math.max(1, Math.round(sourceImage.bitmap.width * scale));
+  const height = Math.max(1, Math.round(sourceImage.bitmap.height * scale));
+  const image = sourceImage.clone();
+  if (scale < 0.999) {
+    image.resize({
+      w: width,
+      h: height,
+      mode: import_jimp.ResizeStrategy.BILINEAR
+    });
+  }
+  const buffer = await image.getBuffer(import_jimp.JimpMime.jpeg, { quality });
+  return {
+    buffer,
+    bytes: getBase64BytesFromBuffer(buffer),
+    width,
+    height,
+    quality,
+    scale: Number(scale.toFixed(3)),
+    format: compression.outputType
+  };
+};
+var rawPngResult = (buffer) => ({
+  buffer,
+  bytes: getBase64BytesFromBuffer(buffer),
+  format: "png",
+  mimeType: "image/png",
+  withinLimit: true
+});
+var mimeTypeForFormat = (format) => format === "jpeg" ? "image/jpeg" : "image/png";
+var compressImageBuffer = async (buffer, compression) => {
+  const sourceImage = await import_jimp.Jimp.read(buffer);
+  const maxQuality = toJpegQuality(compression.quality);
+  const minQuality = Math.min(maxQuality, toJpegQuality(compression.minQuality));
+  let quality = maxQuality;
+  let scale = 1;
+  let smallest = null;
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    const candidate = await encodeJpeg(sourceImage, compression, scale, quality);
+    if (!smallest || candidate.bytes < smallest.bytes) smallest = candidate;
+    if (candidate.bytes <= compression.maxBytes) {
+      return { ...candidate, mimeType: mimeTypeForFormat(candidate.format), withinLimit: true };
+    }
+    if (quality > minQuality) {
+      quality = Math.max(minQuality, Math.floor(quality * 0.75));
+      continue;
+    }
+    const ratio = Math.sqrt(compression.maxBytes / Math.max(1, candidate.bytes));
+    const nextScale = Math.max(
+      compression.minScale,
+      Math.min(scale * 0.85, scale * ratio * 0.94)
+    );
+    if (nextScale >= scale * 0.99 || scale <= compression.minScale) break;
+    scale = nextScale;
+  }
+  const finalCandidate = await encodeJpeg(sourceImage, compression, compression.minScale, minQuality);
+  const fallback = !smallest || finalCandidate.bytes < smallest.bytes ? finalCandidate : smallest;
+  return {
+    ...fallback,
+    mimeType: mimeTypeForFormat(fallback.format),
+    withinLimit: fallback.bytes <= compression.maxBytes
+  };
+};
+var compressImageBufferToResult = async (buffer, compression) => {
+  const originalBytes = getBase64BytesFromBuffer(buffer);
+  if (!compression.enabled || originalBytes <= compression.maxBytes) {
+    const raw = rawPngResult(buffer);
+    return {
+      ...raw,
+      base64: raw.buffer.toString("base64")
+    };
+  }
+  const result = await compressImageBuffer(buffer, compression).catch((error) => {
+    Logger.warn("captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE", { message: error?.message || String(error) });
+    return null;
+  });
+  if (!result?.buffer) {
+    const raw = rawPngResult(buffer);
+    return {
+      ...raw,
+      base64: raw.buffer.toString("base64")
+    };
+  }
+  if (result.withinLimit) {
+    Logger.info("captureScreen \u5DF2\u538B\u7F29", {
+      originalBytes,
+      outputBytes: result.bytes,
+      format: result.format,
+      quality: result.quality,
+      scale: result.scale,
+      size: `${result.width}x${result.height}`
+    });
+  } else {
+    Logger.warn("captureScreen \u538B\u7F29\u540E\u4ECD\u8D85\u8FC7\u76EE\u6807", {
+      originalBytes,
+      outputBytes: result.bytes,
+      maxBytes: compression.maxBytes,
+      format: result.format,
+      quality: result.quality,
+      scale: result.scale
+    });
+  }
+  return {
+    ...result,
+    base64: result.buffer.toString("base64")
+  };
+};
+
+// src/share.js
+var DEFAULT_CAPTURE_COUNT = 9;
+var DEFAULT_COLUMNS = 3;
+var DEFAULT_SETTLE_MS = 550;
+var DEFAULT_TIMEOUT_MS2 = 5e4;
+var DEFAULT_POLL_INTERVAL_MS2 = 800;
+var CAPTURE_SCROLL_STEP_RATIO = 0.56;
+var CAPTURE_SCROLL_DURATION_MS = 360;
+var SPRITE_GAP = 16;
+var FRAME_SIGNATURE_WIDTH = 320;
+var FRAME_SIGNATURE_QUALITY = 35;
+var Share = {
+  captureScreen,
+  captureLink
+};
+async function captureScreen(ctx, options = {}) {
+  const startedAt = Date.now();
+  const logTemplate = Logger.useTemplate();
+  const frameBuffers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const targetSelector = options.selector || { id: "message_list" };
+  const stopSelector = options.stopSelector || null;
+  const resetToTop = options.resetToTop !== false;
+  const maxFrames = clampInt(options.maxFrames, 1, DEFAULT_CAPTURE_COUNT, DEFAULT_CAPTURE_COUNT);
+  const direction = String(options.direction || "up").toLowerCase() === "down" ? "down" : "up";
+  let topResult = null;
+  let stoppedBySelector = false;
+  logTemplate.screenshotStart({ selector: targetSelector, resetToTop, direction, stopSelector });
+  if (resetToTop) {
+    topResult = await DeviceInput.scrollToTop(ctx, targetSelector, { settleMs: 400 });
+    Logger.info("captureScreen scrollToTop", {
+      swipes: topResult?.swipes,
+      stableRounds: topResult?.stableRounds,
+      hashSource: topResult?.hashSource,
+      capped: topResult?.capped === true,
+      inferredBoundary: topResult?.inferredBoundary === true
+    });
+    if (topResult?.capped === true && options.requireTop === true) {
+      throw new CrawlerError({
+        message: `source_extraction_failed: \u622A\u56FE\u524D\u672A\u80FD\u786E\u8BA4\u56DE\u5230\u9876\u90E8 swipes=${topResult.swipes} stableRounds=${topResult.stableRounds}`,
+        code: Code.SourceExtractionFailed,
+        context: {
+          selector: targetSelector,
+          swipes: topResult.swipes,
+          stableRounds: topResult.stableRounds,
+          hashSource: topResult.hashSource
+        }
+      });
+    } else if (topResult?.capped === true) {
+      Logger.warn("captureScreen \u672A\u80FD\u786E\u8BA4\u56DE\u5230\u9876\u90E8\uFF0C\u7EE7\u7EED\u91C7\u96C6\u5F53\u524D\u9875\u9762", {
+        swipes: topResult.swipes,
+        stableRounds: topResult.stableRounds,
+        hashSource: topResult.hashSource
+      });
+    }
+  }
+  for (let index = 0; index < maxFrames; index += 1) {
+    await sleep(DEFAULT_SETTLE_MS);
+    const target = await DeviceView.find(ctx, targetSelector, { optional: true }).catch(() => null);
+    const png = await Device.screenshotPng(ctx);
+    const hash = await frameSignature(png, target?.bounds);
+    if (seen.has(hash)) break;
+    seen.add(hash);
+    frameBuffers.push(png);
+    if (stopSelector && await DeviceView.exists(ctx, stopSelector, { timeoutMs: 300 }).catch(() => false)) {
+      stoppedBySelector = true;
+      break;
+    }
+    if (index >= maxFrames - 1) break;
+    await DeviceInput.scrollStep(ctx, targetSelector, direction, {
+      swipeRatio: CAPTURE_SCROLL_STEP_RATIO,
+      durationMs: CAPTURE_SCROLL_DURATION_MS,
+      settleMs: DEFAULT_SETTLE_MS
+    }).catch(() => {
+    });
+  }
+  const spriteBuffers = options.reverseFrames ? [...frameBuffers].reverse() : frameBuffers;
+  const sprite = await composeSprite(spriteBuffers, { columns: DEFAULT_COLUMNS, gap: SPRITE_GAP });
+  const compression = resolveImageCompression(options);
+  const imageResult = await compressImageBufferToResult(sprite, compression);
+  logTemplate.screenshotDone({
+    duration: Logger.duration(startedAt),
+    frameCount: frameBuffers.length,
+    scrollStepRatio: CAPTURE_SCROLL_STEP_RATIO,
+    resetToTop,
+    topCapped: topResult?.capped === true,
+    topInferredBoundary: topResult?.inferredBoundary === true,
+    format: imageResult.format,
+    base64Bytes: Math.ceil(imageResult.base64.length),
+    uniqueFrameCount: seen.size,
+    stoppedBySelector
+  });
+  return `data:${imageResult.mimeType};base64,${imageResult.base64}`;
+}
+async function captureLink(ctx, options = {}) {
+  const logTemplate = Logger.useTemplate();
+  const actorInfo = resolveActorInfo(options.actorInfo || options.actorKey || ctx.actorKey);
+  const share = actorInfo?.share || {};
+  if (share.mode !== "clipboard") {
+    throw new CrawlerError({
+      message: `source_extraction_failed: unsupported Android share mode ${share.mode || ""}`,
+      code: Code.SourceExtractionFailed
+    });
+  }
+  const timeoutMs = Number(options.timeoutMs || DEFAULT_TIMEOUT_MS2);
+  const prefix = String(share.prefix || "").trim();
+  logTemplate.shareStart({ actor: actorInfo.key, prefix, timeoutMs });
+  const beforeEvent = await readClipboard(ctx).catch(() => null);
+  const beforeLink = beforeEvent ? selectLink(beforeEvent, prefix) : "";
+  if (beforeLink) Logger.info("Share.captureLink baseline", { beforeLink });
+  if (typeof options.performActions === "function") {
+    await options.performActions();
+  }
+  const deadline = Date.now() + timeoutMs;
+  let lastEvent = null;
+  while (Date.now() < deadline) {
+    const event = await readClipboard(ctx).catch((error) => ({ ok: false, error: error?.message || String(error) }));
+    lastEvent = event;
+    const link = selectLink(event, prefix);
+    if (link) {
+      if (link === beforeLink) {
+        Logger.info("Share.captureLink ignore baseline link", { link });
+        await sleep(DEFAULT_POLL_INTERVAL_MS2);
+        continue;
+      }
+      logTemplate.shareSuccess({ link, source: event.source || "clipboard" });
+      return { link, source: event.source || "clipboard", payloadSnapshot: event.payloadSnapshot || "" };
+    }
+    await sleep(DEFAULT_POLL_INTERVAL_MS2);
+  }
+  throw new CrawlerError({
+    message: "source_extraction_failed: \u672A\u6355\u83B7\u5206\u4EAB\u94FE\u63A5",
+    code: Code.SourceExtractionFailed,
+    context: { prefix, lastEvent }
+  });
+}
+async function readClipboard(ctx) {
+  const payload = await readClipboardForShare(ctx);
+  const candidates = extractLinks(payload).map((link) => ({
+    source: "adb.clipboard",
+    link,
+    payload: payload.slice(0, 1e3)
+  }));
+  return {
+    ok: candidates.length > 0,
+    link: candidates[0]?.link || "",
+    source: "adb.clipboard",
+    candidates,
+    payloadSnapshot: payload.slice(0, 500)
+  };
+}
+async function composeSprite(buffers, options = {}) {
+  if (!buffers.length) {
+    throw new CrawlerError({ message: "source_extraction_failed: no screenshots captured", code: Code.SourceExtractionFailed });
+  }
+  const images = [];
+  for (const buffer of buffers) images.push(await import_jimp2.Jimp.read(buffer));
+  const columns = Math.max(1, Number(options.columns || DEFAULT_COLUMNS));
+  const gap = Math.max(0, Number(options.gap || 0));
+  const cellWidth = Math.max(...images.map((image) => image.bitmap.width));
+  const cellHeight = Math.max(...images.map((image) => image.bitmap.height));
+  const rows = Math.ceil(images.length / columns);
+  const width = columns * cellWidth + (columns - 1) * gap;
+  const height = rows * cellHeight + (rows - 1) * gap;
+  const sprite = new import_jimp2.Jimp({ width, height, color: 4294967295 });
+  images.forEach((image, index) => {
+    const x = index % columns * (cellWidth + gap);
+    const y = Math.floor(index / columns) * (cellHeight + gap);
+    sprite.composite(image, x, y);
+  });
+  return sprite.getBuffer(import_jimp2.JimpMime.png);
+}
+async function frameSignature(buffer, bounds2) {
+  const image = await import_jimp2.Jimp.read(buffer);
+  const area = normalizeCaptureBounds(bounds2, image.bitmap.width, image.bitmap.height);
+  const target = image.crop(area);
+  const scale = Math.min(1, FRAME_SIGNATURE_WIDTH / Math.max(1, target.bitmap.width));
+  if (scale < 1) {
+    target.resize({
+      w: Math.max(1, Math.round(target.bitmap.width * scale)),
+      h: Math.max(1, Math.round(target.bitmap.height * scale))
+    });
+  }
+  const normalized = await target.getBuffer(import_jimp2.JimpMime.jpeg, { quality: FRAME_SIGNATURE_QUALITY });
+  return (0, import_node_crypto4.createHash)("sha256").update(normalized).digest("hex");
+}
+function normalizeCaptureBounds(bounds2, imageWidth, imageHeight) {
+  const left = clampInt(bounds2?.left, 0, imageWidth - 1, 0);
+  const top = clampInt(bounds2?.top, 0, imageHeight - 1, 0);
+  const right = clampInt(bounds2?.right, left + 1, imageWidth, imageWidth);
+  const bottom = clampInt(bounds2?.bottom, top + 1, imageHeight, imageHeight);
+  return {
+    x: left,
+    y: top,
+    w: Math.max(1, right - left),
+    h: Math.max(1, bottom - top)
+  };
+}
+function clampInt(value, min, max, fallback) {
+  const number = Math.round(Number(value));
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, number));
+}
+function resolveActorInfo(value) {
+  if (value && typeof value === "object") return value;
+  const key = String(value || "").trim();
+  const info = ActorInfo[key];
+  if (!info) {
+    throw new CrawlerError({
+      message: `invalid_request: unknown actorInfo ${key}`,
+      code: Code.InvalidRequest
+    });
+  }
+  return info;
+}
+function selectLink(event, prefix) {
+  const candidates = [];
+  if (event?.link) candidates.push(event.link);
+  if (Array.isArray(event?.candidates)) {
+    for (const candidate of event.candidates) {
+      if (candidate?.link) candidates.push(candidate.link);
+    }
+  }
+  return candidates.find((link) => !prefix || String(link).startsWith(prefix)) || "";
+}
+function extractLinks(value) {
+  const text2 = String(value || "");
+  const matches = text2.match(/https?:\/\/[^\s"'<>，。]+/g) || [];
+  return matches.map((link) => link.replace(/[)\].,，。；;!?！？]+$/g, ""));
+}
+
+// src/launch.js
+var Launch = {
+  run
+};
+async function run(handler, options = {}) {
+  const startedAt = Date.now();
+  const logTemplate = Logger.useTemplate();
+  const inputPath = StoragePath.Input;
+  const outputPath = StoragePath.Output;
+  const input = options.input || JSON.parse(import_node_fs2.default.readFileSync(inputPath, "utf8"));
+  const ctx = options.ctx || Context.createAndroidContext(input, options.contextDefaults || {});
+  ctx.runId = ctx.runId || input.run_id || input.runId || input.runtime?.run_id || input.runtime?.runId || "";
+  ctx.actorKey = ctx.actorKey || options.actorKey || input.actorKey || input.actor_name || input.actorName || "";
+  const actorInfo = options.actorInfo || ActorInfo[ctx.actorKey] || null;
+  const originalInputMethod = await Device.currentInputMethod(ctx).catch((error) => {
+    logTemplate.inputMethodSnapshotFail(error);
+    return "";
+  });
+  const apifyKit = await ApifyKit.useApifyKit({
+    reset: true,
+    input,
+    ctx,
+    inputPath,
+    outputPath
+  });
+  const kit = {
+    Launch,
+    ApifyKit: apifyKit,
+    Device,
+    DeviceInput,
+    DeviceView,
+    DeviceSQLite,
+    Share,
+    Mutation,
+    NetworkCapture,
+    WebView,
+    Logger,
+    Context
+  };
+  try {
+    logTemplate.launchStart({
+      inputPath,
+      outputPath,
+      runId: ctx.runId,
+      serial: ctx.serial,
+      packageName: ctx.packageName,
+      queryChars: ctx.query.length
+    });
+    if (await WebView.configureHook(ctx, actorInfo)) {
+      await Device.forceStopApp(ctx);
+    }
+    if (typeof options.hooks?.preNavigation === "function") {
+      await options.hooks.preNavigation({ input, ctx, kit, ApifyKit: apifyKit });
+    }
+    await handler({ input, ctx, kit, ApifyKit: apifyKit });
+    if (typeof options.hooks?.postRun === "function") {
+      await options.hooks.postRun({ input, ctx, kit, ApifyKit: apifyKit });
+    }
+    logTemplate.launchSuccess({ duration: Logger.duration(startedAt) });
+  } catch (error) {
+    logTemplate.launchFail({ duration: Logger.duration(startedAt) }, error);
+    if (typeof options.hooks?.onError === "function") {
+      await options.hooks.onError(error, { input, ctx, kit, ApifyKit: apifyKit });
+    }
+    if (!apifyKit.hasPushed()) await apifyKit.pushFailed(error);
+    throw error;
+  } finally {
+    await Device.restoreInputMethod(ctx, originalInputMethod).catch((error) => {
+      logTemplate.inputMethodRestoreFail(error);
+    });
+  }
+}
+
+// entrys/node.js
+var ToolkitMode = Object.freeze({
+  default: "default"
+});
+var useAndroidToolKit = () => {
+  return {
+    Launch,
+    ApifyKit,
+    DeviceInput,
+    DeviceView,
+    DeviceSQLite,
+    Device,
+    Mutation,
+    NetworkCapture,
+    Share,
+    WebView,
+    Constants: constants_exports,
+    Errors: errors_exports,
+    Logger,
+    LOG_TEMPLATES,
+    $Internals: { LOG_TEMPLATES, stripAnsi },
+    Context
+  };
+};
+useAndroidToolKit.Mode = ToolkitMode;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAndroidToolKit
+});
+//# sourceMappingURL=index.cjs.map