@skrillex1224/android-toolkit 0.1.9 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1910 @@
+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);
+
+// src/constants.js
+var constants_exports = {};
+__export(constants_exports, {
+  ActorInfo: () => ActorInfo,
+  Code: () => Code,
+  Status: () => Status,
+  UnicodeIme: () => UnicodeIme
+});
+var Code = Object.freeze({
+  Success: 0,
+  UnknownError: -1,
+  NotLogin: 30000001,
+  Timeout: 30000003,
+  InitialTimeout: 30000004,
+  OverallTimeout: 30000005,
+  InvalidRequest: 30010001,
+  AdbUnavailable: 30010002,
+  ContentUnavailable: 30010003,
+  SourceExtractionFailed: 30010004,
+  AutomationFailed: 30010005,
+  FridaUnavailable: 30010008,
+  AppNotInstalled: 30010009
+});
+var Status = Object.freeze({
+  Success: "SUCCESS",
+  Failed: "FAILED"
+});
+var UnicodeIme = Object.freeze({
+  packageName: "io.appium.settings",
+  component: "io.appium.settings/.UnicodeIME",
+  inputTextAction: "ADB_INPUT_TEXT"
+});
+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`),
+    share: Object.freeze(normalizeShare(info.share))
+  });
+};
+var ActorInfo = Object.freeze({
+  "doubao.android": createActorInfo({
+    key: "doubao.android",
+    name: "\u8C46\u5305 Android",
+    share: {
+      prefix: "https://www.doubao.com/thread/",
+      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),
+    fridaPath: firstNonEmpty(defaults.fridaPath, process.env.ANDROID_TOOLKIT_FRIDA_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 LOG_TEMPLATES = Object.freeze({
+  stepStart: "[Step] start",
+  stepSuccess: "[Step] success",
+  stepFail: "[Step] failed",
+  mutationStable: "[Mutation] stable",
+  shareStart: "[Share] start",
+  screenshotDone: "[Share] screenshot done",
+  dataPush: "[Dataset] push"
+});
+var Logger = {
+  setLogger(logger) {
+    activeLogger = logger || defaultLogger;
+  },
+  createLogger(scope) {
+    const prefix = scope ? `[${scope}] ` : "";
+    return {
+      start: (message, detail) => Logger.start(`${prefix}${message}`, detail),
+      success: (message, detail) => Logger.success(`${prefix}${message}`, detail),
+      fail: (message, error) => Logger.fail(`${prefix}${message}`, error),
+      warn: (message, detail) => Logger.warn(`${prefix}${message}`, detail),
+      info: (message, detail) => Logger.info(`${prefix}${message}`, detail),
+      debug: (message, detail) => Logger.debug(`${prefix}${message}`, detail)
+    };
+  },
+  useTemplate() {
+    return {
+      taskStart: (detail) => Logger.start("\u4EFB\u52A1\u5F00\u59CB", detail),
+      taskSuccess: (detail) => Logger.success("\u4EFB\u52A1\u5B8C\u6210", detail),
+      taskFail: (detail, error) => Logger.fail(`\u4EFB\u52A1\u5931\u8D25 ${detail || ""}`.trim(), error),
+      stepStart: (step, detail) => Logger.start(`[Step] ${step}`, detail),
+      stepSuccess: (step, detail) => Logger.success(`[Step] ${step}`, detail),
+      stepFail: (step, error) => Logger.fail(`[Step] ${step}`, error),
+      mutationStable: (detail) => Logger.success("[Mutation] stable", detail),
+      shareStart: (detail) => Logger.start("[Share] capture", detail),
+      screenshotDone: (detail) => Logger.success("[Share] screenshot", detail),
+      dataPush: (detail) => Logger.success("[Dataset] push", detail)
+    };
+  },
+  start(message, detail = "") {
+    write("info", `\u25B6 ${message}`, detail);
+  },
+  success(message, detail = "") {
+    write("info", `\u2713 ${message}`, detail);
+  },
+  fail(message, error = "") {
+    write("error", `\u2717 ${message}`, error?.message || error);
+  },
+  warn(message, detail = "") {
+    write("warn", `\u26A0 ${message}`, detail);
+  },
+  warning(message, detail = "") {
+    Logger.warn(message, detail);
+  },
+  info(message, detail = "") {
+    write("info", message, detail);
+  },
+  debug(message, detail = "") {
+    write("debug", 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 write(level, message, detail = "") {
+  const formattedDetail = formatDetail(detail);
+  const line = formattedDetail ? `[${formatTimestamp()}] [android-toolkit] ${message} ${formattedDetail}` : `[${formatTimestamp()}] [android-toolkit] ${message}`;
+  const writer = activeLogger[level] || activeLogger.warning || activeLogger.warn || activeLogger.info || console.error;
+  writer.call(activeLogger, line);
+}
+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) {
+  if (detail == null || detail === "") return "";
+  if (detail instanceof Error) return detail.message;
+  if (typeof detail === "string") return detail;
+  if (Array.isArray(detail)) return detail.map(formatDetail).filter(Boolean).join(" ");
+  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)}`).join(" ");
+  }
+  return String(detail);
+}
+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 Device = {
+  adbExec,
+  adbShell,
+  forceStopApp,
+  startActivity,
+  startLauncher,
+  focusedActivity,
+  waitForActivity,
+  waitForForeground,
+  screenSize,
+  screenDensity,
+  tapAbsolute,
+  swipe,
+  pressKey,
+  pressBack,
+  pressEnter,
+  typeText,
+  screenshotPng,
+  screenshotBase64,
+  dumpUiXml,
+  wakeAndUnlock,
+  hideKeyboard,
+  isKeyboardVisible,
+  sleep,
+  ensureUnicodeIme
+};
+async function adbExec(ctx, args, options = {}) {
+  const adbPath = requireDeviceField(ctx, "adbPath");
+  const startedAt = Date.now();
+  try {
+    const { stdout } = await execFileAsync(adbPath, args.map(String), {
+      timeout: Number(options.timeoutMs || 15e3),
+      maxBuffer: Number(options.maxBuffer || 12 * 1024 * 1024),
+      encoding: options.encoding || "utf8"
+    });
+    Logger.debug("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 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 startActivity(ctx, component, args = []) {
+  await adbShell(ctx, ["am", "start", "-n", requireValue(component, "component"), ...args], { timeoutMs: 2e4 });
+  await sleep(1500);
+}
+async function startLauncher(ctx, packageName = ctx.packageName, launcherActivity) {
+  await startActivity(ctx, `${requireValue(packageName, "packageName")}/${requireValue(launcherActivity, "launcherActivity")}`, [
+    "-a",
+    "android.intent.action.MAIN",
+    "-c",
+    "android.intent.category.LAUNCHER"
+  ]);
+}
+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 String(out || "").trim();
+}
+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")) 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) {
+  await adbInput(ctx, [
+    "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))
+  ], { timeoutMs: 15e3 });
+}
+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);
+  await adbShell(ctx, ["am", "broadcast", "-a", UnicodeIme.inputTextAction, "--es", "msg", String(text2 ?? "")], {
+    timeoutMs: 3e4,
+    maxBuffer: 4 * 1024 * 1024
+  });
+}
+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 screenshotPng(ctx) {
+  const serial = requireDeviceField(ctx, "serial");
+  const adbPath = requireDeviceField(ctx, "adbPath");
+  const { stdout } = await execFileAsync(adbPath, ["-s", serial, "exec-out", "screencap", "-p"], {
+    timeout: 3e4,
+    maxBuffer: 40 * 1024 * 1024,
+    encoding: "buffer"
+  });
+  return Buffer.from(stdout);
+}
+async function screenshotBase64(ctx) {
+  return `data:image/png;base64,${(await screenshotPng(ctx)).toString("base64")}`;
+}
+async function dumpUiXml(ctx) {
+  const raw = await adbShell(ctx, ["uiautomator", "dump", "/dev/tty"], {
+    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();
+}
+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);
+}
+function requireDeviceField(ctx, key) {
+  return requireValue(ctx?.[key], key);
+}
+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|not found|No such file|device .* not found|no devices|offline/i.test(message);
+}
+function compactArgs(args) {
+  return args.map(String).join(" ").slice(0, 500);
+}
+
+// src/apify-kit.js
+var instance = null;
+var ApifyKit = {
+  useApifyKit
+};
+async function useApifyKit(options = {}) {
+  if (!instance || options.reset) {
+    instance = createApifyKit(options);
+  }
+  return instance;
+}
+function createApifyKit(options = {}) {
+  const inputPath = String(options.inputPath || "").trim();
+  const outputPath = requiredOption(options.outputPath, "outputPath");
+  const input = options.input || (inputPath ? JSON.parse(import_node_fs.default.readFileSync(inputPath, "utf8")) : {});
+  const ctx = options.ctx || Context.createAndroidContext(input, options.contextDefaults || {});
+  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})` : "";
+        Logger.start(`[Step] ${step}${attemptLabel}`, stepDetail(target));
+        try {
+          const result = await actionFn();
+          Logger.success(`[Step] ${step}${attemptLabel}`, { duration: Logger.duration(startedAt) });
+          return result;
+        } catch (error) {
+          lastError = error;
+          Logger.fail(`[Step] ${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: Code.Success,
+        status: Status.Success,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: sanitizeData(data),
+        ...options2.meta ? { meta: sanitizeData(options2.meta) } : {}
+      });
+      Logger.success("pushSuccess", { outputPath, keys: Object.keys(data || {}).join(",") });
+    },
+    async pushArtifact(data = {}) {
+      appendOutput(outputPath, sanitizeData(data));
+      Logger.success("pushArtifact", { 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: serializeError(normalized),
+        meta: sanitizeData(meta),
+        context: sanitizeData(normalized.context),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      Logger.success("pushFailed", { 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 requiredOption(value, name) {
+  const clean = String(value || "").trim();
+  if (!clean) throw new Error(`ApifyKit.useApifyKit requires ${name}`);
+  return clean;
+}
+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, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (depth > 8) return "[MaxDepth]";
+  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 (value instanceof Error) return serializeError(value);
+  if (Array.isArray(value)) return value.map((item) => sanitizeData(item, depth + 1, seen)).filter((item) => item !== void 0);
+  if (type !== "object") return String(value);
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    const safe = sanitizeData(item, depth + 1, seen);
+    if (safe !== void 0) out[key] = safe;
+  }
+  return out;
+}
+
+// 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;
+  while (Date.now() < deadline) {
+    try {
+      const node = await find(ctx, selector, { ...options, optional: true });
+      if (node) return node;
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(intervalMs);
+  }
+  if (lastError) 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"]) {
+    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",
+      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;
+  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 DeviceInput = {
+  click,
+  tap: click,
+  fill,
+  type: fill,
+  press,
+  pressEnter: pressEnter2,
+  scroll,
+  scrollToEnd,
+  scrollToTop
+};
+async function click(ctx, selectorOrPoint, options = {}) {
+  if (isPoint(selectorOrPoint)) {
+    await Device.tapAbsolute(ctx, selectorOrPoint.x, selectorOrPoint.y);
+    return { point: selectorOrPoint };
+  }
+  if (isBounds(selectorOrPoint)) {
+    const point2 = centerOf(selectorOrPoint);
+    await Device.tapAbsolute(ctx, point2.x, point2.y);
+    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 = {}) {
+  await click(ctx, selector, options);
+  await Device.typeText(ctx, text2);
+  await sleep(Number(options.settleMs || 350));
+}
+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);
+  const box = node.bounds;
+  const ratio = Number(options.swipeRatio || 0.72);
+  const durationMs = Number(options.durationMs || 360);
+  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 || 500));
+}
+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 = Math.max(1, Number(options.maxSwipes || 20));
+  const stableRoundsTarget = Math.max(1, Number(options.stableRounds || 2));
+  let lastHash = "";
+  let stableRounds = 0;
+  for (let index = 0; index < maxSwipes; index += 1) {
+    const node = await DeviceView.find(ctx, selector, options);
+    const currentHash = DeviceView.hashNode(node);
+    if (currentHash === lastHash) {
+      stableRounds += 1;
+      if (stableRounds >= stableRoundsTarget) {
+        return { swipes: index, stableRounds, hash: currentHash };
+      }
+    } else {
+      stableRounds = 0;
+      lastHash = currentHash;
+    }
+    await scroll(ctx, selector, direction, options);
+  }
+  return { swipes: maxSwipes, stableRounds, hash: lastHash };
+}
+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/internals/frida-script.js
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+async function runFridaScriptInternal(ctx, source, options = {}) {
+  await assertFridaReady(ctx);
+  const label = String(options.label || "frida-script");
+  const marker = String(options.marker || "ANDROID_TOOLKIT_SCRIPT_JSON ");
+  const pid = await resolvePid(ctx, options.packageName || ctx.packageName);
+  const scriptPath = writeTempScript(source, label);
+  const args = [
+    "-q",
+    "-t",
+    String(Number(options.fridaTimeoutSeconds || 8)),
+    "-D",
+    ctx.serial,
+    "-p",
+    pid,
+    "-l",
+    scriptPath
+  ];
+  Logger.info("frida script start", { label, pid, timeoutMs: Number(options.timeoutMs || 12e3) });
+  try {
+    return await runFridaProcess(ctx.fridaPath, args, {
+      marker,
+      timeoutMs: Number(options.timeoutMs || 12e3),
+      maxLines: Number(options.maxLines || 1500)
+    });
+  } finally {
+    (0, import_node_fs2.rmSync)(import_node_path.default.dirname(scriptPath), { recursive: true, force: true });
+  }
+}
+async function resolveFridaPid(ctx, packageName = ctx.packageName) {
+  return resolvePid(ctx, packageName);
+}
+async function assertFridaReady(ctx) {
+  if (!ctx?.fridaPath) {
+    throw new CrawlerError({
+      message: "frida_unavailable: ANDROID_TOOLKIT_FRIDA_PATH is required",
+      code: Code.FridaUnavailable
+    });
+  }
+  if (!ctx?.serial) {
+    throw new CrawlerError({
+      message: "frida_unavailable: device serial is required",
+      code: Code.FridaUnavailable
+    });
+  }
+}
+async function resolvePid(ctx, packageName = ctx.packageName) {
+  const target = String(packageName || "").trim();
+  if (!target) {
+    throw new CrawlerError({
+      message: "frida_unavailable: packageName is required",
+      code: Code.FridaUnavailable
+    });
+  }
+  const out = await Device.adbShell(ctx, ["pidof", target], { timeoutMs: 8e3 }).catch(() => "");
+  const pid = String(out || "").trim().split(/\s+/).find(Boolean);
+  if (!pid) {
+    throw new CrawlerError({
+      message: `frida_unavailable: target app pid not found ${target}`,
+      code: Code.FridaUnavailable,
+      context: { packageName: target }
+    });
+  }
+  return pid;
+}
+function runFridaProcess(fridaPath, args, options) {
+  return new Promise((resolve, reject) => {
+    const events = [];
+    const lines = [];
+    let buffer = "";
+    let finished = false;
+    const child = (0, import_node_child_process2.spawn)(fridaPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const timer = setTimeout(() => {
+      if (finished) return;
+      finished = true;
+      child.kill("SIGTERM");
+      reject(new CrawlerError({
+        message: `frida_unavailable: frida script timeout ${options.timeoutMs}ms`,
+        code: Code.FridaUnavailable,
+        context: { lines: lines.slice(-40) }
+      }));
+    }, options.timeoutMs);
+    const consumeLine = (line) => {
+      const text2 = String(line || "").trim();
+      if (!text2) return;
+      lines.push(text2);
+      if (lines.length > options.maxLines) lines.shift();
+      const markerIndex = text2.indexOf(options.marker);
+      if (markerIndex < 0) return;
+      const jsonText = text2.slice(markerIndex + options.marker.length).trim();
+      try {
+        events.push(JSON.parse(jsonText));
+      } catch (error) {
+        events.push({ type: "parse_error", error: error?.message || String(error), line: text2 });
+      }
+    };
+    const onChunk = (chunk) => {
+      buffer += chunk.toString("utf8");
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        consumeLine(buffer.slice(0, index));
+        buffer = buffer.slice(index + 1);
+        index = buffer.indexOf("\n");
+      }
+    };
+    child.stdout.on("data", onChunk);
+    child.stderr.on("data", onChunk);
+    child.on("error", (error) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      reject(new CrawlerError({
+        message: `frida_unavailable: ${error?.message || String(error)}`,
+        code: Code.FridaUnavailable
+      }));
+    });
+    child.on("close", () => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      if (buffer.trim()) consumeLine(buffer);
+      const parsed = events.filter((event) => event?.type !== "parse_error");
+      if (parsed.length === 0) {
+        reject(new CrawlerError({
+          message: "frida_unavailable: script emitted no event",
+          code: Code.FridaUnavailable,
+          context: { lines: lines.slice(-40), events }
+        }));
+        return;
+      }
+      resolve(parsed.at(-1));
+    });
+  });
+}
+function writeTempScript(source, label) {
+  const dir = (0, import_node_fs2.mkdtempSync)(import_node_path.default.join((0, import_node_os.tmpdir)(), `android-toolkit-${safeName(label)}-`));
+  const scriptPath = import_node_path.default.join(dir, "script.js");
+  (0, import_node_fs2.writeFileSync)(scriptPath, String(source || ""), "utf8");
+  return scriptPath;
+}
+function safeName(value) {
+  return String(value || "script").replace(/[^a-z0-9_-]+/gi, "-").slice(0, 80);
+}
+
+// src/frida-client.js
+var Frida = {
+  querySQLite,
+  health
+};
+async function querySQLite(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))
+  };
+  const event = await runFridaScriptInternal(ctx, sqliteScript(config), {
+    label: options.label || "query-sqlite",
+    packageName: options.packageName || ctx.packageName,
+    timeoutMs: options.timeoutMs || 3e4,
+    fridaTimeoutSeconds: options.fridaTimeoutSeconds || 25,
+    maxLines: options.maxLines || 4e3
+  });
+  if (!event.ok) {
+    throw new CrawlerError({
+      message: `content_unavailable: sqlite query failed ${event.error || ""}`.trim(),
+      code: Code.ContentUnavailable,
+      context: event
+    });
+  }
+  return event;
+}
+async function health(ctx) {
+  if (!ctx?.fridaPath) {
+    throw new CrawlerError({
+      message: "frida_unavailable: ANDROID_TOOLKIT_FRIDA_PATH is required",
+      code: Code.FridaUnavailable
+    });
+  }
+  if (!ctx?.serial) {
+    throw new CrawlerError({
+      message: "frida_unavailable: device serial is required",
+      code: Code.FridaUnavailable
+    });
+  }
+  const pid = await resolveFridaPid(ctx, ctx.packageName);
+  return { ok: true, pid };
+}
+function sqliteScript(config) {
+  return `
+Java.perform(function () {
+  function emit(payload) { console.log('ANDROID_TOOLKIT_SCRIPT_JSON ' + JSON.stringify(payload)); }
+  var config = ${JSON.stringify(config)};
+  var JavaString = Java.use('java.lang.String');
+  function safeString(cursor, index) {
+    try { return cursor.isNull(index) ? '' : String(cursor.getString(index)); } catch (_) { return ''; }
+  }
+  function stringArray(values) {
+    if (!values || values.length === 0) return null;
+    var out = [];
+    for (var i = 0; i < values.length; i++) out.push(String(values[i]));
+    return Java.array('java.lang.String', out);
+  }
+  function matchesName(name) {
+    if (config.dbNamePrefix && name.indexOf(config.dbNamePrefix) !== 0) return false;
+    if (config.dbNameIncludes && name.indexOf(config.dbNameIncludes) < 0) return false;
+    for (var i = 0; i < config.dbNameExcludes.length; i++) {
+      if (String(name).indexOf(config.dbNameExcludes[i]) >= 0) return false;
+    }
+    return true;
+  }
+  function dbPaths() {
+    if (config.dbPath) return [config.dbPath];
+    var File = Java.use('java.io.File');
+    var dir = File.$new(config.dbDir);
+    var files = dir.listFiles();
+    var out = [];
+    if (!files) return out;
+    for (var i = 0; i < files.length; i++) {
+      var name = String(files[i].getName());
+      if (matchesName(name)) out.push(String(files[i].getAbsolutePath()));
+    }
+    return out;
+  }
+  function queryOne(dbPath) {
+    var SQLiteDatabase = Java.use('android.database.sqlite.SQLiteDatabase');
+    var db = SQLiteDatabase.openDatabase(JavaString.$new(dbPath), null, 1);
+    try {
+      var cursor = db.rawQuery(JavaString.$new(config.sql), stringArray(config.args));
+      var columns = [];
+      var columnCount = cursor.getColumnCount();
+      for (var c = 0; c < columnCount; c++) columns.push(String(cursor.getColumnName(c)));
+      var rows = [];
+      var truncated = false;
+      while (cursor.moveToNext()) {
+        if (rows.length >= config.maxRows) { truncated = true; break; }
+        var row = {};
+        for (var i = 0; i < columns.length; i++) row[columns[i]] = safeString(cursor, i);
+        rows.push(row);
+      }
+      cursor.close();
+      return { dbPath: dbPath, columns: columns, rows: rows, rowCount: rows.length, truncated: truncated };
+    } finally {
+      db.close();
+    }
+  }
+  try {
+    var paths = dbPaths();
+    if (paths.length === 0) { emit({ ok: false, error: 'sqlite database not found', config: config }); return; }
+    var databases = [];
+    for (var d = 0; d < paths.length; d++) databases.push(queryOne(paths[d]));
+    emit({ ok: true, databases: databases, rows: databases.length === 1 ? databases[0].rows : [] });
+  } catch (error) {
+    emit({ ok: false, error: String(error), stack: String(error.stack || '') });
+  }
+});
+`;
+}
+function normalizeStringArray(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item ?? ""));
+  if (value == null) return [];
+  return [String(value)];
+}
+
+// src/launch.js
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+
+// src/mutation.js
+var MUTATION_MONITOR_MODE = Object.freeze({
+  Added: "added",
+  Changed: "changed",
+  All: "all"
+});
+var Mutation = {
+  Mode: MUTATION_MONITOR_MODE,
+  waitForStable,
+  waitForStableAcrossRoots,
+  useMonitor
+};
+async function waitForStable(ctx, selectors, 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;
+  Logger.start("Mutation.waitForStable", {
+    selectors: selectorList.map(selectorLabel2).join(","),
+    stableTime,
+    timeout,
+    pollIntervalMs
+  });
+  let foundInitial = false;
+  let lastSnapshot = null;
+  let stableSince = 0;
+  let mutationCount = 0;
+  let wasPaused = false;
+  while (Date.now() < deadline) {
+    const snapshot2 = await captureSnapshot(ctx, selectorList, options);
+    if (!foundInitial) {
+      if (snapshot2.found || Date.now() >= initialDeadline) {
+        foundInitial = true;
+        if (!snapshot2.found) Logger.warn("Mutation.waitForStable \u521D\u59CB\u7B49\u5F85\u672A\u627E\u5230\u8282\u70B9", { initialTimeout });
+      } else {
+        await sleep(pollIntervalMs);
+        continue;
+      }
+    }
+    const changed = !lastSnapshot || snapshot2.hash !== lastSnapshot.hash;
+    if (changed) {
+      if (lastSnapshot) mutationCount += 1;
+      lastSnapshot = snapshot2;
+    }
+    let paused = false;
+    if ((changed || !stableSince) && onMutation) {
+      const signal = await onMutation({
+        mutationCount,
+        html: snapshot2.html,
+        text: snapshot2.text,
+        mutationNodes: snapshot2.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: snapshot2.html,
+        text: snapshot2.text,
+        mutationNodes: snapshot2.mutationNodes
+      };
+      Logger.success("Mutation.waitForStable", {
+        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`);
+}
+async function waitForStableAcrossRoots(ctx, selectors, options = {}) {
+  return waitForStable(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 snapshot2 = await captureSnapshot(ctx, selectorList, options).catch(() => null);
+      if (snapshot2 && snapshot2.hash !== lastHash) {
+        if (lastHash) totalMutations += 1;
+        lastHash = snapshot2.hash;
+        if (onMutation) {
+          await onMutation({
+            mutationCount: totalMutations,
+            html: snapshot2.html,
+            text: snapshot2.text,
+            mutationNodes: snapshot2.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/share.js
+var import_node_crypto2 = 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 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, 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, withinLimit: fallback.bytes <= compression.maxBytes };
+};
+var compressImageBufferToBase64 = async (buffer, compression) => {
+  const originalBytes = getBase64BytesFromBuffer(buffer);
+  if (!compression.enabled || originalBytes <= compression.maxBytes) {
+    return 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) {
+    return 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.buffer.toString("base64");
+};
+
+// src/share.js
+var DEFAULT_CAPTURE_COUNT = 9;
+var DEFAULT_COLUMNS = 3;
+var DEFAULT_SETTLE_MS = 550;
+var DEFAULT_TIMEOUT_MS = 5e4;
+var DEFAULT_POLL_INTERVAL_MS = 800;
+var Share = {
+  captureScreen,
+  captureLink
+};
+async function captureScreen(ctx, options = {}) {
+  const startedAt = Date.now();
+  const frameBuffers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const targetSelector = options.selector || { id: "message_list" };
+  await Device.hideKeyboard(ctx, { attempts: 2, settleMs: 350 }).catch(() => {
+  });
+  await DeviceInput.scrollToTop(ctx, targetSelector, {
+    maxSwipes: Number(options.scrollToTopMaxSwipes || 12),
+    stableRounds: 2,
+    settleMs: 400
+  }).catch((error) => {
+    Logger.warn("captureScreen scrollToTop skipped", { message: error?.message || String(error) });
+  });
+  for (let index = 0; index < DEFAULT_CAPTURE_COUNT; index += 1) {
+    await Device.hideKeyboard(ctx, { attempts: 1, settleMs: 250 }).catch(() => {
+    });
+    await sleep(DEFAULT_SETTLE_MS);
+    const png = await Device.screenshotPng(ctx);
+    const hash = (0, import_node_crypto2.createHash)("sha256").update(png).digest("hex");
+    if (seen.has(hash)) break;
+    seen.add(hash);
+    frameBuffers.push(png);
+    if (index >= DEFAULT_CAPTURE_COUNT - 1) break;
+    await DeviceInput.scroll(ctx, targetSelector, "up", {
+      swipeRatio: 0.72,
+      durationMs: 360,
+      settleMs: DEFAULT_SETTLE_MS
+    }).catch(() => {
+    });
+  }
+  const sprite = await composeSprite(frameBuffers, { columns: DEFAULT_COLUMNS, gap: 16 });
+  const compression = resolveImageCompression(options);
+  const base64 = await compressImageBufferToBase64(sprite, compression);
+  Logger.success("Share.captureScreen", {
+    duration: Logger.duration(startedAt),
+    frameCount: frameBuffers.length,
+    base64Bytes: Math.ceil(base64.length)
+  });
+  return `data:image/jpeg;base64,${base64}`;
+}
+async function captureLink(ctx, options = {}) {
+  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_MS);
+  const pollIntervalMs = Number(options.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS);
+  const deadline = Date.now() + timeoutMs;
+  const prefix = String(share.prefix || "").trim();
+  Logger.start("Share.captureLink", { actor: actorInfo.key, prefix, timeoutMs });
+  await clearClipboard(ctx).catch((error) => {
+    Logger.warn("Share.captureLink clearClipboard failed", { message: error?.message || String(error) });
+  });
+  if (typeof options.performActions === "function") {
+    await options.performActions();
+  }
+  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) {
+      Logger.success("Share.captureLink", { link });
+      return { link, source: event.source || "clipboard", payloadSnapshot: event.payloadSnapshot || "" };
+    }
+    await sleep(pollIntervalMs);
+  }
+  throw new CrawlerError({
+    message: "source_extraction_failed: \u672A\u6355\u83B7\u5206\u4EAB\u94FE\u63A5",
+    code: Code.SourceExtractionFailed,
+    context: { prefix, lastEvent }
+  });
+}
+async function clearClipboard(ctx) {
+  await runFridaScriptInternal(ctx, clipboardScript("clear"), {
+    label: "share-clear-clipboard",
+    timeoutMs: 8e3,
+    fridaTimeoutSeconds: 8
+  });
+}
+async function readClipboard(ctx) {
+  return runFridaScriptInternal(ctx, clipboardScript("read"), {
+    label: "share-read-clipboard",
+    timeoutMs: 9e3,
+    fridaTimeoutSeconds: 8,
+    maxLines: 1500
+  });
+}
+function clipboardScript(mode) {
+  return `
+Java.perform(function () {
+  function emit(payload) { console.log('ANDROID_TOOLKIT_SCRIPT_JSON ' + JSON.stringify(payload)); }
+  var mode = ${JSON.stringify(mode)};
+  var JavaObject = Java.use('java.lang.Object');
+  function text(value) {
+    if (value === null || value === undefined) return '';
+    try { return Java.cast(value, JavaObject).toString() + ''; } catch (_) {}
+    try { return value.toString.overload().call(value) + ''; } catch (_) {}
+    try { return value.toString() + ''; } catch (_) {}
+    return '';
+  }
+  function addCandidate(out, source, value) {
+    var s = text(value);
+    if (!s) return;
+    var matches = s.match(/https?:\\/\\/[^\\s"'<>\uFF0C\u3002]+/g) || [];
+    for (var i = 0; i < matches.length; i++) {
+      var link = matches[i].replace(/[)\\].,\uFF0C\u3002\uFF1B;!?\uFF01\uFF1F]+$/g, '');
+      out.push({ source: source, link: link, payload: s.slice(0, 1000) });
+    }
+  }
+  try {
+    var ActivityThread = Java.use('android.app.ActivityThread');
+    var ClipData = Java.use('android.content.ClipData');
+    var app = ActivityThread.currentApplication();
+    var manager = app ? app.getSystemService('clipboard') : null;
+    if (!manager) { emit({ ok: false, error: 'clipboard manager unavailable' }); return; }
+    if (mode === 'clear') {
+      manager.setPrimaryClip(ClipData.newPlainText('android-toolkit', ''));
+      emit({ ok: true, source: 'clipboard.clear' });
+      return;
+    }
+    var candidates = [];
+    var clip = manager.getPrimaryClip();
+    var count = clip ? clip.getItemCount() : 0;
+    for (var i = 0; i < count; i++) {
+      var item = clip.getItemAt(i);
+      try { addCandidate(candidates, 'clipboard.text', item.getText()); } catch (_) {}
+      try { addCandidate(candidates, 'clipboard.html', item.getHtmlText()); } catch (_) {}
+      try { addCandidate(candidates, 'clipboard.uri', item.getUri()); } catch (_) {}
+      try { addCandidate(candidates, 'clipboard.intent', item.getIntent()); } catch (_) {}
+      try { addCandidate(candidates, 'clipboard.coerceToText', item.coerceToText(app)); } catch (_) {}
+    }
+    emit({
+      ok: candidates.length > 0,
+      link: candidates.length > 0 ? candidates[0].link : '',
+      source: candidates.length > 0 ? candidates[0].source : 'clipboard',
+      candidates: candidates,
+      payloadSnapshot: candidates.length > 0 ? String(candidates[0].payload || '').slice(0, 500) : ''
+    });
+  } catch (error) {
+    emit({ ok: false, error: String(error), stack: String(error.stack || '') });
+  }
+});
+`;
+}
+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);
+}
+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)) || "";
+}
+
+// src/launch.js
+var DEFAULT_INPUT_PATH = "/apify_storage/input.json";
+var DEFAULT_OUTPUT_PATH = "/apify_storage/output.json";
+var Launch = {
+  run
+};
+async function run(handler, options = {}) {
+  const startedAt = Date.now();
+  const inputPath = pathOption(options.inputPath, DEFAULT_INPUT_PATH);
+  const outputPath = pathOption(options.outputPath, DEFAULT_OUTPUT_PATH);
+  const input = options.input || JSON.parse(import_node_fs3.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 apifyKit = await ApifyKit.useApifyKit({
+    reset: true,
+    input,
+    ctx,
+    inputPath,
+    outputPath
+  });
+  const kit = {
+    Launch,
+    ApifyKit: apifyKit,
+    Device,
+    DeviceInput,
+    DeviceView,
+    Frida,
+    Share,
+    Mutation,
+    Logger,
+    Context
+  };
+  try {
+    Logger.start("Launch.run", {
+      inputPath,
+      outputPath,
+      runId: ctx.runId,
+      serial: ctx.serial,
+      packageName: ctx.packageName,
+      queryChars: ctx.query.length
+    });
+    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 });
+    }
+    Logger.success("Launch.run", { duration: Logger.duration(startedAt) });
+  } catch (error) {
+    Logger.fail(`Launch.run 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;
+  }
+}
+function pathOption(value, fallback) {
+  const clean = String(value || "").trim();
+  return clean || fallback;
+}
+
+// entrys/node.js
+var useAndroidToolKit = () => ({
+  Launch,
+  ApifyKit,
+  DeviceInput,
+  DeviceView,
+  Device,
+  Mutation,
+  Share,
+  Frida,
+  Constants: constants_exports,
+  Errors: errors_exports,
+  Logger,
+  Context,
+  $Internals: {
+    LOG_TEMPLATES,
+    stripAnsi
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAndroidToolKit
+});
+//# sourceMappingURL=index.cjs.map