assistsx-js 0.2.1 → 0.2.3

package/dist/step-flow/index.cjs

@@ -0,0 +1,4367 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/step-flow/index.ts
+var step_flow_exports = {};
+__export(step_flow_exports, {
+  StepFlow: () => StepFlow,
+  assignFlowPayload: () => assignFlowPayload,
+  buildFlowInitialData: () => buildFlowInitialData,
+  createFinishHandoff: () => createFinishHandoff,
+  createFlowDispatcher: () => createFlowDispatcher,
+  createLaunchState: () => createLaunchState,
+  flowEnd: () => flowEnd,
+  flowEvent: () => flowEvent,
+  flowRepeat: () => flowRepeat,
+  getFlowPayload: () => getFlowPayload
+});
+module.exports = __toCommonJS(step_flow_exports);
+
+// src/step-flow/outcome.ts
+function flowEvent(name) {
+  return { type: "event", name };
+}
+function flowRepeat() {
+  return { type: "repeat" };
+}
+function flowEnd() {
+  return { type: "end" };
+}
+
+// src/step-flow/payload.ts
+function asFlowData(step) {
+  return step.data;
+}
+function getFlowPayload(step) {
+  const data = asFlowData(step);
+  const payload = data.payload;
+  if (payload !== null && payload !== void 0 && typeof payload === "object" && !Array.isArray(payload)) {
+    return payload;
+  }
+  return {};
+}
+function assignFlowPayload(step, partial) {
+  const data = asFlowData(step);
+  const current = getFlowPayload(step);
+  data.payload = { ...current, ...partial };
+}
+
+// src/step-flow/legacy-handoff.ts
+function createFinishHandoff(dispatcher, nextState) {
+  return async (step) => {
+    const data = step.data;
+    if (!data.__flow) {
+      data.__flow = { state: nextState };
+    } else {
+      data.__flow.state = nextState;
+    }
+    return step.next(dispatcher);
+  };
+}
+function createLaunchState(dispatcher, launchImpl, nextState, legacyDataKeys = ["appName", "packageName"]) {
+  return {
+    run: async (step) => {
+      const payload = getFlowPayload(step);
+      for (const key of legacyDataKeys) {
+        if (payload[key] !== void 0) {
+          step.data[key] = payload[key];
+        }
+      }
+      step.data.finishMethod = createFinishHandoff(
+        dispatcher,
+        nextState
+      );
+      return { type: "legacy", impl: launchImpl };
+    },
+    on: {}
+  };
+}
+
+// src/bounds.ts
+var Bounds = class _Bounds {
+  // 构造函数
+  constructor(left, top, right, bottom, width, height, centerX, centerY, exactCenterX, exactCenterY, isEmpty) {
+    this.left = left;
+    this.top = top;
+    this.right = right;
+    this.bottom = bottom;
+    this.width = width;
+    this.height = height;
+    this.centerX = centerX;
+    this.centerY = centerY;
+    this.exactCenterX = exactCenterX;
+    this.exactCenterY = exactCenterY;
+    this.isEmpty = isEmpty;
+  }
+  /**
+   * 判断该 Bounds 是否在屏幕内（满足基本几何有效性）
+   * @returns {boolean}
+   */
+  isInScreen() {
+    return this.centerX > 0 && this.centerY > 0 && this.height > 0 && this.width > 0;
+  }
+  // 从普通对象创建 Bounds 实例
+  static from(data) {
+    return new _Bounds(
+      data.left,
+      data.top,
+      data.right,
+      data.bottom,
+      data.width,
+      data.height,
+      data.centerX,
+      data.centerY,
+      data.exactCenterX,
+      data.exactCenterY,
+      data.isEmpty
+    );
+  }
+  // 从 JSON 字符串创建实例
+  static fromJSON(json) {
+    const data = JSON.parse(json);
+    return _Bounds.from(data);
+  }
+  static fromData(data) {
+    if (data == null) {
+      return new _Bounds(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, true);
+    }
+    if (typeof data !== "object" || Array.isArray(data)) {
+      throw new Error(
+        `Bounds.fromData: Expected object, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return new _Bounds(
+      data.left,
+      data.top,
+      data.right,
+      data.bottom,
+      data.width,
+      data.height,
+      data.centerX,
+      data.centerY,
+      data.exactCenterX,
+      data.exactCenterY,
+      data.isEmpty
+    );
+  }
+  // 转换为普通对象
+  toJSON() {
+    return {
+      left: this.left,
+      top: this.top,
+      right: this.right,
+      bottom: this.bottom,
+      width: this.width,
+      height: this.height,
+      centerX: this.centerX,
+      centerY: this.centerY,
+      exactCenterX: this.exactCenterX,
+      exactCenterY: this.exactCenterY,
+      isEmpty: this.isEmpty
+    };
+  }
+  // 克隆方法
+  clone() {
+    return new _Bounds(
+      this.left,
+      this.top,
+      this.right,
+      this.bottom,
+      this.width,
+      this.height,
+      this.centerX,
+      this.centerY,
+      this.exactCenterX,
+      this.exactCenterY,
+      this.isEmpty
+    );
+  }
+};
+
+// src/call-method.ts
+var CallMethod = {
+  takeScreenshot: "takeScreenshot",
+  takeScreenshotSave: "takeScreenshotSave",
+  takeScreenshotToFile: "takeScreenshotToFile",
+  overlayToast: "overlayToast",
+  setNodeText: "setNodeText",
+  findByTags: "findByTags",
+  findById: "findById",
+  findByText: "findByText",
+  findByTextAllMatch: "findByTextAllMatch",
+  containsText: "containsText",
+  getAllText: "getAllText",
+  findFirstParentByTags: "findFirstParentByTags",
+  getAllNodes: "getAllNodes",
+  getNodes: "getNodes",
+  findFirstParentClickable: "findFirstParentClickable",
+  getChildren: "getChildren",
+  getBoundsInScreen: "getBoundsInScreen",
+  isVisible: "isVisible",
+  click: "click",
+  longClick: "longClick",
+  back: "back",
+  home: "home",
+  notifications: "notifications",
+  recentApps: "recentApps",
+  paste: "paste",
+  focus: "focus",
+  selectionText: "selectionText",
+  scrollForward: "scrollForward",
+  launchApp: "launchApp",
+  getPackageName: "getPackageName",
+  getScreenSize: "getScreenSize",
+  getAppScreenSize: "getAppScreenSize",
+  scrollBackward: "scrollBackward",
+  setOverlayFlags: "setOverlayFlags",
+  scanQR: "scanQR",
+  loadWebViewOverlay: "loadWebViewOverlay",
+  closeOverlay: "closeOverlay",
+  recognizeTextInScreenshot: "recognizeTextInScreenshot",
+  clickByGesture: "clickByGesture",
+  clickNodeByGesture: "clickNodeByGesture",
+  doubleClickNodeByGesture: "doubleClickNodeByGesture",
+  performLinearGesture: "performLinearGesture",
+  longPressGestureAutoPaste: "longPressGestureAutoPaste",
+  getAppInfo: "getAppInfo",
+  getMacAddress: "getMacAddress",
+  getAndroidID: "getAndroidID",
+  getUniqueDeviceId: "getUniqueDeviceId",
+  addAccessibilityEventFilter: "addAccessibilityEventFilter",
+  setAccessibilityEventFilters: "setAccessibilityEventFilters",
+  httpRequest: "httpRequest",
+  getDeviceInfo: "getDeviceInfo",
+  getNetworkType: "getNetworkType",
+  isAppInstalled: "isAppInstalled",
+  getClipboardLatestText: "getClipboardLatestText",
+  getClipboardText: "getClipboardText",
+  openUrlInBrowser: "openUrlInBrowser",
+  keepScreenOn: "keepScreenOn",
+  clearKeepScreenOn: "clearKeepScreenOn",
+  download: "download",
+  audioPlayFromFile: "audioPlayFromFile",
+  audioStop: "audioStop",
+  audioPlayRingtone: "audioPlayRingtone",
+  audioStopRingtone: "audioStopRingtone",
+  // 通讯录相关方法
+  addContact: "addContact",
+  getAllContacts: "getAllContacts",
+  // 节点树相关方法
+  saveRootNodeTreeJson: "saveRootNodeTreeJson"
+};
+
+// src/call-response.ts
+var CallResponse = class {
+  constructor(code, data, callbackId) {
+    this.code = code;
+    this.data = data;
+    this.callbackId = callbackId;
+  }
+  // 判断是否成功
+  isSuccess() {
+    return this.code === 0;
+  }
+  // 获取数据，如果数据为空则抛出错误
+  getData() {
+    if (this.data === null) {
+      throw new Error("Data is null");
+    }
+    return this.data;
+  }
+  // 获取数据，如果数据为空则返回默认值
+  getDataOrNull() {
+    return this.data;
+  }
+  // 获取数据，如果数据为空则返回默认值
+  getDataOrDefault(defaultValue) {
+    var _a2;
+    return (_a2 = this.data) != null ? _a2 : defaultValue;
+  }
+};
+
+// src/utils.ts
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function decodeBase64UTF8(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder("utf-8").decode(bytes);
+}
+
+// src/app-info.ts
+var AppInfo = class _AppInfo {
+  constructor(isSystem = false, minSdkVersion = 0, name = "", packageName = "", targetSdkVersion = 0, versionCode = 0, versionName = "") {
+    this.isSystem = isSystem;
+    this.minSdkVersion = minSdkVersion;
+    this.name = name;
+    this.packageName = packageName;
+    this.targetSdkVersion = targetSdkVersion;
+    this.versionCode = versionCode;
+    this.versionName = versionName;
+  }
+  /**
+   * 从JSON对象创建AppInfo实例
+   * @param data JSON对象
+   * @returns AppInfo实例
+   */
+  static fromJSON(data) {
+    var _a2, _b, _c, _d, _e, _f, _g;
+    return new _AppInfo(
+      (_a2 = data.isSystem) != null ? _a2 : false,
+      (_b = data.minSdkVersion) != null ? _b : 0,
+      (_c = data.name) != null ? _c : "",
+      (_d = data.packageName) != null ? _d : "",
+      (_e = data.targetSdkVersion) != null ? _e : 0,
+      (_f = data.versionCode) != null ? _f : 0,
+      (_g = data.versionName) != null ? _g : ""
+    );
+  }
+  /**
+   * 转换为JSON对象
+   * @returns JSON对象
+   */
+  toJSON() {
+    return {
+      isSystem: this.isSystem,
+      minSdkVersion: this.minSdkVersion,
+      name: this.name,
+      packageName: this.packageName,
+      targetSdkVersion: this.targetSdkVersion,
+      versionCode: this.versionCode,
+      versionName: this.versionName
+    };
+  }
+};
+
+// src/device-info.ts
+var DeviceInfo = class _DeviceInfo {
+  constructor(uniqueDeviceId = "", androidID = "", macAddress = "", isDeviceRooted = false, manufacturer = "", model = "", sdkVersionCode = 0, sdkVersionName = "", abiList = [], isAdbEnabled = false, isDevelopmentSettingsEnabled = false, isEmulator = false, isTablet = false) {
+    this.uniqueDeviceId = uniqueDeviceId;
+    this.androidID = androidID;
+    this.macAddress = macAddress;
+    this.isDeviceRooted = isDeviceRooted;
+    this.manufacturer = manufacturer;
+    this.model = model;
+    this.sdkVersionCode = sdkVersionCode;
+    this.sdkVersionName = sdkVersionName;
+    this.abiList = abiList;
+    this.isAdbEnabled = isAdbEnabled;
+    this.isDevelopmentSettingsEnabled = isDevelopmentSettingsEnabled;
+    this.isEmulator = isEmulator;
+    this.isTablet = isTablet;
+  }
+  /**
+   * 从JSON对象创建DeviceInfo实例
+   * @param data JSON对象
+   * @returns DeviceInfo实例
+   */
+  static fromJSON(data) {
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    return new _DeviceInfo(
+      (_a2 = data.uniqueDeviceId) != null ? _a2 : "",
+      (_b = data.androidID) != null ? _b : "",
+      (_c = data.macAddress) != null ? _c : "",
+      (_d = data.isDeviceRooted) != null ? _d : false,
+      (_e = data.manufacturer) != null ? _e : "",
+      (_f = data.model) != null ? _f : "",
+      (_g = data.sdkVersionCode) != null ? _g : 0,
+      (_h = data.sdkVersionName) != null ? _h : "",
+      (_i = data.abiList) != null ? _i : [],
+      (_j = data.isAdbEnabled) != null ? _j : false,
+      (_k = data.isDevelopmentSettingsEnabled) != null ? _k : false,
+      (_l = data.isEmulator) != null ? _l : false,
+      (_m = data.isTablet) != null ? _m : false
+    );
+  }
+  /**
+   * 转换为JSON对象
+   * @returns JSON对象
+   */
+  toJSON() {
+    return {
+      uniqueDeviceId: this.uniqueDeviceId,
+      androidID: this.androidID,
+      macAddress: this.macAddress,
+      isDeviceRooted: this.isDeviceRooted,
+      manufacturer: this.manufacturer,
+      model: this.model,
+      sdkVersionCode: this.sdkVersionCode,
+      sdkVersionName: this.sdkVersionName,
+      abiList: this.abiList,
+      isAdbEnabled: this.isAdbEnabled,
+      isDevelopmentSettingsEnabled: this.isDevelopmentSettingsEnabled,
+      isEmulator: this.isEmulator,
+      isTablet: this.isTablet
+    };
+  }
+};
+
+// src/assistsx-async.ts
+var AssistsXAsync = class {
+  /**
+   * 执行异步调用
+   * @param method 方法名
+   * @param args 参数对象
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns Promise<调用响应>
+   */
+  static async asyncCall(method, {
+    args,
+    node,
+    nodes,
+    timeout = 30
+  } = {}) {
+    const uuid = generateUUID();
+    const params = {
+      method,
+      arguments: args ? args : void 0,
+      node: node ? node : void 0,
+      nodes: nodes ? nodes : void 0,
+      callbackId: uuid
+    };
+    const promise = new Promise((resolve) => {
+      callbacks.set(uuid, (data) => {
+        resolve(data);
+      });
+      setTimeout(() => {
+        callbacks.delete(uuid);
+        resolve(new CallResponse(0, null, uuid));
+      }, timeout * 1e3);
+    });
+    const result = window.assistsxAsync.call(JSON.stringify(params));
+    const promiseResult = await promise;
+    if (typeof promiseResult === "string") {
+      const responseData = JSON.parse(promiseResult);
+      const response = new CallResponse(
+        responseData.code,
+        responseData.data,
+        responseData.callbackId
+      );
+      return response;
+    }
+    throw new Error("Call failed");
+  }
+  /**
+   * 设置悬浮窗标志
+   * @param flags 标志
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否设置成功
+   */
+  static async setOverlayFlags(flags, timeout) {
+    const response = await this.asyncCall(CallMethod.setOverlayFlags, {
+      args: { flags },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 设置悬浮窗标志
+   * @param flags 标志
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否设置成功
+   */
+  static async setOverlayFlagList(flags, timeout) {
+    const response = await this.asyncCall(CallMethod.setOverlayFlags, {
+      args: { flags },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 获取所有符合条件的节点
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param filterText 文本过滤
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 节点数组
+   */
+  static async getAllNodes({
+    filterClass,
+    filterViewId,
+    filterDes,
+    filterText,
+    timeout,
+    scope
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.getAllNodes, {
+      args: {
+        filterClass,
+        filterViewId,
+        filterDes,
+        filterText,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.getAllNodes: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 设置节点文本
+   * @param node 目标节点
+   * @param text 要设置的文本
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否设置成功
+   */
+  static async setNodeText(node, text, timeout) {
+    const response = await this.asyncCall(CallMethod.setNodeText, {
+      args: { text },
+      node,
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 对指定节点进行截图
+   * @param nodes 要截图的节点数组
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 截图路径数组
+   */
+  static async takeScreenshotNodes(nodes, overlayHiddenScreenshotDelayMillis = 250, timeout) {
+    const response = await this.asyncCall(CallMethod.takeScreenshot, {
+      nodes,
+      args: { overlayHiddenScreenshotDelayMillis },
+      timeout
+    });
+    const data = response.getDataOrDefault({ images: [] });
+    return data.images;
+  }
+  /**
+   * 保存全屏截图到文件
+   * @param options 截图保存选项
+   * @param options.filePath 文件路径（可选，不提供则自动生成）
+   * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认为 "PNG"
+   * @param options.overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)，默认为 250
+   * @param options.timeout 超时时间(秒)，默认30秒
+   * @returns 保存的文件路径
+   */
+  static async takeScreenshotSave(options = {}) {
+    const {
+      filePath,
+      format = "PNG",
+      overlayHiddenScreenshotDelayMillis = 250,
+      timeout
+    } = options;
+    const response = await this.asyncCall(CallMethod.takeScreenshotSave, {
+      args: {
+        filePath,
+        format,
+        overlayHiddenScreenshotDelayMillis
+      },
+      timeout
+    });
+    const data = response.getDataOrDefault({ file: "" });
+    return data.file;
+  }
+  /**
+   * 保存截图到文件（支持多个节点）
+   * @param options 截图保存选项
+   * @param options.nodes 要截图的节点数组（可选，不提供则保存全屏截图）
+   * @param options.filePath 文件路径（可选，不提供则自动生成。多个节点时会自动添加索引后缀）
+   * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认为 "PNG"
+   * @param options.overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)，默认为 250
+   * @param options.timeout 超时时间(秒)，默认30秒
+   * @returns 保存的文件路径数组
+   */
+  static async takeScreenshotToFile(options = {}) {
+    const {
+      nodes,
+      filePath,
+      format = "PNG",
+      overlayHiddenScreenshotDelayMillis = 250,
+      timeout
+    } = options;
+    const response = await this.asyncCall(CallMethod.takeScreenshotToFile, {
+      nodes,
+      args: {
+        filePath,
+        format,
+        overlayHiddenScreenshotDelayMillis
+      },
+      timeout
+    });
+    const data = response.getDataOrDefault({ files: [] });
+    if (!Array.isArray(data.files)) {
+      throw new Error(
+        `AssistsXAsync.takeScreenshotToFile: Expected files array, but got ${typeof data.files}. Value: ${JSON.stringify(data.files)}`
+      );
+    }
+    return data.files;
+  }
+  /**
+   * 截图识别文本
+   * @param param0 识别参数
+   * @returns 截图识别结果
+   */
+  static async recognizeTextInScreenshot(targetText, options = {}) {
+    const {
+      rotationDegrees = 0,
+      overlayHiddenScreenshotDelayMillis = 250,
+      restoreOverlay = true,
+      region,
+      timeout
+    } = options;
+    const response = await this.asyncCall(
+      CallMethod.recognizeTextInScreenshot,
+      {
+        args: {
+          targetText,
+          rotationDegrees,
+          overlayHiddenScreenshotDelayMillis,
+          restoreOverlay,
+          region
+        },
+        timeout
+      }
+    );
+    return response.getDataOrDefault({
+      fullText: "",
+      processingTimeMillis: 0,
+      positions: []
+    });
+  }
+  static async scanQR(timeout) {
+    const response = await this.asyncCall(CallMethod.scanQR, { timeout });
+    const data = response.getDataOrDefault({ value: "" });
+    return data.value;
+  }
+  static async loadWebViewOverlay(url, options = {}) {
+    const {
+      initialWidth,
+      initialHeight,
+      initialX,
+      initialY,
+      minWidth,
+      minHeight,
+      maxWidth,
+      maxHeight,
+      initialCenter,
+      showTopOperationArea,
+      showBottomOperationArea,
+      backgroundColor,
+      timeout
+    } = options;
+    const response = await this.asyncCall(CallMethod.loadWebViewOverlay, {
+      args: {
+        url,
+        initialWidth,
+        initialHeight,
+        initialX,
+        initialY,
+        minWidth,
+        minHeight,
+        maxWidth,
+        maxHeight,
+        initialCenter,
+        showTopOperationArea,
+        showBottomOperationArea,
+        backgroundColor
+      },
+      timeout
+    });
+    const data = response.getDataOrDefault({});
+    return data;
+  }
+  /**
+   * 关闭当前 WebView 悬浮窗
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否关闭成功（当前页面在悬浮窗内时返回 true，否则 false）
+   */
+  static async closeOverlay(timeout) {
+    const response = await this.asyncCall(CallMethod.closeOverlay, {
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 点击节点
+   * @param node 要点击的节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否点击成功
+   */
+  static async click(node, timeout) {
+    const response = await this.asyncCall(CallMethod.click, { node, timeout });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 长按节点
+   * @param node 要长按的节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否长按成功
+   */
+  static async longClick(node, timeout) {
+    const response = await this.asyncCall(CallMethod.longClick, {
+      node,
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 启动应用
+   * @param packageName 应用包名
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否启动成功
+   */
+  static async launchApp(packageName, timeout) {
+    const response = await this.asyncCall(CallMethod.launchApp, {
+      args: { packageName },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  static async getPackageName(timeoutOrOptions) {
+    const normalized = typeof timeoutOrOptions === "number" ? { timeout: timeoutOrOptions } : timeoutOrOptions != null ? timeoutOrOptions : {};
+    const { timeout, scope } = normalized;
+    const response = await this.asyncCall(CallMethod.getPackageName, {
+      args: scope !== void 0 ? { scope } : void 0,
+      timeout
+    });
+    return response.getDataOrDefault("");
+  }
+  /**
+   * 显示悬浮提示
+   * @param text 提示文本
+   * @param delay 显示时长(毫秒)
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否显示成功
+   */
+  static async overlayToast(text, delay = 2e3, timeout) {
+    const response = await this.asyncCall(CallMethod.overlayToast, {
+      args: { text, delay },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 通过ID查找节点
+   * @param id 节点ID
+   * @param filterClass 类名过滤
+   * @param filterText 文本过滤
+   * @param filterDes 描述过滤
+   * @param node 父节点范围
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 节点数组
+   */
+  static async findById(id, {
+    filterClass,
+    filterText,
+    filterDes,
+    node,
+    timeout,
+    scope
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.findById, {
+      args: {
+        id,
+        filterClass,
+        filterText,
+        filterDes,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      node,
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.findById: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 通过文本查找节点
+   * @param text 要查找的文本
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param node 父节点范围
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 节点数组
+   */
+  static async findByText(text, {
+    filterClass,
+    filterViewId,
+    filterDes,
+    node,
+    timeout,
+    scope
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.findByText, {
+      args: {
+        text,
+        filterClass,
+        filterViewId,
+        filterDes,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      node,
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.findByText: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 通过标签查找节点
+   * @param className 类名
+   * @param filterText 文本过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param node 父节点范围
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 节点数组
+   */
+  static async findByTags(className, {
+    filterText,
+    filterViewId,
+    filterDes,
+    node,
+    timeout,
+    scope
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.findByTags, {
+      args: {
+        className,
+        filterText,
+        filterViewId,
+        filterDes,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      node,
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.findByTags: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  static async findByTextAllMatch(text, timeoutOrOptions) {
+    const normalized = typeof timeoutOrOptions === "number" ? { timeout: timeoutOrOptions } : timeoutOrOptions != null ? timeoutOrOptions : {};
+    const { timeout, scope } = normalized;
+    const response = await this.asyncCall(CallMethod.findByTextAllMatch, {
+      args: {
+        text,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.findByTextAllMatch: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 检查是否包含指定文本
+   * @param text 要检查的文本
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否包含
+   */
+  static async containsText(text, timeout) {
+    const response = await this.asyncCall(CallMethod.containsText, {
+      args: { text },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 获取所有文本
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 文本数组
+   */
+  static async getAllText(timeout) {
+    const response = await this.asyncCall(CallMethod.getAllText, { timeout });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.getAllText: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return data;
+  }
+  /**
+   * 查找第一个匹配标签的父节点
+   * @param className 类名
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 父节点
+   */
+  static async findFirstParentByTags(node, className, timeout) {
+    const response = await this.asyncCall(CallMethod.findFirstParentByTags, {
+      args: { className },
+      node,
+      timeout
+    });
+    return Node.create(response.getDataOrDefault({}));
+  }
+  /**
+   * 获取节点的所有子节点
+   * @param node 父节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 子节点数组
+   */
+  static async getNodes(node, timeout) {
+    const response = await this.asyncCall(CallMethod.getNodes, {
+      node,
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.getNodes: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 获取节点的直接子节点
+   * @param node 父节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 子节点数组
+   */
+  static async getChildren(node, timeout) {
+    const response = await this.asyncCall(CallMethod.getChildren, {
+      node,
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.getChildren: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 查找第一个可点击的父节点
+   * @param node 起始节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 可点击的父节点
+   */
+  static async findFirstParentClickable(node, timeout) {
+    const response = await this.asyncCall(CallMethod.findFirstParentClickable, {
+      node,
+      timeout
+    });
+    return Node.create(response.getDataOrDefault({}));
+  }
+  /**
+   * 获取节点在屏幕中的边界
+   * @param node 目标节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 边界对象
+   */
+  static async getBoundsInScreen(node, timeout) {
+    const response = await this.asyncCall(CallMethod.getBoundsInScreen, {
+      node,
+      timeout
+    });
+    return Bounds.fromData(response.getDataOrDefault({}));
+  }
+  /**
+   * 检查节点是否可见
+   * @param node 目标节点
+   * @param compareNode 比较节点
+   * @param isFullyByCompareNode 是否完全可见
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否可见
+   */
+  static async isVisible(node, {
+    compareNode,
+    isFullyByCompareNode,
+    timeout
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.isVisible, {
+      node,
+      args: { compareNode, isFullyByCompareNode },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 执行点击手势
+   * @param x 横坐标
+   * @param y 纵坐标
+   * @param duration 持续时间
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async clickByGesture(x, y, duration, timeout) {
+    const response = await this.asyncCall(CallMethod.clickByGesture, {
+      args: { x, y, duration },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 返回操作
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async back(timeout) {
+    const response = await this.asyncCall(CallMethod.back, { timeout });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 回到主页
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async home(timeout) {
+    const response = await this.asyncCall(CallMethod.home, { timeout });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 打开通知栏
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async notifications(timeout) {
+    const response = await this.asyncCall(CallMethod.notifications, {
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 显示最近应用
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async recentApps(timeout) {
+    const response = await this.asyncCall(CallMethod.recentApps, { timeout });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 在节点中粘贴文本
+   * @param node 目标节点
+   * @param text 要粘贴的文本
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async paste(node, text, timeout) {
+    const response = await this.asyncCall(CallMethod.paste, {
+      args: { text },
+      node,
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  static async focus(node, timeout) {
+    const response = await this.asyncCall(CallMethod.focus, { node, timeout });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 选择文本
+   * @param node 目标节点
+   * @param selectionStart 选择起始位置
+   * @param selectionEnd 选择结束位置
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async selectionText(node, selectionStart, selectionEnd, timeout) {
+    const response = await this.asyncCall(CallMethod.selectionText, {
+      args: { selectionStart, selectionEnd },
+      node,
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 向前滚动
+   * @param node 可滚动节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async scrollForward(node, timeout) {
+    const response = await this.asyncCall(CallMethod.scrollForward, {
+      node,
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 向后滚动
+   * @param node 可滚动节点
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async scrollBackward(node, timeout) {
+    const response = await this.asyncCall(CallMethod.scrollBackward, {
+      node,
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 对节点执行点击手势
+   * @param node 目标节点
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async clickNodeByGesture(node, {
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration,
+    timeout
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.clickNodeByGesture, {
+      node,
+      args: { offsetX, offsetY, switchWindowIntervalDelay, clickDuration },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 对节点执行双击手势
+   * @param node 目标节点
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @param clickInterval 点击间隔
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async doubleClickNodeByGesture(node, {
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration,
+    clickInterval,
+    timeout
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.doubleClickNodeByGesture, {
+      node,
+      args: {
+        offsetX,
+        offsetY,
+        switchWindowIntervalDelay,
+        clickDuration,
+        clickInterval
+      },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 执行线型手势
+   * @param startPoint
+   * @param endPoint
+   * @param param2
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns
+   */
+  static async performLinearGesture(startPoint, endPoint, { duration, timeout } = {}) {
+    const response = await this.asyncCall(CallMethod.performLinearGesture, {
+      args: { startPoint, endPoint, duration },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  static async longPressNodeByGestureAutoPaste(node, text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration,
+    timeout
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    const response = await this.asyncCall(
+      CallMethod.longPressGestureAutoPaste,
+      {
+        node,
+        args: {
+          text,
+          matchedPackageName,
+          matchedText,
+          timeoutMillis,
+          longPressDuration
+        },
+        timeout
+      }
+    );
+    return response.getDataOrDefault(false);
+  }
+  static async longPressGestureAutoPaste(point, text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration,
+    timeout
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    const response = await this.asyncCall(
+      CallMethod.longPressGestureAutoPaste,
+      {
+        args: {
+          point,
+          text,
+          matchedPackageName,
+          matchedText,
+          timeoutMillis,
+          longPressDuration
+        },
+        timeout
+      }
+    );
+    return response.getDataOrDefault(false);
+  }
+  static async getAppInfo(packageName, timeout) {
+    const response = await this.asyncCall(CallMethod.getAppInfo, {
+      args: { packageName },
+      timeout
+    });
+    return AppInfo.fromJSON(response.getDataOrDefault({}));
+  }
+  static async getUniqueDeviceId(timeout) {
+    const response = await this.asyncCall(CallMethod.getUniqueDeviceId, {
+      timeout
+    });
+    return response.getDataOrDefault("");
+  }
+  static async getAndroidID(timeout) {
+    const response = await this.asyncCall(CallMethod.getAndroidID, { timeout });
+    return response.getDataOrDefault("");
+  }
+  static async getMacAddress(timeout) {
+    const response = await this.asyncCall(CallMethod.getMacAddress, {
+      timeout
+    });
+    return response.getDataOrDefault({});
+  }
+  static async getDeviceInfo(timeout) {
+    const response = await this.asyncCall(CallMethod.getDeviceInfo, {
+      timeout
+    });
+    return DeviceInfo.fromJSON(response.getDataOrDefault({}));
+  }
+  /**
+   * 获取屏幕尺寸
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 屏幕尺寸对象
+   */
+  static async getScreenSize(timeout) {
+    const response = await this.asyncCall(CallMethod.getScreenSize, {
+      timeout
+    });
+    return response.getDataOrDefault({});
+  }
+  /**
+   * 获取应用窗口尺寸
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 应用窗口尺寸对象
+   */
+  static async getAppScreenSize(timeout) {
+    const response = await this.asyncCall(CallMethod.getAppScreenSize, {
+      timeout
+    });
+    return response.getDataOrDefault({});
+  }
+  /**
+   * 在浏览器中打开URL
+   * @param url 要打开的URL
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功打开
+   */
+  static async openUrlInBrowser(url, timeout) {
+    const response = await this.asyncCall(CallMethod.openUrlInBrowser, {
+      args: { url },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  static async download(url, timeout) {
+    const response = await this.asyncCall(CallMethod.download, {
+      args: { url },
+      timeout
+    });
+    return response.getDataOrDefault(null);
+  }
+  static async audioPlayFromFile(filePath, {
+    volume = void 0,
+    useAbsoluteVolume = false,
+    timeout = 30
+  }) {
+    const response = await this.asyncCall(CallMethod.audioPlayFromFile, {
+      args: { filePath, volume, useAbsoluteVolume },
+      timeout
+    });
+    return response.getDataOrDefault(null);
+  }
+  static async audioStop({
+    timeout = 30
+  }) {
+    const response = await this.asyncCall(CallMethod.audioStop, {
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 播放系统电话铃声
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 播放结果消息
+   */
+  static async audioPlayRingtone({
+    timeout = 30
+  }) {
+    const response = await this.asyncCall(CallMethod.audioPlayRingtone, {
+      timeout
+    });
+    return response.getDataOrDefault("");
+  }
+  /**
+   * 停止播放系统电话铃声
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 停止结果消息
+   */
+  static async audioStopRingtone({
+    timeout = 30
+  }) {
+    const response = await this.asyncCall(CallMethod.audioStopRingtone, {
+      timeout
+    });
+    return response.getDataOrDefault("");
+  }
+  /**
+   * 添加联系人
+   * @param name 联系人姓名（必填）
+   * @param phoneNumber 电话号码（必填）
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否添加成功
+   */
+  static async addContact(name, phoneNumber, timeout) {
+    const response = await this.asyncCall(CallMethod.addContact, {
+      args: { name, phoneNumber },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 获取所有联系人
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 联系人列表
+   */
+  static async getAllContacts(timeout) {
+    const response = await this.asyncCall(CallMethod.getAllContacts, {
+      timeout
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsXAsync.getAllContacts: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return data;
+  }
+  /**
+   * 保存根节点树为JSON文件
+   * @param options 保存选项
+   * @param options.filePath 文件路径（可选，不提供则自动生成）
+   * @param options.prettyPrint 是否格式化输出，默认为 true
+   * @param options.timeout 超时时间(秒)，默认30秒
+   * @param options.scope 节点查找范围（可选）
+   * @returns 保存的文件路径
+   */
+  static async saveRootNodeTreeJson(options = {}) {
+    const {
+      filePath,
+      prettyPrint = true,
+      timeout,
+      scope
+    } = options;
+    const response = await this.asyncCall(CallMethod.saveRootNodeTreeJson, {
+      args: {
+        filePath,
+        prettyPrint,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      timeout
+    });
+    const data = response.getDataOrDefault({ file: "" });
+    return data.file;
+  }
+  /**
+   * 获取剪贴板文本内容
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 剪贴板文本内容，如果获取失败则返回空字符串
+   */
+  static async getClipboardText(timeout) {
+    const response = await this.asyncCall(CallMethod.getClipboardText, {
+      timeout
+    });
+    const data = response.getDataOrDefault({ text: "" });
+    return data.text || "";
+  }
+  /**
+   * 发送HTTP请求
+   * @param options 请求选项
+   * @returns HTTP响应
+   */
+  // public static async httpRequest(
+  //   options: HttpRequestOptions
+  // ): Promise<HttpResponse> {
+  //   const { url, method = "GET", headers, body, timeout = 30 } = options;
+  //   const response = await this.asyncCall(CallMethod.httpRequest, {
+  //     args: { url, method, headers, body, timeout },
+  //   });
+  //   return response.getDataOrDefault({
+  //     statusCode: -1,
+  //     statusMessage: "",
+  //     body: "",
+  //     headers: {},
+  //   });
+  // }
+};
+
+// src/node-async.ts
+var NodeAsync = class {
+  /**
+   * 构造函数
+   * @param node Node实例
+   */
+  constructor(node) {
+    this.node = node;
+  }
+  /**
+   * 查找第一个匹配标签的父节点
+   * @param className 类名
+   * @returns 父节点
+   */
+  async findFirstParentByTags(className) {
+    Step.assert(this.node.stepId);
+    const node = await AssistsXAsync.findFirstParentByTags(
+      this.node,
+      className
+    );
+    Step.assert(this.node.stepId);
+    return node;
+  }
+  /**
+   * 对节点执行点击手势
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @returns 是否点击成功
+   */
+  async clickNodeByGesture({
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration
+  } = {}) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.clickNodeByGesture(this.node, {
+      offsetX,
+      offsetY,
+      switchWindowIntervalDelay,
+      clickDuration
+    });
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 对节点执行双击手势
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @param clickInterval 点击间隔
+   * @returns 是否双击成功
+   */
+  async doubleClickNodeByGesture({
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration,
+    clickInterval
+  } = {}) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.doubleClickNodeByGesture(this.node, {
+      offsetX,
+      offsetY,
+      switchWindowIntervalDelay,
+      clickDuration,
+      clickInterval
+    });
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  async longPressNodeByGestureAutoPaste(text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.longPressNodeByGestureAutoPaste(
+      this.node,
+      text,
+      {
+        matchedPackageName,
+        matchedText,
+        timeoutMillis,
+        longPressDuration
+      }
+    );
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 在当前节点范围内通过标签查找节点
+   * @param className 类名
+   * @param filterText 文本过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  async findByTags(className, {
+    filterText,
+    filterViewId,
+    filterDes
+  } = {}) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.findByTags(className, {
+      filterText,
+      filterViewId,
+      filterDes,
+      node: this.node
+    });
+    Step.assignIdsToNodes(result, this.node.stepId);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 在当前节点范围内通过ID查找节点
+   * @param id 节点ID
+   * @param filterClass 类名过滤
+   * @param filterText 文本过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  async findById(id, {
+    filterClass,
+    filterText,
+    filterDes
+  } = {}) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.findById(id, {
+      filterClass,
+      filterText,
+      filterDes,
+      node: this.node
+    });
+    Step.assignIdsToNodes(result, this.node.stepId);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 在当前节点范围内通过文本查找节点
+   * @param text 要查找的文本
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  async findByText(text, {
+    filterClass,
+    filterViewId,
+    filterDes
+  } = {}) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.findByText(text, {
+      filterClass,
+      filterViewId,
+      filterDes,
+      node: this.node
+    });
+    Step.assignIdsToNodes(result, this.node.stepId);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 向前滚动节点
+   * @returns 是否滚动成功
+   */
+  async scrollForward() {
+    Step.assert(this.node.stepId);
+    const response = await AssistsXAsync.scrollForward(this.node);
+    Step.assert(this.node.stepId);
+    return response;
+  }
+  /**
+   * 向后滚动节点
+   * @returns 是否滚动成功
+   */
+  async scrollBackward() {
+    Step.assert(this.node.stepId);
+    const response = await AssistsXAsync.scrollBackward(this.node);
+    Step.assert(this.node.stepId);
+    return response;
+  }
+  /**
+   * 检查节点是否可见
+   * @param compareNode 比较节点
+   * @param isFullyByCompareNode 是否完全可见
+   * @returns 是否可见
+   */
+  async isVisible({
+    compareNode,
+    isFullyByCompareNode
+  } = {}) {
+    Step.assert(this.node.stepId);
+    const response = await AssistsXAsync.isVisible(this.node, {
+      compareNode,
+      isFullyByCompareNode
+    });
+    Step.assert(this.node.stepId);
+    return response;
+  }
+  /**
+   * 对节点进行截图
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @returns 截图路径
+   */
+  async takeScreenshot(overlayHiddenScreenshotDelayMillis = 250) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.takeScreenshotNodes(
+      [this.node],
+      overlayHiddenScreenshotDelayMillis
+    );
+    Step.assert(this.node.stepId);
+    return result[0];
+  }
+  /**
+   * 设置节点文本
+   * @param text 要设置的文本
+   * @returns 是否设置成功
+   */
+  async setNodeText(text) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.setNodeText(this.node, text);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  async paste(text) {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.paste(this.node, text);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  async focus() {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.focus(this.node);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 点击节点
+   * @returns 是否点击成功
+   */
+  async click() {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.click(this.node);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 长按节点
+   * @returns 是否长按成功
+   */
+  async longClick() {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.longClick(this.node);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 查找第一个可点击的父节点
+   * @returns 可点击的父节点
+   */
+  async findFirstParentClickable() {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.findFirstParentClickable(this.node);
+    Step.assert(this.node.stepId);
+    Step.assignIdsToNodes([result], this.node.stepId);
+    return result;
+  }
+  /**
+   * 获取节点在屏幕中的边界
+   * @returns 边界对象
+   */
+  async getBoundsInScreen() {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.getBoundsInScreen(this.node);
+    Step.assert(this.node.stepId);
+    return result;
+  }
+  /**
+   * 获取节点的所有子节点
+   * @returns 子节点数组
+   */
+  async getNodes() {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.getNodes(this.node);
+    Step.assert(this.node.stepId);
+    Step.assignIdsToNodes(result, this.node.stepId);
+    return result;
+  }
+  /**
+   * 获取节点的直接子节点
+   * @returns 子节点数组
+   */
+  async getChildren() {
+    Step.assert(this.node.stepId);
+    const result = await AssistsXAsync.getChildren(this.node);
+    Step.assert(this.node.stepId);
+    Step.assignIdsToNodes(result, this.node.stepId);
+    return result;
+  }
+  /**
+   * 从JSON字符串创建节点实例
+   * @param json JSON字符串
+   * @returns 节点实例
+   */
+  static fromJSON(json) {
+    const data = JSON.parse(json);
+    return new Node(data);
+  }
+  /**
+   * 从普通对象创建节点实例
+   * @param data 对象数据
+   * @returns 节点实例
+   */
+  static from(data) {
+    return new Node(data);
+  }
+  /**
+   * JSON.parse的reviver函数，用于将解析的JSON对象转换为Node实例
+   * @param key 属性键
+   * @param value 属性值
+   * @returns 转换后的值
+   */
+  static reviver(key, value) {
+    return key === "" ? new Node(value) : value;
+  }
+  /**
+   * 创建新的节点实例
+   * @param params 节点参数对象
+   * @returns 节点实例
+   */
+  static create(params) {
+    return new Node(params);
+  }
+  /**
+   * 从JSON数组创建节点数组
+   * @param array JSON数组
+   * @returns 节点数组
+   */
+  static fromJSONArray(array) {
+    if (!Array.isArray(array)) {
+      throw new Error(
+        `NodeAsync.fromJSONArray: Expected array, but got ${typeof array}. Value: ${JSON.stringify(array)}`
+      );
+    }
+    return array.map((data) => new Node(data));
+  }
+};
+
+// src/node.ts
+var Node = class _Node {
+  /**
+   * 节点在屏幕中的边界
+   * @deprecated 请使用 bounds 字段替代
+   */
+  get boundsInScreen() {
+    return this.bounds;
+  }
+  /**
+   * 构造函数
+   * @param params 节点参数对象
+   */
+  constructor(params) {
+    var _a2;
+    this.nodeId = params.nodeId;
+    this.text = params.text;
+    this.des = params.des;
+    this.viewId = params.viewId;
+    this.className = params.className;
+    this.isScrollable = params.isScrollable;
+    this.isClickable = params.isClickable;
+    this.isEnabled = params.isEnabled;
+    this.stepId = params.stepId;
+    this.hintText = params.hintText;
+    this.isCheckable = params.isCheckable;
+    this.isChecked = params.isChecked;
+    this.isFocusable = params.isFocusable;
+    this.isFocused = params.isFocused;
+    this.isLongClickable = params.isLongClickable;
+    this.isPassword = params.isPassword;
+    this.isSelected = params.isSelected;
+    this.isVisibleToUser = params.isVisibleToUser;
+    this.drawingOrder = params.drawingOrder;
+    const rawBounds = (_a2 = params.bounds) != null ? _a2 : params.boundsInScreen;
+    this.bounds = rawBounds instanceof Bounds ? rawBounds : Bounds.fromData(rawBounds);
+  }
+  get async() {
+    return new NodeAsync(this);
+  }
+  /**
+   * 查找第一个匹配标签的父节点
+   * @param className 类名
+   * @returns 父节点
+   */
+  findFirstParentByTags(className) {
+    Step.assert(this.stepId);
+    const node = AssistsX2.findFirstParentByTags(this, className);
+    Step.assert(this.stepId);
+    return node;
+  }
+  /**
+   * 对节点执行点击手势
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @returns 是否点击成功
+   */
+  async clickNodeByGesture({
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration
+  } = {}) {
+    Step.assert(this.stepId);
+    const result = await AssistsX2.clickNodeByGesture(this, {
+      offsetX,
+      offsetY,
+      switchWindowIntervalDelay,
+      clickDuration
+    });
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 对节点执行双击手势
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @param clickInterval 点击间隔
+   * @returns 是否双击成功
+   */
+  async doubleClickNodeByGesture({
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration,
+    clickInterval
+  } = {}) {
+    Step.assert(this.stepId);
+    const result = await AssistsX2.doubleClickNodeByGesture(this, {
+      offsetX,
+      offsetY,
+      switchWindowIntervalDelay,
+      clickDuration,
+      clickInterval
+    });
+    Step.assert(this.stepId);
+    return result;
+  }
+  async longPressNodeByGestureAutoPaste(text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    Step.assert(this.stepId);
+    const result = await AssistsX2.longPressNodeByGestureAutoPaste(this, text, {
+      matchedPackageName,
+      matchedText,
+      timeoutMillis,
+      longPressDuration
+    });
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 在当前节点范围内通过标签查找节点
+   * @param className 类名
+   * @param filterText 文本过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  findByTags(className, {
+    filterText,
+    filterViewId,
+    filterDes
+  } = {}) {
+    Step.assert(this.stepId);
+    const result = AssistsX2.findByTags(className, {
+      filterText,
+      filterViewId,
+      filterDes,
+      node: this
+    });
+    Step.assignIdsToNodes(result, this.stepId);
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 在当前节点范围内通过ID查找节点
+   * @param id 节点ID
+   * @param filterClass 类名过滤
+   * @param filterText 文本过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  findById(id, {
+    filterClass,
+    filterText,
+    filterDes
+  } = {}) {
+    Step.assert(this.stepId);
+    const result = AssistsX2.findById(id, {
+      filterClass,
+      filterText,
+      filterDes,
+      node: this
+    });
+    Step.assignIdsToNodes(result, this.stepId);
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 在当前节点范围内通过文本查找节点
+   * @param text 要查找的文本
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  findByText(text, {
+    filterClass,
+    filterViewId,
+    filterDes
+  } = {}) {
+    Step.assert(this.stepId);
+    const result = AssistsX2.findByText(text, {
+      filterClass,
+      filterViewId,
+      filterDes,
+      node: this
+    });
+    Step.assignIdsToNodes(result, this.stepId);
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 向前滚动节点
+   * @returns 是否滚动成功
+   */
+  scrollForward() {
+    Step.assert(this.stepId);
+    const response = AssistsX2.scrollForward(this);
+    Step.assert(this.stepId);
+    return response;
+  }
+  /**
+   * 向后滚动节点
+   * @returns 是否滚动成功
+   */
+  scrollBackward() {
+    Step.assert(this.stepId);
+    const response = AssistsX2.scrollBackward(this);
+    Step.assert(this.stepId);
+    return response;
+  }
+  /**
+   * 检查节点是否可见
+   * @param compareNode 比较节点
+   * @param isFullyByCompareNode 是否完全可见
+   * @returns 是否可见
+   */
+  isVisible({
+    compareNode,
+    isFullyByCompareNode
+  } = {}) {
+    Step.assert(this.stepId);
+    const response = AssistsX2.isVisible(this, {
+      compareNode,
+      isFullyByCompareNode
+    });
+    Step.assert(this.stepId);
+    return response;
+  }
+  /**
+   * 对节点进行截图
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @returns 截图路径
+   */
+  async takeScreenshot(overlayHiddenScreenshotDelayMillis = 250) {
+    Step.assert(this.stepId);
+    const result = await AssistsX2.takeScreenshotNodes(
+      [this],
+      overlayHiddenScreenshotDelayMillis
+    );
+    Step.assert(this.stepId);
+    return result[0];
+  }
+  /**
+   * 保存节点截图到文件
+   * @param options 截图保存选项
+   * @param options.filePath 文件路径（可选，不提供则自动生成）
+   * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认为 "PNG"
+   * @param options.overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)，默认为 250
+   * @returns 保存的文件路径
+   */
+  async takeScreenshotToFile(options = {}) {
+    Step.assert(this.stepId);
+    const result = await AssistsXAsync.takeScreenshotToFile({
+      nodes: [this],
+      ...options
+    });
+    Step.assert(this.stepId);
+    return result[0];
+  }
+  /**
+   * 设置节点文本
+   * @param text 要设置的文本
+   * @returns 是否设置成功
+   */
+  setNodeText(text) {
+    Step.assert(this.stepId);
+    const result = AssistsX2.setNodeText(this, text);
+    Step.assert(this.stepId);
+    return result;
+  }
+  paste(text) {
+    Step.assert(this.stepId);
+    const result = AssistsX2.paste(this, text);
+    Step.assert(this.stepId);
+    return result;
+  }
+  focus() {
+    Step.assert(this.stepId);
+    const result = AssistsX2.focus(this);
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 点击节点
+   * @returns 是否点击成功
+   */
+  click() {
+    Step.assert(this.stepId);
+    const result = AssistsX2.click(this);
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 长按节点
+   * @returns 是否长按成功
+   */
+  longClick() {
+    Step.assert(this.stepId);
+    const result = AssistsX2.longClick(this);
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 查找第一个可点击的父节点
+   * @returns 可点击的父节点
+   */
+  findFirstParentClickable() {
+    Step.assert(this.stepId);
+    const result = AssistsX2.findFirstParentClickable(this);
+    Step.assert(this.stepId);
+    Step.assignIdsToNodes([result], this.stepId);
+    return result;
+  }
+  /**
+   * 获取节点在屏幕中的边界
+   * @returns 边界对象
+   */
+  getBoundsInScreen() {
+    Step.assert(this.stepId);
+    const result = AssistsX2.getBoundsInScreen(this);
+    Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 获取节点的所有子节点
+   * @returns 子节点数组
+   */
+  getNodes() {
+    Step.assert(this.stepId);
+    const result = AssistsX2.getNodes(this);
+    Step.assert(this.stepId);
+    Step.assignIdsToNodes(result, this.stepId);
+    return result;
+  }
+  /**
+   * 获取节点的直接子节点
+   * @returns 子节点数组
+   */
+  getChildren() {
+    Step.assert(this.stepId);
+    const result = AssistsX2.getChildren(this);
+    Step.assert(this.stepId);
+    Step.assignIdsToNodes(result, this.stepId);
+    return result;
+  }
+  /**
+   * 从JSON字符串创建节点实例
+   * @param json JSON字符串
+   * @returns 节点实例
+   */
+  static fromJSON(json) {
+    const data = JSON.parse(json);
+    return new _Node(data);
+  }
+  /**
+   * 从普通对象创建节点实例
+   * @param data 对象数据
+   * @returns 节点实例
+   */
+  static from(data) {
+    return new _Node(data);
+  }
+  /**
+   * JSON.parse的reviver函数，用于将解析的JSON对象转换为Node实例
+   * @param key 属性键
+   * @param value 属性值
+   * @returns 转换后的值
+   */
+  static reviver(key, value) {
+    return key === "" ? new _Node(value) : value;
+  }
+  /**
+   * 创建新的节点实例
+   * @param params 节点参数对象
+   * @returns 节点实例
+   */
+  static create(params) {
+    return new _Node(params);
+  }
+  /**
+   * 从JSON数组创建节点数组
+   * @param array JSON数组
+   * @returns 节点数组
+   */
+  static fromJSONArray(array) {
+    if (!Array.isArray(array)) {
+      throw new Error(
+        `Node.fromJSONArray: Expected array, but got ${typeof array}. Value: ${JSON.stringify(array)}`
+      );
+    }
+    return array.map((data) => new _Node(data));
+  }
+};
+
+// src/assistsx.ts
+var callbacks = /* @__PURE__ */ new Map();
+var accessibilityEventListeners = [];
+var screen;
+if (typeof window !== "undefined" && !window.assistsxCallback) {
+  window.assistsxCallback = (data) => {
+    let callbackId;
+    try {
+      const json = decodeBase64UTF8(data);
+      const response = JSON.parse(json);
+      callbackId = response.callbackId;
+      if (callbackId) {
+        const callback = callbacks.get(callbackId);
+        if (callback) {
+          callback(json);
+        }
+      }
+    } catch (e) {
+      console.log(e);
+    } finally {
+      if (callbackId) {
+        callbacks.delete(callbackId);
+      }
+    }
+  };
+}
+if (typeof window !== "undefined" && !window.onAccessibilityEvent) {
+  window.onAccessibilityEvent = (event) => {
+    accessibilityEventListeners.forEach((listener) => {
+      try {
+        const decodedEvent = decodeBase64UTF8(event);
+        const parsedEvent = JSON.parse(decodedEvent);
+        listener(parsedEvent);
+      } catch (error) {
+        console.error("Accessibility event listener error:", error);
+      }
+    });
+  };
+}
+var AssistsX2 = class {
+  /**
+   * 屏幕尺寸（与全局变量 screen 同源）
+   * @deprecated 已过时，请使用全局变量 {@link screen}
+   */
+  static get screenSize() {
+    if (screen == null) return null;
+    return {
+      width: screen.width,
+      height: screen.height,
+      screenWidth: screen.width,
+      screenHeight: screen.height
+    };
+  }
+  /**
+   * 执行同步调用
+   * @param method 方法名
+   * @param args 参数对象
+   * @returns 调用响应
+   */
+  static call(method, { args, node } = {}) {
+    const params = {
+      method,
+      arguments: args ? args : void 0,
+      node: node ? node : void 0
+    };
+    const result = window.assistsx.call(JSON.stringify(params));
+    if (typeof result === "string") {
+      const responseData = JSON.parse(result);
+      const response = new CallResponse(
+        responseData.code,
+        responseData.data,
+        responseData.callbackId
+      );
+      return response;
+    }
+    throw new Error("Call failed");
+  }
+  /**
+   * 执行异步调用
+   * @param method 方法名
+   * @param args 参数对象
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns Promise<调用响应>
+   */
+  static async asyncCall(method, {
+    args,
+    node,
+    nodes,
+    timeout = 30
+  } = {}) {
+    const uuid = generateUUID();
+    const params = {
+      method,
+      arguments: args ? args : void 0,
+      node: node ? node : void 0,
+      nodes: nodes ? nodes : void 0,
+      callbackId: uuid
+    };
+    const promise = new Promise((resolve) => {
+      callbacks.set(uuid, (data) => {
+        resolve(data);
+      });
+      setTimeout(() => {
+        callbacks.delete(uuid);
+        resolve(new CallResponse(0, null, uuid));
+      }, timeout * 1e3);
+    });
+    const result = window.assistsx.call(JSON.stringify(params));
+    const promiseResult = await promise;
+    if (typeof promiseResult === "string") {
+      const responseData = JSON.parse(promiseResult);
+      const response = new CallResponse(
+        responseData.code,
+        responseData.data,
+        responseData.callbackId
+      );
+      return response;
+    }
+    throw new Error("Call failed");
+  }
+  /**
+   * 设置悬浮窗标志
+   * @param flags 标志
+   * @returns 是否设置成功
+   */
+  static setOverlayFlags(flags) {
+    const response = this.call(CallMethod.setOverlayFlags, {
+      args: { flags }
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 设置悬浮窗标志
+   * @param flags 标志
+   * @returns 是否设置成功
+   */
+  static setOverlayFlagList(flags) {
+    const response = this.call(CallMethod.setOverlayFlags, {
+      args: { flags }
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 获取所有符合条件的节点
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param filterText 文本过滤
+   * @returns 节点数组
+   */
+  static getAllNodes({
+    filterClass,
+    filterViewId,
+    filterDes,
+    filterText,
+    scope
+  } = {}) {
+    const response = this.call(CallMethod.getAllNodes, {
+      args: {
+        filterClass,
+        filterViewId,
+        filterDes,
+        filterText,
+        ...scope !== void 0 ? { scope } : {}
+      }
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.getAllNodes: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 设置节点文本
+   * @param node 目标节点
+   * @param text 要设置的文本
+   * @returns 是否设置成功
+   */
+  static setNodeText(node, text) {
+    const response = this.call(CallMethod.setNodeText, {
+      args: { text },
+      node
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 获取剪贴板最新文本
+   * @returns 剪贴板最新文本
+   */
+  static getClipboardLatestText() {
+    const response = this.call(CallMethod.getClipboardLatestText);
+    return response.getDataOrDefault({});
+  }
+  /**
+   * 获取剪贴板文本内容（异步）
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 剪贴板文本内容，如果获取失败则返回空字符串
+   */
+  static async getClipboardText(timeout) {
+    const response = await this.asyncCall(CallMethod.getClipboardText, {
+      timeout
+    });
+    const data = response.getDataOrDefault({ text: "" });
+    return data.text || "";
+  }
+  /**
+   * 在浏览器中打开URL
+   * @param url 要打开的URL
+   * @returns 是否成功打开
+   */
+  static openUrlInBrowser(url) {
+    const response = this.call(CallMethod.openUrlInBrowser, {
+      args: { url }
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 保持屏幕常亮
+   * @param tip 提示文本
+   * @returns 是否保持屏幕常亮成功
+   */
+  static keepScreenOn(tip) {
+    const response = this.call(CallMethod.keepScreenOn, {
+      args: { tip }
+    });
+    return response.getDataOrDefault(false);
+  }
+  static clearKeepScreenOn() {
+    const response = this.call(CallMethod.clearKeepScreenOn, {});
+    return response.getDataOrDefault(false);
+  }
+  static isAppInstalled(packageName) {
+    const response = this.call(CallMethod.isAppInstalled, {
+      args: { packageName }
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 对指定节点进行截图
+   * @param nodes 要截图的节点数组
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 截图路径数组
+   */
+  static async takeScreenshotNodes(nodes, overlayHiddenScreenshotDelayMillis = 250, timeout) {
+    const response = await this.asyncCall(CallMethod.takeScreenshot, {
+      nodes,
+      args: { overlayHiddenScreenshotDelayMillis },
+      timeout
+    });
+    const data = response.getDataOrDefault({ images: [] });
+    return data.images;
+  }
+  static async scanQR(timeout) {
+    const response = await this.asyncCall(CallMethod.scanQR, { timeout });
+    const data = response.getDataOrDefault({ value: "" });
+    return data.value;
+  }
+  static async loadWebViewOverlay(url, options = {}) {
+    const {
+      initialWidth,
+      initialHeight,
+      initialX,
+      initialY,
+      minWidth,
+      minHeight,
+      maxWidth,
+      maxHeight,
+      initialCenter,
+      showTopOperationArea,
+      showBottomOperationArea,
+      backgroundColor,
+      timeout
+    } = options;
+    const response = await this.asyncCall(CallMethod.loadWebViewOverlay, {
+      args: {
+        url,
+        initialWidth,
+        initialHeight,
+        initialX,
+        initialY,
+        minWidth,
+        minHeight,
+        maxWidth,
+        maxHeight,
+        initialCenter,
+        showTopOperationArea,
+        showBottomOperationArea,
+        backgroundColor
+      },
+      timeout
+    });
+    const data = response.getDataOrDefault({});
+    return data;
+  }
+  /**
+   * 点击节点
+   * @param node 要点击的节点
+   * @returns 是否点击成功
+   */
+  static click(node) {
+    const response = this.call(CallMethod.click, { node });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 长按节点
+   * @param node 要长按的节点
+   * @returns 是否长按成功
+   */
+  static longClick(node) {
+    const response = this.call(CallMethod.longClick, { node });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 启动应用
+   * @param packageName 应用包名
+   * @returns 是否启动成功
+   */
+  static launchApp(packageName) {
+    const response = this.call(CallMethod.launchApp, { args: { packageName } });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 获取当前应用包名
+   * @returns 包名
+   */
+  static getPackageName(options = {}) {
+    const { scope } = options;
+    const response = this.call(
+      CallMethod.getPackageName,
+      scope !== void 0 ? { args: { scope } } : {}
+    );
+    return response.getDataOrDefault("");
+  }
+  /**
+   * 显示悬浮提示
+   * @param text 提示文本
+   * @param delay 显示时长(毫秒)
+   * @returns 是否显示成功
+   */
+  static overlayToast(text, delay = 2e3) {
+    const response = this.call(CallMethod.overlayToast, {
+      args: { text, delay }
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 通过ID查找节点
+   * @param id 节点ID
+   * @param filterClass 类名过滤
+   * @param filterText 文本过滤
+   * @param filterDes 描述过滤
+   * @param node 父节点范围
+   * @returns 节点数组
+   */
+  static findById(id, {
+    filterClass,
+    filterText,
+    filterDes,
+    node,
+    scope
+  } = {}) {
+    const response = this.call(CallMethod.findById, {
+      args: {
+        id,
+        filterClass,
+        filterText,
+        filterDes,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      node
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.findById: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 通过文本查找节点
+   * @param text 要查找的文本
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param node 父节点范围
+   * @returns 节点数组
+   */
+  static findByText(text, {
+    filterClass,
+    filterViewId,
+    filterDes,
+    node,
+    scope
+  } = {}) {
+    const response = this.call(CallMethod.findByText, {
+      args: {
+        text,
+        filterClass,
+        filterViewId,
+        filterDes,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      node
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.findByText: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 通过标签查找节点
+   * @param className 类名
+   * @param filterText 文本过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param node 父节点范围
+   * @returns 节点数组
+   */
+  static findByTags(className, {
+    filterText,
+    filterViewId,
+    filterDes,
+    node,
+    scope
+  } = {}) {
+    const response = this.call(CallMethod.findByTags, {
+      args: {
+        className,
+        filterText,
+        filterViewId,
+        filterDes,
+        ...scope !== void 0 ? { scope } : {}
+      },
+      node
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.findByTags: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 查找所有匹配文本的节点
+   * @param text 要查找的文本
+   * @param options.scope 节点查找范围（可选）
+   */
+  static findByTextAllMatch(text, { scope } = {}) {
+    const response = this.call(CallMethod.findByTextAllMatch, {
+      args: {
+        text,
+        ...scope !== void 0 ? { scope } : {}
+      }
+    });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.findByTextAllMatch: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 检查是否包含指定文本
+   * @param text 要检查的文本
+   * @returns 是否包含
+   */
+  static containsText(text) {
+    const response = this.call(CallMethod.containsText, { args: { text } });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 获取所有文本
+   * @returns 文本数组
+   */
+  static getAllText() {
+    const response = this.call(CallMethod.getAllText);
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.getAllText: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return data;
+  }
+  /**
+   * 查找第一个匹配标签的父节点
+   * @param className 类名
+   * @returns 父节点
+   */
+  static findFirstParentByTags(node, className) {
+    const response = this.call(CallMethod.findFirstParentByTags, {
+      args: { className },
+      node
+    });
+    return Node.create(response.getDataOrDefault({}));
+  }
+  /**
+   * 获取节点的所有子节点
+   * @param node 父节点
+   * @returns 子节点数组
+   */
+  static getNodes(node) {
+    const response = this.call(CallMethod.getNodes, { node });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.getNodes: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 获取节点的直接子节点
+   * @param node 父节点
+   * @returns 子节点数组
+   */
+  static getChildren(node) {
+    const response = this.call(CallMethod.getChildren, { node });
+    const data = response.getDataOrDefault([]);
+    if (!Array.isArray(data)) {
+      throw new Error(
+        `AssistsX.getChildren: Expected array, but got ${typeof data}. Value: ${JSON.stringify(data)}`
+      );
+    }
+    return Node.fromJSONArray(data);
+  }
+  /**
+   * 查找第一个可点击的父节点
+   * @param node 起始节点
+   * @returns 可点击的父节点
+   */
+  static findFirstParentClickable(node) {
+    const response = this.call(CallMethod.findFirstParentClickable, { node });
+    return Node.create(response.getDataOrDefault({}));
+  }
+  /**
+   * 获取节点在屏幕中的边界
+   * @param node 目标节点
+   * @returns 边界对象
+   */
+  static getBoundsInScreen(node) {
+    const response = this.call(CallMethod.getBoundsInScreen, { node });
+    return Bounds.fromData(response.getDataOrDefault({}));
+  }
+  /**
+   * 检查节点是否可见
+   * @param node 目标节点
+   * @param compareNode 比较节点
+   * @param isFullyByCompareNode 是否完全可见
+   * @returns 是否可见
+   */
+  static isVisible(node, {
+    compareNode,
+    isFullyByCompareNode
+  } = {}) {
+    const response = this.call(CallMethod.isVisible, {
+      node,
+      args: { compareNode, isFullyByCompareNode }
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 执行点击手势
+   * @param x 横坐标
+   * @param y 纵坐标
+   * @param duration 持续时间
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async clickByGesture(x, y, duration, timeout) {
+    const response = await this.asyncCall(CallMethod.clickByGesture, {
+      args: { x, y, duration },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 返回操作
+   * @returns 是否成功
+   */
+  static back() {
+    const response = this.call(CallMethod.back);
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 回到主页
+   * @returns 是否成功
+   */
+  static home() {
+    const response = this.call(CallMethod.home);
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 打开通知栏
+   * @returns 是否成功
+   */
+  static notifications() {
+    const response = this.call(CallMethod.notifications);
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 显示最近应用
+   * @returns 是否成功
+   */
+  static recentApps() {
+    const response = this.call(CallMethod.recentApps);
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 在节点中粘贴文本
+   * @param node 目标节点
+   * @param text 要粘贴的文本
+   * @returns 是否成功
+   */
+  static paste(node, text) {
+    const response = this.call(CallMethod.paste, { args: { text }, node });
+    return response.getDataOrDefault(false);
+  }
+  static focus(node) {
+    const response = this.call(CallMethod.focus, { node });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 选择文本
+   * @param node 目标节点
+   * @param selectionStart 选择起始位置
+   * @param selectionEnd 选择结束位置
+   * @returns 是否成功
+   */
+  static selectionText(node, selectionStart, selectionEnd) {
+    const response = this.call(CallMethod.selectionText, {
+      args: { selectionStart, selectionEnd },
+      node
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 向前滚动
+   * @param node 可滚动节点
+   * @returns 是否成功
+   */
+  static scrollForward(node) {
+    const response = this.call(CallMethod.scrollForward, { node });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 向后滚动
+   * @param node 可滚动节点
+   * @returns 是否成功
+   */
+  static scrollBackward(node) {
+    const response = this.call(CallMethod.scrollBackward, { node });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 对节点执行点击手势
+   * @param node 目标节点
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async clickNodeByGesture(node, {
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration,
+    timeout
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.clickNodeByGesture, {
+      node,
+      args: { offsetX, offsetY, switchWindowIntervalDelay, clickDuration },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 对节点执行双击手势
+   * @param node 目标节点
+   * @param offsetX X轴偏移
+   * @param offsetY Y轴偏移
+   * @param switchWindowIntervalDelay 窗口切换延迟
+   * @param clickDuration 点击持续时间
+   * @param clickInterval 点击间隔
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 是否成功
+   */
+  static async doubleClickNodeByGesture(node, {
+    offsetX,
+    offsetY,
+    switchWindowIntervalDelay,
+    clickDuration,
+    clickInterval,
+    timeout
+  } = {}) {
+    const response = await this.asyncCall(CallMethod.doubleClickNodeByGesture, {
+      node,
+      args: {
+        offsetX,
+        offsetY,
+        switchWindowIntervalDelay,
+        clickDuration,
+        clickInterval
+      },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  /**
+   * 执行线型手势
+   * @param startPoint
+   * @param endPoint
+   * @param param2
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns
+   */
+  static async performLinearGesture(startPoint, endPoint, { duration, timeout } = {}) {
+    const response = await this.asyncCall(CallMethod.performLinearGesture, {
+      args: { startPoint, endPoint, duration },
+      timeout
+    });
+    return response.getDataOrDefault(false);
+  }
+  static async longPressNodeByGestureAutoPaste(node, text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration,
+    timeout
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    const response = await this.asyncCall(
+      CallMethod.longPressGestureAutoPaste,
+      {
+        node,
+        args: {
+          text,
+          matchedPackageName,
+          matchedText,
+          timeoutMillis,
+          longPressDuration
+        },
+        timeout
+      }
+    );
+    return response.getDataOrDefault(false);
+  }
+  static async longPressGestureAutoPaste(point, text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration,
+    timeout
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    const response = await this.asyncCall(
+      CallMethod.longPressGestureAutoPaste,
+      {
+        args: {
+          point,
+          text,
+          matchedPackageName,
+          matchedText,
+          timeoutMillis,
+          longPressDuration
+        },
+        timeout
+      }
+    );
+    return response.getDataOrDefault(false);
+  }
+  static async getAppInfo(packageName, timeout) {
+    const response = await this.asyncCall(CallMethod.getAppInfo, {
+      args: { packageName },
+      timeout
+    });
+    return AppInfo.fromJSON(response.getDataOrDefault({}));
+  }
+  static getUniqueDeviceId() {
+    const response = this.call(CallMethod.getUniqueDeviceId);
+    return response.getDataOrDefault("");
+  }
+  static getAndroidID() {
+    const response = this.call(CallMethod.getAndroidID);
+    return response.getDataOrDefault("");
+  }
+  static async getMacAddress(timeout) {
+    const response = await this.asyncCall(CallMethod.getMacAddress, {
+      timeout
+    });
+    return response.getDataOrDefault({});
+  }
+  static async getDeviceInfo(timeout) {
+    const response = await this.asyncCall(CallMethod.getDeviceInfo, {
+      timeout
+    });
+    return DeviceInfo.fromJSON(response.getDataOrDefault({}));
+  }
+  static async getNetworkType(timeout) {
+    const response = await this.asyncCall(CallMethod.getNetworkType, {
+      timeout
+    });
+    return response.getDataOrDefault({});
+  }
+  /**
+   * 播放系统电话铃声
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 播放结果消息
+   */
+  static async audioPlayRingtone(timeout) {
+    const response = await this.asyncCall(CallMethod.audioPlayRingtone, {
+      timeout
+    });
+    return response.getDataOrDefault("");
+  }
+  /**
+   * 停止播放系统电话铃声
+   * @param timeout 超时时间(秒)，默认30秒
+   * @returns 停止结果消息
+   */
+  static async audioStopRingtone(timeout) {
+    const response = await this.asyncCall(CallMethod.audioStopRingtone, {
+      timeout
+    });
+    return response.getDataOrDefault("");
+  }
+  static async setAccessibilityEventFilters(value) {
+    const response = this.call(CallMethod.setAccessibilityEventFilters, {
+      args: { value }
+    });
+    return response.getDataOrDefault({});
+  }
+  static async addAccessibilityEventFilter(value) {
+    const response = this.call(CallMethod.addAccessibilityEventFilter, {
+      args: { value }
+    });
+    return response.getDataOrDefault({});
+  }
+  /**
+   * 获取屏幕尺寸
+   * @returns 屏幕尺寸对象（width, height）
+   */
+  static getScreenSize() {
+    const response = this.call(CallMethod.getScreenSize);
+    const data = response.getDataOrDefault({});
+    return normalizeScreen(data);
+  }
+  /**
+   * 获取应用窗口尺寸
+   * @returns 应用窗口尺寸对象
+   */
+  static getAppScreenSize() {
+    const response = this.call(CallMethod.getAppScreenSize);
+    return response.getDataOrDefault({});
+  }
+  /**
+   * 添加无障碍事件监听器
+   * @param listener 监听器函数
+   */
+  static addAccessibilityEventListener(listener) {
+    accessibilityEventListeners.push(listener);
+  }
+  /**
+   * 判断是否包含无障碍事件监听器
+   * @param listener 监听器函数
+   * @returns 是否包含
+   */
+  static containsAccessibilityEventListener(listener) {
+    return accessibilityEventListeners.indexOf(listener) > -1;
+  }
+  /**
+   * 移除无障碍事件监听器
+   * @param listener 要移除的监听器函数
+   * @returns 是否移除成功
+   */
+  static removeAccessibilityEventListener(listener) {
+    const index = accessibilityEventListeners.indexOf(listener);
+    if (index > -1) {
+      accessibilityEventListeners.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 移除所有无障碍事件监听器
+   */
+  static removeAllAccessibilityEventListeners() {
+    accessibilityEventListeners.length = 0;
+  }
+  /**
+   * 获取当前注册的无障碍事件监听器数量
+   * @returns 监听器数量
+   */
+  static getAccessibilityEventListenerCount() {
+    return accessibilityEventListeners.length;
+  }
+};
+function normalizeScreen(data) {
+  if (data == null) return null;
+  const w = typeof data.width === "number" ? data.width : data.screenWidth;
+  const h = typeof data.height === "number" ? data.height : data.screenHeight;
+  if (typeof w !== "number" || typeof h !== "number") return null;
+  return { width: Math.floor(w), height: Math.floor(h) };
+}
+var _a;
+if (typeof window !== "undefined") {
+  try {
+    if (window.assistsx && typeof window.assistsx.call === "function") {
+      screen = (_a = AssistsX2.getScreenSize()) != null ? _a : { width: 0, height: 0 };
+    }
+  } catch (e) {
+    console.log("Failed to initialize screen size:", e);
+  }
+}
+
+// src/step-state-store.ts
+var import_pinia = require("pinia");
+var useStepStore = (0, import_pinia.defineStore)("step", {
+  state: () => ({
+    status: "idle",
+    stepId: void 0,
+    tag: void 0,
+    data: void 0,
+    error: void 0
+  }),
+  actions: {
+    // 开始执行步骤
+    startStep(stepId, tag, data) {
+      this.status = "running";
+      this.stepId = stepId;
+      this.tag = tag;
+      this.data = data;
+      this.error = void 0;
+    },
+    // 完成步骤
+    completeStep() {
+      this.status = "completed";
+    },
+    // 步骤出错
+    setError(error) {
+      this.status = "error";
+      this.error = error;
+    },
+    // 重置状态
+    reset() {
+      this.status = "idle";
+      this.stepId = void 0;
+      this.tag = void 0;
+      this.data = void 0;
+      this.error = void 0;
+    }
+  }
+});
+
+// src/pinia-ensure.ts
+var import_pinia2 = require("pinia");
+var fallbackPinia = null;
+function ensureAssistsXPinia() {
+  if ((0, import_pinia2.getActivePinia)() !== void 0) return;
+  if (fallbackPinia === null) {
+    fallbackPinia = (0, import_pinia2.createPinia)();
+  }
+  (0, import_pinia2.setActivePinia)(fallbackPinia);
+}
+
+// src/step-error.ts
+var StepError = class extends Error {
+  constructor(message, data, impl, tag, originalError, currentStep) {
+    super(message);
+    this.name = "StepError";
+    this.data = data;
+    this.impl = impl;
+    this.tag = tag;
+    this.originalError = originalError;
+    this.currentStep = currentStep;
+  }
+};
+var StepStopError = class extends StepError {
+  constructor(message, data) {
+    super(message || "\u4E3B\u52A8\u4E2D\u65AD\u6B65\u9AA4", data);
+    this.name = "StepStopError";
+  }
+};
+
+// src/step-async.ts
+var StepAsync = class {
+  /**
+   * 构造函数
+   * @param step Step实例
+   */
+  constructor(step) {
+    this.step = step;
+  }
+  /**
+   * 对单个节点进行截图
+   * @param node 目标节点
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @returns 截图路径
+   */
+  async takeScreenshotByNode(node, overlayHiddenScreenshotDelayMillis = 250) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.takeScreenshotNodes(
+      [node],
+      overlayHiddenScreenshotDelayMillis
+    );
+    Step.assert(this.step.stepId);
+    return result[0];
+  }
+  /**
+   * 对多个节点进行截图
+   * @param nodes 目标节点数组
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @returns 截图路径数组
+   */
+  async takeScreenshotNodes(nodes, overlayHiddenScreenshotDelayMillis = 250) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.takeScreenshotNodes(
+      nodes,
+      overlayHiddenScreenshotDelayMillis
+    );
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 获取所有符合条件的节点
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param filterText 文本过滤
+   * @returns 节点数组
+   */
+  async getAllNodes({
+    filterClass,
+    filterViewId,
+    filterDes,
+    filterText,
+    scope
+  } = {}) {
+    Step.assert(this.step.stepId);
+    const nodes = await AssistsXAsync.getAllNodes({
+      filterClass,
+      filterViewId,
+      filterDes,
+      filterText,
+      scope
+    });
+    Step.assert(this.step.stepId);
+    Step.assignIdsToNodes(nodes, this.step.stepId);
+    return nodes;
+  }
+  /**
+   * 启动应用
+   * @param packageName 应用包名
+   * @returns 是否启动成功
+   */
+  async launchApp(packageName) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.launchApp(packageName);
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  async getPackageName(timeoutOrOptions) {
+    Step.assert(this.step.stepId);
+    const result = typeof timeoutOrOptions === "number" ? await AssistsXAsync.getPackageName(timeoutOrOptions) : await AssistsXAsync.getPackageName(timeoutOrOptions != null ? timeoutOrOptions : {});
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 通过ID查找节点
+   * @param id 节点ID
+   * @param filterClass 类名过滤
+   * @param filterText 文本过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  async findById(id, {
+    filterClass,
+    filterText,
+    filterDes,
+    scope
+  } = {}) {
+    Step.assert(this.step.stepId);
+    const nodes = await AssistsXAsync.findById(id, {
+      filterClass,
+      filterText,
+      filterDes,
+      scope
+    });
+    Step.assert(this.step.stepId);
+    Step.assignIdsToNodes(nodes, this.step.stepId);
+    return nodes;
+  }
+  /**
+   * 通过文本查找节点
+   * @param text 要查找的文本
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  async findByText(text, {
+    filterClass,
+    filterViewId,
+    filterDes,
+    scope
+  } = {}) {
+    Step.assert(this.step.stepId);
+    const nodes = await AssistsXAsync.findByText(text, {
+      filterClass,
+      filterViewId,
+      filterDes,
+      scope
+    });
+    Step.assert(this.step.stepId);
+    Step.assignIdsToNodes(nodes, this.step.stepId);
+    return nodes;
+  }
+  /**
+   * 通过标签查找节点
+   * @param className 类名
+   * @param filterText 文本过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  async findByTags(className, {
+    filterText,
+    filterViewId,
+    filterDes,
+    scope
+  } = {}) {
+    Step.assert(this.step.stepId);
+    const nodes = await AssistsXAsync.findByTags(className, {
+      filterText,
+      filterViewId,
+      filterDes,
+      scope
+    });
+    Step.assert(this.step.stepId);
+    Step.assignIdsToNodes(nodes, this.step.stepId);
+    return nodes;
+  }
+  async findByTextAllMatch(text, timeoutOrOptions) {
+    Step.assert(this.step.stepId);
+    const nodes = typeof timeoutOrOptions === "number" ? await AssistsXAsync.findByTextAllMatch(text, timeoutOrOptions) : timeoutOrOptions !== void 0 ? await AssistsXAsync.findByTextAllMatch(text, timeoutOrOptions) : await AssistsXAsync.findByTextAllMatch(text);
+    Step.assert(this.step.stepId);
+    Step.assignIdsToNodes(nodes, this.step.stepId);
+    return nodes;
+  }
+  /**
+   * 检查是否包含指定文本
+   * @param text 要检查的文本
+   * @returns 是否包含
+   */
+  async containsText(text) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.containsText(text);
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 获取所有文本
+   * @returns 文本数组
+   */
+  async getAllText() {
+    Step.assert(this.step.stepId);
+    const texts = await AssistsXAsync.getAllText();
+    Step.assert(this.step.stepId);
+    return texts;
+  }
+  /**
+   * 执行点击手势
+   * @param x 横坐标
+   * @param y 纵坐标
+   * @param duration 持续时间(毫秒)
+   * @returns 是否成功
+   */
+  async clickByGesture(x, y, duration) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.clickByGesture(x, y, duration);
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  async longPressGestureAutoPaste(point, text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.longPressGestureAutoPaste(point, text, {
+      matchedPackageName,
+      matchedText,
+      timeoutMillis,
+      longPressDuration
+    });
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  async getAppInfo(packageName) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.getAppInfo(packageName);
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  async performLinearGesture(startPoint, endPoint, { duration } = {}) {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.performLinearGesture(
+      startPoint,
+      endPoint,
+      {
+        duration
+      }
+    );
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 返回操作
+   * @returns 是否成功
+   */
+  async back() {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.back();
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 回到主页
+   * @returns 是否成功
+   */
+  async home() {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.home();
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 打开通知栏
+   * @returns 是否成功
+   */
+  async notifications() {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.notifications();
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 显示最近应用
+   * @returns 是否成功
+   */
+  async recentApps() {
+    Step.assert(this.step.stepId);
+    const result = await AssistsXAsync.recentApps();
+    Step.assert(this.step.stepId);
+    return result;
+  }
+  /**
+   * 获取屏幕尺寸
+   * @returns 屏幕尺寸对象
+   */
+  async getScreenSize() {
+    Step.assert(this.step.stepId);
+    const data = await AssistsXAsync.getScreenSize();
+    Step.assert(this.step.stepId);
+    return data;
+  }
+  /**
+   * 获取应用窗口尺寸
+   * @returns 应用窗口尺寸对象
+   */
+  async getAppScreenSize() {
+    Step.assert(this.step.stepId);
+    const data = await AssistsXAsync.getAppScreenSize();
+    Step.assert(this.step.stepId);
+    return data;
+  }
+};
+
+// src/step.ts
+var _Step = class _Step {
+  /**
+   * 构造函数
+   * @param stepId 步骤ID
+   * @param impl 步骤实现函数
+   * @param tag 步骤标签
+   * @param data 步骤数据
+   * @param delayMs 步骤延迟时间(毫秒)
+   */
+  constructor({
+    stepId,
+    impl,
+    tag,
+    data,
+    delayMs = _Step.delayMsDefault,
+    repeatCountMax = _Step.repeatCountMaxDefault,
+    exceptionRetryCountMax = _Step.exceptionRetryCountMaxDefault,
+    isEnd = false
+  }) {
+    /**
+     * 步骤ID
+     */
+    this.stepId = "";
+    /**
+     * 步骤重复执行次数
+     */
+    this.repeatCount = 0;
+    /**
+     * 步骤重复执行最大次数,默认15次
+     */
+    this.repeatCountMax = _Step.repeatCountMaxDefault;
+    /**
+     * 异常重试次数
+     */
+    this.exceptionRetryCount = 0;
+    /**
+     * 异常重试最大次数,默认3次
+     */
+    this.exceptionRetryCountMax = _Step.exceptionRetryCountMaxDefault;
+    this.isEnd = false;
+    /**
+     * 步骤延迟时间(毫秒)
+     */
+    this.delayMs = _Step.delayMsDefault;
+    this.tag = tag;
+    this.stepId = stepId;
+    this.data = _Step.resolveStepData(data);
+    this.impl = impl;
+    this.delayMs = delayMs;
+    this.repeatCountMax = repeatCountMax;
+    this.exceptionRetryCountMax = exceptionRetryCountMax;
+    this.isEnd = isEnd;
+  }
+  /**
+   * 判断步骤数据是否有效（非空且为普通对象）
+   */
+  static isValidStepData(data) {
+    return data !== null && data !== void 0 && typeof data === "object" && !Array.isArray(data);
+  }
+  /**
+   * 解析步骤数据：优先使用传入值，否则使用当前值，均无效时返回空对象
+   */
+  static resolveStepData(provided, fallback) {
+    if (provided !== void 0 && _Step.isValidStepData(provided)) {
+      return provided;
+    }
+    if (fallback !== void 0 && _Step.isValidStepData(fallback)) {
+      return fallback;
+    }
+    return {};
+  }
+  /**
+   * 运行步骤实现
+   * @param impl 步骤实现函数
+   * @param tag 步骤标签
+   * @param data 步骤数据
+   * @param delayMs 步骤延迟时间(毫秒)
+   */
+  static async run(impl, {
+    stepId,
+    tag,
+    data,
+    delayMs = _Step.delayMsDefault,
+    exceptionRetryCountMax = _Step.exceptionRetryCountMaxDefault
+  } = {}) {
+    var _a2, _b, _c, _d, _e, _f;
+    this.exception = void 0;
+    ensureAssistsXPinia();
+    const stepStore = useStepStore();
+    const resolvedData = _Step.resolveStepData(data);
+    let implnName = impl.name;
+    let currentStep;
+    let nextStep;
+    try {
+      if (stepId) {
+        this._stepId = stepId;
+        if (_Step.showLog) {
+          console.log(`\u4F7F\u7528\u4F20\u5165\u6B65\u9AA4ID: ${this._stepId}`);
+        }
+      } else {
+        this._stepId = generateUUID();
+        if (_Step.showLog) {
+          console.log(`\u751F\u6210\u6B65\u9AA4ID: ${this._stepId}`);
+        }
+      }
+      stepStore.startStep(this._stepId, tag, resolvedData);
+      currentStep = new _Step({
+        stepId: this._stepId,
+        impl,
+        tag,
+        data: resolvedData,
+        delayMs,
+        exceptionRetryCountMax
+      });
+      while (true) {
+        let interceptedStep = void 0;
+        let stepForRetry = currentStep;
+        try {
+          if (currentStep.delayMs) {
+            if (_Step.showLog) {
+              console.log(`\u5EF6\u8FDF${currentStep.delayMs}\u6BEB\u79D2`);
+            }
+            await currentStep.delay(currentStep.delayMs);
+            _Step.assert(currentStep.stepId);
+          }
+          implnName = (_b = (_a2 = currentStep.impl) == null ? void 0 : _a2.name) != null ? _b : "undefined";
+          if (_Step.showLog) {
+            console.log(
+              `\u6267\u884C\u6B65\u9AA4${implnName}\uFF0C\u91CD\u590D\u6B21\u6570${currentStep.repeatCount}`
+            );
+          }
+          for (const interceptor of this._interceptors) {
+            try {
+              const result = await interceptor(currentStep);
+              if (result) {
+                interceptedStep = result;
+                if (_Step.showLog) {
+                  console.log(`\u6B65\u9AA4${implnName}\u88AB\u62E6\u622A\u5668\u62E6\u622A\uFF0C\u6267\u884C\u62E6\u622A\u540E\u7684\u6B65\u9AA4`);
+                }
+                break;
+              }
+            } catch (e) {
+              if (_Step.showLog) {
+                console.error(`\u62E6\u622A\u5668\u6267\u884C\u51FA\u9519`, e);
+              }
+            }
+          }
+          stepForRetry = currentStep;
+          if (interceptedStep !== void 0) {
+            const stepToExecute = interceptedStep;
+            stepForRetry = stepToExecute;
+            if (stepToExecute.delayMs) {
+              if (_Step.showLog) {
+                console.log(`\u62E6\u622A\u6B65\u9AA4\u5EF6\u8FDF${stepToExecute.delayMs}\u6BEB\u79D2`);
+              }
+              await stepToExecute.delay(stepToExecute.delayMs);
+              _Step.assert(stepToExecute.stepId);
+            }
+            const interceptedImplName = (_c = stepToExecute.impl) == null ? void 0 : _c.name;
+            if (_Step.showLog) {
+              console.log(
+                `\u6267\u884C\u62E6\u622A\u6B65\u9AA4${interceptedImplName}\uFF0C\u91CD\u590D\u6B21\u6570${stepToExecute.repeatCount}`
+              );
+            }
+            nextStep = await ((_d = stepToExecute.impl) == null ? void 0 : _d.call(stepToExecute, stepToExecute));
+          } else {
+            nextStep = await ((_e = currentStep.impl) == null ? void 0 : _e.call(currentStep, currentStep));
+          }
+          if (currentStep.repeatCountMax > _Step.repeatCountInfinite && currentStep.repeatCount >= currentStep.repeatCountMax) {
+            if (_Step.showLog) {
+              console.log(
+                `\u91CD\u590D\u6B21\u6570${currentStep.repeatCount}\u8D85\u8FC7\u6700\u5927\u6B21\u6570${currentStep.repeatCountMax}\uFF0C\u505C\u6B62\u6267\u884C`
+              );
+            }
+            throw new StepError("\u6B65\u9AA4\u91CD\u590D\u6B21\u6570\u8FBE\u5230\u6700\u5927\u6B21\u6570", { stepId: currentStep.stepId, repeatCount: currentStep.repeatCount, repeatCountMax: currentStep.repeatCountMax });
+          }
+          _Step.assert(currentStep.stepId);
+          stepForRetry.exceptionRetryCount = 0;
+          if (nextStep) {
+            currentStep = nextStep;
+            if (currentStep.isEnd) {
+              if (_Step.showLog) {
+                console.log(`\u6B65\u9AA4${implnName}\u7ED3\u675F`);
+              }
+              break;
+            }
+          } else {
+            break;
+          }
+        } catch (e) {
+          if ((e == null ? void 0 : e.message) === "\u6B65\u9AA4\u91CD\u590D\u6B21\u6570\u8FBE\u5230\u6700\u5927\u6B21\u6570") {
+            throw e;
+          }
+          stepForRetry.exceptionRetryCount++;
+          if (stepForRetry.exceptionRetryCount < stepForRetry.exceptionRetryCountMax) {
+            if (_Step.showLog) {
+              console.warn(
+                `\u6B65\u9AA4${implnName}\u6267\u884C\u5F02\u5E38\uFF0C\u91CD\u8BD5\u7B2C${stepForRetry.exceptionRetryCount}\u6B21\uFF0C\u6700\u5927\u91CD\u8BD5\u6B21\u6570${stepForRetry.exceptionRetryCountMax}`,
+                e
+              );
+            }
+            continue;
+          } else {
+            if (_Step.showLog) {
+              console.error(
+                `\u6B65\u9AA4${implnName}\u6267\u884C\u5F02\u5E38\uFF0C\u5DF2\u8FBE\u5230\u6700\u5927\u91CD\u8BD5\u6B21\u6570${stepForRetry.exceptionRetryCountMax}\uFF0C\u505C\u6B62\u91CD\u8BD5`,
+                e
+              );
+            }
+            throw e;
+          }
+        }
+      }
+      stepStore.completeStep();
+    } catch (e) {
+      console.error(`\u6B65\u9AA4${implnName}\u6267\u884C\u51FA\u9519`, e);
+      const errorMsg = JSON.stringify({
+        impl: implnName,
+        tag,
+        data: resolvedData,
+        error: (_f = e == null ? void 0 : e.message) != null ? _f : String(e)
+      });
+      stepStore.setError(errorMsg);
+      throw e;
+    }
+    return currentStep;
+  }
+  /**
+   * 获取当前步骤ID
+   */
+  static get stepId() {
+    return this._stepId;
+  }
+  /**
+   * 验证步骤ID是否匹配，如果不匹配则表示停止
+   * @param stepId 要验证的步骤ID
+   */
+  static assert(stepId) {
+    if (_Step.exception) {
+      throw _Step.exception;
+    }
+    if (stepId && _Step.stepId != stepId) {
+      throw new StepError("StepId mismatch", { stepId, currentStepId: _Step.stepId });
+    }
+  }
+  /**
+   * 为节点数组分配步骤ID
+   * @param nodes 节点数组
+   * @param stepId 步骤ID
+   */
+  static assignIdsToNodes(nodes, stepId) {
+    if (stepId) {
+      nodes.forEach((node) => {
+        node.stepId = stepId;
+      });
+    }
+  }
+  /**
+   * 停止当前步骤执行
+   * @param exception 可选的异常对象，如果传入则使用该异常，否则使用默认的StepStopError
+   */
+  static stop(exception) {
+    this._stepId = "STEP_STOP";
+    if (exception) {
+      this.exception = exception;
+    } else {
+      this.exception = new StepStopError("\u4E3B\u52A8\u4E2D\u65AD\u6B65\u9AA4", { stepId: this._stepId });
+    }
+  }
+  /**
+   * 添加步骤拦截器
+   * @param interceptor 拦截器函数
+   */
+  static addInterceptor(interceptor) {
+    this._interceptors.push(interceptor);
+  }
+  /**
+   * 移除步骤拦截器
+   * @param interceptor 要移除的拦截器函数
+   * @returns 是否成功删除
+   */
+  static removeInterceptor(interceptor) {
+    const index = this._interceptors.indexOf(interceptor);
+    if (index > -1) {
+      this._interceptors.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 按索引移除步骤拦截器
+   * @param index 要移除的拦截器索引
+   * @returns 是否成功删除
+   */
+  static removeInterceptorByIndex(index) {
+    if (index >= 0 && index < this._interceptors.length) {
+      this._interceptors.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 移除所有匹配的步骤拦截器
+   * @param interceptor 要移除的拦截器函数
+   * @returns 删除的拦截器数量
+   */
+  static removeAllInterceptors(interceptor) {
+    let removedCount = 0;
+    for (let i = this._interceptors.length - 1; i >= 0; i--) {
+      if (this._interceptors[i] === interceptor) {
+        this._interceptors.splice(i, 1);
+        removedCount++;
+      }
+    }
+    return removedCount;
+  }
+  /**
+   * 按条件移除步骤拦截器
+   * @param predicate 判断是否删除的条件函数
+   * @returns 删除的拦截器数量
+   */
+  static removeInterceptorByPredicate(predicate) {
+    let removedCount = 0;
+    for (let i = this._interceptors.length - 1; i >= 0; i--) {
+      if (predicate(this._interceptors[i], i)) {
+        this._interceptors.splice(i, 1);
+        removedCount++;
+      }
+    }
+    return removedCount;
+  }
+  /**
+   * 清空所有拦截器
+   */
+  static clearInterceptors() {
+    this._interceptors = [];
+  }
+  /**
+   * 获取所有拦截器
+   * @returns 拦截器数组
+   */
+  static getInterceptors() {
+    return [...this._interceptors];
+  }
+  get async() {
+    return new StepAsync(this);
+  }
+  /**
+   * 创建下一个步骤
+   * @param impl 下一步骤实现函数
+   * @param tag 步骤标签
+   * @param data 步骤数据
+   * @param delayMs 步骤延迟时间(毫秒)
+   * @returns 新的步骤实例
+   */
+  next(impl, {
+    tag,
+    data,
+    delayMs = _Step.delayMsDefault,
+    repeatCountMax = _Step.repeatCountMaxDefault,
+    exceptionRetryCountMax = _Step.exceptionRetryCountMaxDefault
+  } = {}) {
+    _Step.assert(this.stepId);
+    return new _Step({
+      stepId: this.stepId,
+      impl,
+      tag,
+      data: _Step.resolveStepData(data, this.data),
+      delayMs,
+      repeatCountMax,
+      exceptionRetryCountMax
+    });
+  }
+  end({
+    tag,
+    data,
+    delayMs = _Step.delayMsDefault,
+    repeatCountMax = _Step.repeatCountMaxDefault,
+    exceptionRetryCountMax = _Step.exceptionRetryCountMaxDefault
+  } = {}) {
+    _Step.assert(this.stepId);
+    return new _Step({
+      stepId: this.stepId,
+      impl: void 0,
+      tag,
+      data: _Step.resolveStepData(data, this.data),
+      delayMs,
+      repeatCountMax,
+      exceptionRetryCountMax,
+      isEnd: true
+    });
+  }
+  /**
+   * 重复当前步骤
+   * @param stepId 步骤ID
+   * @param tag 步骤标签
+   * @param data 步骤数据
+   * @param delayMs 步骤延迟时间(毫秒)
+   * @returns 当前步骤实例
+   */
+  repeat({
+    stepId = this.stepId,
+    tag = this.tag,
+    data,
+    delayMs = this.delayMs,
+    repeatCountMax = this.repeatCountMax,
+    exceptionRetryCountMax = this.exceptionRetryCountMax
+  } = {}) {
+    _Step.assert(this.stepId);
+    this.repeatCount++;
+    this.stepId = stepId;
+    this.tag = tag;
+    this.data = _Step.resolveStepData(data, this.data);
+    this.delayMs = delayMs;
+    this.repeatCountMax = repeatCountMax;
+    this.exceptionRetryCountMax = exceptionRetryCountMax;
+    this.exceptionRetryCount = 0;
+    return this;
+  }
+  /**
+   * 延迟执行
+   * @param ms 延迟时间(毫秒)
+   * @returns Promise
+   */
+  async delay(ms) {
+    while (true) {
+      ms -= 100;
+      if (ms <= 0) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      _Step.assert(this.stepId);
+    }
+  }
+  /**
+   * 等待异步方法执行完成
+   * @param method 异步方法
+   * @returns Promise<T>
+   */
+  async await(method) {
+    _Step.assert(this.stepId);
+    const result = await method();
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 对单个节点进行截图
+   * @param node 目标节点
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @returns 截图路径
+   */
+  async takeScreenshotByNode(node, overlayHiddenScreenshotDelayMillis = 250) {
+    _Step.assert(this.stepId);
+    const result = await AssistsX2.takeScreenshotNodes(
+      [node],
+      overlayHiddenScreenshotDelayMillis
+    );
+    _Step.assert(this.stepId);
+    return result[0];
+  }
+  /**
+   * 对多个节点进行截图
+   * @param nodes 目标节点数组
+   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+   * @returns 截图路径数组
+   */
+  async takeScreenshotNodes(nodes, overlayHiddenScreenshotDelayMillis = 250) {
+    _Step.assert(this.stepId);
+    const result = await AssistsX2.takeScreenshotNodes(
+      nodes,
+      overlayHiddenScreenshotDelayMillis
+    );
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 获取所有符合条件的节点
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @param filterText 文本过滤
+   * @returns 节点数组
+   */
+  getAllNodes({
+    filterClass,
+    filterViewId,
+    filterDes,
+    filterText,
+    scope
+  } = {}) {
+    _Step.assert(this.stepId);
+    const nodes = AssistsX2.getAllNodes({
+      filterClass,
+      filterViewId,
+      filterDes,
+      filterText,
+      scope
+    });
+    _Step.assert(this.stepId);
+    _Step.assignIdsToNodes(nodes, this.stepId);
+    return nodes;
+  }
+  /**
+   * 启动应用
+   * @param packageName 应用包名
+   * @returns 是否启动成功
+   */
+  launchApp(packageName) {
+    _Step.assert(this.stepId);
+    const result = AssistsX2.launchApp(packageName);
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 获取当前应用包名
+   * @param options.scope 节点查找范围（可选）
+   */
+  getPackageName(options = {}) {
+    _Step.assert(this.stepId);
+    const result = AssistsX2.getPackageName(options);
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 通过ID查找节点
+   * @param id 节点ID
+   * @param filterClass 类名过滤
+   * @param filterText 文本过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  findById(id, {
+    filterClass,
+    filterText,
+    filterDes,
+    scope
+  } = {}) {
+    _Step.assert(this.stepId);
+    const nodes = AssistsX2.findById(id, {
+      filterClass,
+      filterText,
+      filterDes,
+      scope
+    });
+    _Step.assert(this.stepId);
+    _Step.assignIdsToNodes(nodes, this.stepId);
+    return nodes;
+  }
+  /**
+   * 通过文本查找节点
+   * @param text 要查找的文本
+   * @param filterClass 类名过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  findByText(text, {
+    filterClass,
+    filterViewId,
+    filterDes,
+    scope
+  } = {}) {
+    _Step.assert(this.stepId);
+    const nodes = AssistsX2.findByText(text, {
+      filterClass,
+      filterViewId,
+      filterDes,
+      scope
+    });
+    _Step.assert(this.stepId);
+    _Step.assignIdsToNodes(nodes, this.stepId);
+    return nodes;
+  }
+  /**
+   * 通过标签查找节点
+   * @param className 类名
+   * @param filterText 文本过滤
+   * @param filterViewId 视图ID过滤
+   * @param filterDes 描述过滤
+   * @returns 节点数组
+   */
+  findByTags(className, {
+    filterText,
+    filterViewId,
+    filterDes,
+    scope
+  } = {}) {
+    _Step.assert(this.stepId);
+    const nodes = AssistsX2.findByTags(className, {
+      filterText,
+      filterViewId,
+      filterDes,
+      scope
+    });
+    _Step.assert(this.stepId);
+    _Step.assignIdsToNodes(nodes, this.stepId);
+    return nodes;
+  }
+  /**
+   * 查找所有匹配文本的节点
+   * @param text 要查找的文本
+   * @param options.scope 节点查找范围（可选）
+   */
+  findByTextAllMatch(text, { scope } = {}) {
+    _Step.assert(this.stepId);
+    const nodes = AssistsX2.findByTextAllMatch(text, { scope });
+    _Step.assert(this.stepId);
+    _Step.assignIdsToNodes(nodes, this.stepId);
+    return nodes;
+  }
+  /**
+   * 检查是否包含指定文本
+   * @param text 要检查的文本
+   * @returns 是否包含
+   */
+  containsText(text) {
+    _Step.assert(this.stepId);
+    const result = AssistsX2.containsText(text);
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 获取所有文本
+   * @returns 文本数组
+   */
+  getAllText() {
+    _Step.assert(this.stepId);
+    const texts = AssistsX2.getAllText();
+    _Step.assert(this.stepId);
+    return texts;
+  }
+  /**
+   * 执行点击手势
+   * @param x 横坐标
+   * @param y 纵坐标
+   * @param duration 持续时间(毫秒)
+   * @returns 是否成功
+   */
+  async clickByGesture(x, y, duration) {
+    _Step.assert(this.stepId);
+    const result = await AssistsX2.clickByGesture(x, y, duration);
+    _Step.assert(this.stepId);
+    return result;
+  }
+  async longPressGestureAutoPaste(point, text, {
+    matchedPackageName,
+    matchedText,
+    timeoutMillis,
+    longPressDuration
+  } = { matchedText: "\u7C98\u8D34", timeoutMillis: 1500, longPressDuration: 600 }) {
+    _Step.assert(this.stepId);
+    const result = await AssistsX2.longPressGestureAutoPaste(point, text, {
+      matchedPackageName,
+      matchedText,
+      timeoutMillis,
+      longPressDuration
+    });
+    _Step.assert(this.stepId);
+    return result;
+  }
+  async getAppInfo(packageName) {
+    _Step.assert(this.stepId);
+    const result = await AssistsX2.getAppInfo(packageName);
+    _Step.assert(this.stepId);
+    return result;
+  }
+  async performLinearGesture(startPoint, endPoint, { duration } = {}) {
+    _Step.assert(this.stepId);
+    const result = await AssistsX2.performLinearGesture(startPoint, endPoint, {
+      duration
+    });
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 返回操作
+   * @returns 是否成功
+   */
+  back() {
+    _Step.assert(this.stepId);
+    const result = AssistsX2.back();
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 回到主页
+   * @returns 是否成功
+   */
+  home() {
+    _Step.assert(this.stepId);
+    const result = AssistsX2.home();
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 打开通知栏
+   * @returns 是否成功
+   */
+  notifications() {
+    _Step.assert(this.stepId);
+    const result = AssistsX2.notifications();
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 显示最近应用
+   * @returns 是否成功
+   */
+  recentApps() {
+    _Step.assert(this.stepId);
+    const result = AssistsX2.recentApps();
+    _Step.assert(this.stepId);
+    return result;
+  }
+  /**
+   * 获取屏幕尺寸
+   * @returns 屏幕尺寸对象
+   */
+  getScreenSize() {
+    _Step.assert(this.stepId);
+    const data = AssistsX2.getScreenSize();
+    _Step.assert(this.stepId);
+    return data;
+  }
+  /**
+   * 获取应用窗口尺寸
+   * @returns 应用窗口尺寸对象
+   */
+  getAppScreenSize() {
+    _Step.assert(this.stepId);
+    const data = AssistsX2.getAppScreenSize();
+    _Step.assert(this.stepId);
+    return data;
+  }
+};
+_Step.delayMsDefault = 1e3;
+_Step.repeatCountInfinite = -1;
+_Step.repeatCountMaxDefault = 15;
+_Step.showLog = false;
+_Step.exceptionRetryCountMaxDefault = 3;
+/**
+ * 当前执行步骤的ID
+ */
+_Step._stepId = void 0;
+/**
+ * 步骤拦截器列表
+ */
+_Step._interceptors = [];
+/**
+ * 步骤异常变量，默认为空
+ */
+_Step.exception = void 0;
+var Step = _Step;
+
+// src/step-flow/runner.ts
+function ensureFlowMeta(step, config) {
+  const data = step.data;
+  if (!data.__flow) {
+    data.__flow = { id: config.id, state: config.initial };
+  }
+}
+function setFlowState(step, state, config) {
+  const data = step.data;
+  if (!data.__flow) {
+    data.__flow = { id: config.id, state };
+  } else {
+    data.__flow.state = state;
+  }
+}
+function resolveOutcome(config, currentState, outcome) {
+  if (outcome.type === "end") {
+    return void 0;
+  }
+  if (outcome.type === "repeat") {
+    return null;
+  }
+  if (outcome.type === "legacy") {
+    return "legacy";
+  }
+  const stateDef = config.states[currentState];
+  if (!stateDef) {
+    throw new StepError(`StepFlow: unknown state "${currentState}"`, {
+      flowId: config.id,
+      state: currentState
+    });
+  }
+  const nextState = stateDef.on[outcome.name];
+  if (!nextState) {
+    throw new StepError(
+      `StepFlow: no transition for event "${outcome.name}" in state "${currentState}"`,
+      { flowId: config.id, state: currentState, event: outcome.name }
+    );
+  }
+  return nextState;
+}
+function createDispatcher(config) {
+  const dispatcher = async (step) => {
+    ensureFlowMeta(step, config);
+    const data = step.data;
+    const currentState = data.__flow.state;
+    const stateDef = config.states[currentState];
+    if (!stateDef) {
+      throw new StepError(`StepFlow: unknown state "${currentState}"`, {
+        flowId: config.id,
+        state: currentState
+      });
+    }
+    const outcome = await stateDef.run(step);
+    const resolved = resolveOutcome(config, currentState, outcome);
+    if (resolved === void 0) {
+      return void 0;
+    }
+    if (resolved === null) {
+      return step.repeat();
+    }
+    if (resolved === "legacy") {
+      if (outcome.type !== "legacy") {
+        throw new StepError("StepFlow: internal legacy outcome mismatch");
+      }
+      return step.next(outcome.impl);
+    }
+    setFlowState(step, resolved, config);
+    return step.next(dispatcher);
+  };
+  return dispatcher;
+}
+function createFlowDispatcher(config) {
+  return createDispatcher(config);
+}
+function buildFlowInitialData(config) {
+  var _a2;
+  return {
+    payload: (_a2 = config.data) != null ? _a2 : {},
+    __flow: {
+      id: config.id,
+      state: config.initial
+    }
+  };
+}
+var StepFlow = class {
+  /**
+   * 按状态机配置运行流程，内部复用 Step.run 与现有步骤循环。
+   */
+  static async run(config, options) {
+    var _a2;
+    if (!config.states[config.initial]) {
+      throw new StepError(
+        `StepFlow: initial state "${config.initial}" is not defined`,
+        { flowId: config.id }
+      );
+    }
+    const dispatcher = createDispatcher(config);
+    return Step.run(dispatcher, {
+      ...options,
+      tag: (_a2 = options == null ? void 0 : options.tag) != null ? _a2 : config.id,
+      data: buildFlowInitialData(config)
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StepFlow,
+  assignFlowPayload,
+  buildFlowInitialData,
+  createFinishHandoff,
+  createFlowDispatcher,
+  createLaunchState,
+  flowEnd,
+  flowEvent,
+  flowRepeat,
+  getFlowPayload
+});
+//# sourceMappingURL=index.cjs.map