agent-device 0.15.2 → 0.16.1

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift

@@ -27,6 +27,7 @@ extension RunnerTests {
   struct SelectorElementMatch {
     let element: XCUIElement?
     let isAmbiguous: Bool
+    let usedNonHittableFallback: Bool
   }
 
   enum TextTypingRepairMode {
@@ -177,10 +178,15 @@ extension RunnerTests {
     return element.exists ? element : nil
   }
 
-  func findElement(app: XCUIApplication, selectorKey: String, selectorValue: String) -> SelectorElementMatch {
+  func findElement(
+    app: XCUIApplication,
+    selectorKey: String,
+    selectorValue: String,
+    allowNonHittableFallback: Bool = false
+  ) -> SelectorElementMatch {
     let value = selectorValue.trimmingCharacters(in: .whitespacesAndNewlines)
     guard !value.isEmpty else {
-      return SelectorElementMatch(element: nil, isAmbiguous: false)
+      return SelectorElementMatch(element: nil, isAmbiguous: false, usedNonHittableFallback: false)
     }
     let predicate: NSPredicate
     switch selectorKey {
@@ -193,21 +199,47 @@ extension RunnerTests {
     case "text":
       predicate = NSPredicate(format: "label ==[c] %@ OR identifier ==[c] %@ OR value ==[c] %@", value, value, value)
     default:
-      return SelectorElementMatch(element: nil, isAmbiguous: false)
+      return SelectorElementMatch(element: nil, isAmbiguous: false, usedNonHittableFallback: false)
     }
 
     var matchedElement: XCUIElement?
+    var nonHittableElement: XCUIElement?
     let matches = app.descendants(matching: .any).matching(predicate).allElementsBoundByIndex
     for element in matches where element.exists {
-      guard element.isHittable else {
+      if !element.isHittable {
+        if allowNonHittableFallback && hasTappableFrame(app: app, element: element) {
+          guard nonHittableElement == nil else {
+            return SelectorElementMatch(element: nil, isAmbiguous: true, usedNonHittableFallback: false)
+          }
+          nonHittableElement = element
+        }
         continue
       }
       guard matchedElement == nil else {
-        return SelectorElementMatch(element: nil, isAmbiguous: true)
+        return SelectorElementMatch(element: nil, isAmbiguous: true, usedNonHittableFallback: false)
       }
       matchedElement = element
     }
-    return SelectorElementMatch(element: matchedElement, isAmbiguous: false)
+    if let matchedElement {
+      return SelectorElementMatch(element: matchedElement, isAmbiguous: false, usedNonHittableFallback: false)
+    }
+    return SelectorElementMatch(
+      element: nonHittableElement,
+      isAmbiguous: false,
+      usedNonHittableFallback: nonHittableElement != nil
+    )
+  }
+
+  private func hasTappableFrame(app: XCUIApplication, element: XCUIElement) -> Bool {
+    let frame = element.frame
+    if frame.isEmpty {
+      return false
+    }
+    let appFrame = app.frame
+    if appFrame.isEmpty {
+      return true
+    }
+    return appFrame.contains(CGPoint(x: frame.midX, y: frame.midY))
   }
 
   func queryElement(app: XCUIApplication, selectorKey: String, selectorValue: String) -> Response {
@@ -303,7 +335,7 @@ extension RunnerTests {
           switch element.elementType {
           case .textField, .secureTextField, .searchField, .textView:
             let frame = element.frame
-            return !frame.isEmpty && frame.contains(point)
+            return !frame.isEmpty && frameContainsPoint(frame, point, tolerance: 2)
           default:
             return false
           }
@@ -334,20 +366,33 @@ extension RunnerTests {
     return matched
   }
 
+  private func frameContainsPoint(_ frame: CGRect, _ point: CGPoint, tolerance: CGFloat) -> Bool {
+    point.x >= frame.minX - tolerance
+      && point.x <= frame.maxX + tolerance
+      && point.y >= frame.minY - tolerance
+      && point.y <= frame.maxY + tolerance
+  }
+
   func focusedTextInput(app: XCUIApplication) -> XCUIElement? {
+#if os(iOS)
+    // iOS focus predicates can return stale or misleading text-input matches
+    // under XCUITest, so text entry readiness is driven by tap/keyboard state.
+    return nil
+#else
     var focused: XCUIElement?
     let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
-      let candidate = app
+      let candidates = app
         .descendants(matching: .any)
         .matching(NSPredicate(format: "hasKeyboardFocus == 1"))
-        .firstMatch
-      guard candidate.exists else { return }
-
-      switch candidate.elementType {
-      case .textField, .secureTextField, .searchField, .textView:
-        focused = candidate
-      default:
-        return
+        .allElementsBoundByIndex
+      for candidate in candidates where candidate.exists {
+        switch candidate.elementType {
+        case .textField, .secureTextField, .searchField, .textView:
+          focused = candidate
+          return
+        default:
+          continue
+        }
       }
     })
     if let exceptionMessage {
@@ -358,6 +403,7 @@ extension RunnerTests {
       return nil
     }
     return focused
+#endif
   }
 
   func stabilizeTextInputBeforeTyping(app: XCUIApplication, target: XCUIElement?) -> XCUIElement? {
@@ -417,6 +463,36 @@ extension RunnerTests {
     )
   }
 
+  func focusTextInputForTextEntry(app: XCUIApplication, element: XCUIElement) -> TextEntryTarget {
+    let point = textEntryRefreshPoint(for: element)
+    if let point {
+      _ = tapAt(app: app, x: point.x, y: point.y)
+    }
+    let stabilized = stabilizeTextInputBeforeTyping(app: app, target: element)
+    let resolved = waitForTextEntryReadiness(
+      app: app,
+      target: TextEntryTarget(
+        element: stabilized ?? element,
+        refreshPoint: point,
+        prefersFocusedElement: false
+      )
+    ) ?? stabilized ?? element
+    return TextEntryTarget(
+      element: resolved,
+      refreshPoint: textEntryRefreshPoint(for: resolved) ?? point,
+      prefersFocusedElement: false
+    )
+  }
+
+  func isTextEntryElement(_ element: XCUIElement) -> Bool {
+    switch element.elementType {
+    case .textField, .secureTextField, .searchField, .textView:
+      return true
+    default:
+      return false
+    }
+  }
+
   func resolveTextEntryMode(_ command: Command) -> TextTypingRepairMode {
     switch command.textEntryMode {
     case "append":
@@ -597,7 +673,7 @@ extension RunnerTests {
     guard let observedText = editableTextValue(for: targetElement) else {
       return TextEntryResult(verified: nil, repaired: repaired, expectedText: expectedText, observedText: nil)
     }
-    guard observedText == expectedText else {
+    guard textEntryValueMatchesExpected(targetElement, observedText: observedText, expectedText: expectedText) else {
       return TextEntryResult(
         verified: false,
         repaired: repaired,
@@ -613,7 +689,11 @@ extension RunnerTests {
         return TextEntryResult(verified: nil, repaired: repaired, expectedText: expectedText, observedText: nil)
       }
       latestObservedText = nextObservedText
-      guard nextObservedText == expectedText else {
+      guard textEntryValueMatchesExpected(
+        resolveTextEntryElement(app: app, target: target),
+        observedText: nextObservedText,
+        expectedText: expectedText
+      ) else {
         return TextEntryResult(
           verified: false,
           repaired: repaired,
@@ -630,6 +710,28 @@ extension RunnerTests {
     )
   }
 
+  private func textEntryValueMatchesExpected(
+    _ element: XCUIElement?,
+    observedText: String,
+    expectedText: String
+  ) -> Bool {
+    if observedText == expectedText {
+      return true
+    }
+    guard hasTextEntrySubmitSuffix(expectedText), element?.elementType != .textView else {
+      return false
+    }
+    var submittedText = expectedText
+    while hasTextEntrySubmitSuffix(submittedText) {
+      submittedText.removeLast()
+    }
+    return observedText == submittedText
+  }
+
+  private func hasTextEntrySubmitSuffix(_ text: String) -> Bool {
+    text.hasSuffix("\n") || text.hasSuffix("\r")
+  }
+
   private func expectedTextEntryValue(
     typedText: String,
     mode: TextTypingRepairMode,
@@ -661,7 +763,11 @@ extension RunnerTests {
       guard let observedText = editableTextValue(for: resolveTextEntryElement(app: app, target: target)) else {
         return false
       }
-      if observedText == expectedText {
+      if textEntryValueMatchesExpected(
+        resolveTextEntryElement(app: app, target: target),
+        observedText: observedText,
+        expectedText: expectedText
+      ) {
         return false
       }
       latestObservedText = observedText
@@ -678,7 +784,11 @@ extension RunnerTests {
     guard let latestObservedText else {
       return false
     }
-    guard latestObservedText != expectedText else {
+    guard !textEntryValueMatchesExpected(
+      resolveTextEntryElement(app: app, target: target),
+      observedText: latestObservedText,
+      expectedText: expectedText
+    ) else {
       return false
     }
     return isRepairableTextEntryMismatch(
@@ -780,6 +890,35 @@ extension RunnerTests {
 #endif
   }
 
+  func waitForTextEntryReadinessAfterTap(app: XCUIApplication, element: XCUIElement) {
+#if os(iOS)
+    switch element.elementType {
+    case .textField, .secureTextField, .searchField, .textView:
+      if waitForFocusedTextInput(app: app, timeout: TextEntryTiming.readinessTimeout) != nil {
+        return
+      }
+      let frame = element.frame
+      if !frame.isEmpty {
+        _ = tapAt(app: app, x: frame.midX, y: frame.midY)
+        _ = waitForFocusedTextInput(app: app, timeout: TextEntryTiming.readinessTimeout)
+      }
+    default:
+      return
+    }
+#endif
+  }
+
+  private func waitForFocusedTextInput(app: XCUIApplication, timeout: TimeInterval) -> XCUIElement? {
+    let deadline = Date().addingTimeInterval(timeout)
+    while Date() < deadline {
+      if let focused = focusedTextInput(app: app) {
+        return focused
+      }
+      sleepFor(TextEntryTiming.pollInterval)
+    }
+    return focusedTextInput(app: app)
+  }
+
   private func textEntryRefreshPoint(for element: XCUIElement?) -> CGPoint? {
     guard let element else {
       return nil
@@ -843,6 +982,85 @@ extension RunnerTests {
 #endif
   }
 
+  func pressKeyboardReturn(app: XCUIApplication) -> (wasVisible: Bool, pressed: Bool, visible: Bool) {
+#if os(tvOS)
+    return (wasVisible: false, pressed: pressTvRemote(.select), visible: false)
+#elseif os(iOS)
+    let wasVisible = isKeyboardVisible(app: app)
+    if tapKeyboardReturnControl(app: app) {
+      sleepFor(0.2)
+      return (wasVisible: wasVisible, pressed: true, visible: isKeyboardVisible(app: app))
+    }
+
+    var typed = false
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      app.typeText(XCUIKeyboardKey.return.rawValue)
+      typed = true
+    })
+    if let exceptionMessage {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_KEYBOARD_RETURN_IGNORED_EXCEPTION=%@",
+        exceptionMessage
+      )
+      if let singleTarget = singleTextEntryElement(app: app) {
+        return pressKeyboardReturn(on: singleTarget, app: app, wasVisible: wasVisible)
+      }
+      return (wasVisible: wasVisible, pressed: false, visible: isKeyboardVisible(app: app))
+    }
+    sleepFor(0.2)
+    return (wasVisible: wasVisible, pressed: typed, visible: isKeyboardVisible(app: app))
+#else
+    return (wasVisible: false, pressed: false, visible: false)
+#endif
+  }
+
+  private func pressKeyboardReturn(
+    on element: XCUIElement,
+    app: XCUIApplication,
+    wasVisible: Bool
+  ) -> (wasVisible: Bool, pressed: Bool, visible: Bool) {
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      element.tap()
+      element.typeText(XCUIKeyboardKey.return.rawValue)
+    })
+    if let exceptionMessage {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_KEYBOARD_RETURN_TARGET_IGNORED_EXCEPTION=%@",
+        exceptionMessage
+      )
+      return (wasVisible: wasVisible, pressed: false, visible: isKeyboardVisible(app: app))
+    }
+    sleepFor(0.2)
+    return (wasVisible: wasVisible, pressed: true, visible: isKeyboardVisible(app: app))
+  }
+
+  private func singleTextEntryElement(app: XCUIApplication) -> XCUIElement? {
+#if os(iOS)
+    var matches: [XCUIElement] = []
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      matches = app.descendants(matching: .any).allElementsBoundByIndex.filter { element in
+        guard element.exists else { return false }
+        switch element.elementType {
+        case .textField, .secureTextField, .searchField, .textView:
+          return true
+        default:
+          return false
+        }
+      }
+    })
+    if let exceptionMessage {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_KEYBOARD_RETURN_TEXT_ENTRY_QUERY_IGNORED_EXCEPTION=%@",
+        exceptionMessage
+      )
+      return nil
+    }
+    return matches.count == 1 ? matches[0] : nil
+#else
+    return nil
+#endif
+  }
+
   private func tapKeyboardDismissControl(app: XCUIApplication) -> Bool {
 #if os(tvOS)
     return false
@@ -880,6 +1098,22 @@ extension RunnerTests {
 #endif
   }
 
+  private func tapKeyboardReturnControl(app: XCUIApplication) -> Bool {
+#if os(iOS)
+    for label in ["return", "Return", "Enter", "Go", "Search", "Next", "Done", "Send", "Join"] {
+      let candidates = [
+        app.keyboards.buttons[label],
+        app.keyboards.keys[label],
+      ]
+      if let hittable = candidates.first(where: { $0.exists && $0.isHittable }) {
+        hittable.tap()
+        return true
+      }
+    }
+#endif
+    return false
+  }
+
   private func isKeyboardAccessoryControl(_ element: XCUIElement, keyboardFrame: CGRect) -> Bool {
     let frame = element.frame
     guard !frame.isEmpty && !keyboardFrame.isEmpty else {
@@ -942,11 +1176,24 @@ extension RunnerTests {
     guard !normalizedValue.isEmpty else {
       return false
     }
-    guard let placeholder = element.placeholderValue?.trimmingCharacters(in: .whitespacesAndNewlines),
-          !placeholder.isEmpty else {
+    let placeholder = element.placeholderValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+    if !placeholder.isEmpty && normalizedValue == placeholder {
+      return true
+    }
+    if isGenericTextInputLabel(normalizedValue) {
+      return true
+    }
+    let normalizedLabel = element.label.trimmingCharacters(in: .whitespacesAndNewlines)
+    return normalizedLabel == normalizedValue && isGenericTextInputLabel(normalizedLabel)
+  }
+
+  private func isGenericTextInputLabel(_ value: String) -> Bool {
+    switch value {
+    case "Text input field":
+      return true
+    default:
       return false
     }
-    return normalizedValue == placeholder
   }
 
   private func readableText(for element: XCUIElement) -> String? {
@@ -1266,6 +1513,51 @@ extension RunnerTests {
     return performCoordinatePinch(app: app, scale: scale, x: x, y: y)
   }
 
+  func rotateGesture(app: XCUIApplication, degrees: Double, x: Double?, y: Double?, velocity: Double) -> RunnerInteractionOutcome {
+    return performCoordinateRotateGesture(app: app, degrees: degrees, x: x, y: y, velocity: velocity)
+  }
+
+  func transformGesture(
+    app: XCUIApplication,
+    x: Double,
+    y: Double,
+    dx: Double,
+    dy: Double,
+    scale: Double,
+    degrees: Double,
+    durationMs: Double
+  ) -> RunnerInteractionOutcome {
+#if os(iOS)
+    let target = interactionRoot(app: app)
+    if let message = RunnerSynthesizedGesture.synthesizeTransform(
+      withApplication: app,
+      x: x,
+      y: y,
+      dx: dx,
+      dy: dy,
+      scale: scale,
+      degrees: degrees,
+      radius: transformGestureRadius(frame: target.frame, scale: scale),
+      durationMs: durationMs
+    ) {
+      return .unsupported(message)
+    }
+    return .performed
+#elseif os(tvOS)
+    return .unsupported("transformGesture is not supported on tvOS")
+#else
+    return .unsupported("transformGesture is not supported on macOS")
+#endif
+  }
+
+  private func transformGestureRadius(frame: CGRect, scale: Double) -> Double {
+    let shorterSide = Double(min(frame.width, frame.height))
+    let frameRadius = shorterSide * 0.20
+    let minimumEndRadius = shorterSide * 0.08
+    let scaleAdjustedRadius = scale < 1.0 ? max(frameRadius, minimumEndRadius / scale) : frameRadius
+    return min(max(scaleAdjustedRadius, 48.0), shorterSide * 0.35)
+  }
+
   private func performCoordinatePinch(app: XCUIApplication, scale: Double, x: Double?, y: Double?) -> RunnerInteractionOutcome {
 #if os(tvOS)
     return .unsupported("pinch is not supported on tvOS")
@@ -1304,6 +1596,19 @@ extension RunnerTests {
 #endif
   }
 
+  private func performCoordinateRotateGesture(app: XCUIApplication, degrees: Double, x: Double?, y: Double?, velocity: Double) -> RunnerInteractionOutcome {
+#if os(iOS)
+    let target = app.windows.firstMatch.exists ? app.windows.firstMatch : app
+    let radians = CGFloat(degrees * .pi / 180.0)
+    target.rotate(radians, withVelocity: CGFloat(velocity))
+    return .performed
+#elseif os(tvOS)
+    return .unsupported("rotate-gesture is not supported on tvOS")
+#else
+    return .unsupported("rotate-gesture is not supported on macOS")
+#endif
+  }
+
   private func interactionRoot(app: XCUIApplication) -> XCUIElement {
     let windows = app.windows.allElementsBoundByIndex
     if let window = windows.first(where: { $0.exists && !$0.frame.isEmpty }) {

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift

@@ -248,7 +248,9 @@ extension RunnerTests {
       .rotate,
       .appSwitcher,
       .keyboardDismiss,
-      .pinch:
+      .pinch,
+      .rotateGesture,
+      .transformGesture:
       return true
     default:
       return false

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Models.swift

@@ -23,8 +23,11 @@ enum CommandType: String, Codable {
   case rotate
   case appSwitcher
   case keyboardDismiss
+  case keyboardReturn
   case alert
   case pinch
+  case rotateGesture
+  case transformGesture
   case recordStart
   case recordStop
   case uptime
@@ -37,6 +40,7 @@ struct Command: Codable {
   let text: String?
   let selectorKey: String?
   let selectorValue: String?
+  let allowNonHittableCoordinateFallback: Bool?
   let delayMs: Int?
   let textEntryMode: String?
   let clearFirst: Bool?
@@ -52,10 +56,14 @@ struct Command: Codable {
   let pattern: String?
   let x2: Double?
   let y2: Double?
+  let dx: Double?
+  let dy: Double?
   let durationMs: Double?
   let direction: String?
   let orientation: String?
   let scale: Double?
+  let degrees: Double?
+  let velocity: Double?
   let outPath: String?
   let fps: Int?
   let quality: Int?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-device",
-  "version": "0.15.2",
+  "version": "0.16.1",
   "description": "Agent-native CLI for AI mobile testing and app automation across iOS, Android, tvOS, Android TV, macOS, and Linux.",
   "mcpName": "io.github.callstackincubator/agent-device",
   "license": "MIT",
@@ -90,6 +90,9 @@
     "build:android-snapshot-helper": "sh ./scripts/build-android-snapshot-helper.sh $(node -p \"require('./package.json').version\") .tmp/android-snapshot-helper",
     "package:android-snapshot-helper": "sh ./scripts/package-android-snapshot-helper.sh $(node -p \"require('./package.json').version\") v$(node -p \"require('./package.json').version\") .tmp/android-snapshot-helper",
     "package:android-snapshot-helper:npm": "rm -rf android-snapshot-helper/dist && sh ./scripts/package-android-snapshot-helper.sh $(node -p \"require('./package.json').version\") v$(node -p \"require('./package.json').version\") android-snapshot-helper/dist",
+    "build:android-multitouch-helper": "sh ./scripts/build-android-multitouch-helper.sh $(node -p \"require('./package.json').version\") .tmp/android-multitouch-helper",
+    "package:android-multitouch-helper": "sh ./scripts/package-android-multitouch-helper.sh $(node -p \"require('./package.json').version\") .tmp/android-multitouch-helper",
+    "package:android-multitouch-helper:npm": "rm -rf android-multitouch-helper/dist && sh ./scripts/package-android-multitouch-helper.sh $(node -p \"require('./package.json').version\") android-multitouch-helper/dist",
     "build:macos-helper": "swift build -c release --package-path macos-helper",
     "build:all": "pnpm build:node && pnpm build:xcuitest",
     "ad": "node bin/agent-device.mjs",
@@ -104,7 +107,7 @@
     "check:tooling": "pnpm lint && pnpm typecheck && pnpm check:mcp-metadata && pnpm build",
     "check:unit": "pnpm test:unit && pnpm test:smoke",
     "check": "pnpm check:tooling && pnpm check:fallow && pnpm check:unit",
-    "prepack": "pnpm check:mcp-metadata && pnpm build:all && pnpm package:android-snapshot-helper:npm",
+    "prepack": "pnpm check:mcp-metadata && pnpm build:all && pnpm package:android-snapshot-helper:npm && pnpm package:android-multitouch-helper:npm",
     "typecheck": "tsc -p tsconfig.json",
     "test-app:install": "pnpm install --dir examples/test-app --ignore-workspace",
     "test-app:start": "pnpm --dir examples/test-app start",
@@ -122,7 +125,8 @@
     "test:integration:provider": "vitest run --project provider-integration",
     "test:integration:progress": "node scripts/integration-progress.mjs",
     "test:integration:progress:check": "node scripts/integration-progress.mjs --check",
-    "test:skillgym": "pnpm build && skillgym run ./test/skillgym/suites/agent-device-smoke-suite.ts --config ./test/skillgym/skillgym.config.ts",
+    "test:skillgym": "node test/skillgym/runner-environment.ts && pnpm build && skillgym run ./test/skillgym/suites/agent-device-smoke-suite.ts --config ./test/skillgym/skillgym.config.ts",
+    "test:skillgym:case": "node test/skillgym/runner-environment.ts && pnpm build && skillgym run ./test/skillgym/suites/agent-device-smoke-suite.ts --config ./test/skillgym/skillgym.config.ts --case",
     "test:smoke": "node --test test/integration/smoke-*.test.ts",
     "test:integration:node": "node --test test/integration/*.test.ts",
     "test:integration": "pnpm test:integration:node && pnpm test:integration:provider",
@@ -144,6 +148,8 @@
     "!macos-helper/**/.build",
     "android-snapshot-helper/dist",
     "!android-snapshot-helper/dist/*.idsig",
+    "android-multitouch-helper/dist",
+    "!android-multitouch-helper/dist/*.idsig",
     "src/platforms/linux/atspi-dump.py",
     "skills",
     "server.json",

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/callstackincubator/agent-device",
     "source": "github"
   },
-  "version": "0.15.2",
+  "version": "0.16.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "agent-device",
-      "version": "0.15.2",
+      "version": "0.16.1",
       "transport": {
         "type": "stdio"
       }

package/android-snapshot-helper/dist/agent-device-android-snapshot-helper-0.15.2.apk.sha256

@@ -1 +0,0 @@
-56421142cf1ac84bb0313d993da7eb408109149178873225741570ca96dd7aa0  agent-device-android-snapshot-helper-0.15.2.apk

package/dist/src/1393.js

@@ -1 +0,0 @@
-import{AppError as e}from"./9152.js";let r="user-installed";function t(e){return e??r}function o(r){if(void 0===r)throw new e("INVALID_ARGS","appsFilter must be resolved before executing the apps command");return r}export{r as DEFAULT_APPS_FILTER,o as assertResolvedAppsFilter,t as resolveAppsFilter};