mobridge-mcp 0.0.6 → 0.0.8

package/resources/ios/MobileSemantic/UITests/BridgeServer.swift

@@ -1,6 +1,7 @@
 import Foundation
 import XCTest
 import Darwin
+import ObjectiveC
 
 // The XCTest Runner (WDA-style): a long-running UI test that binds a TCP socket on 127.0.0.1:8500 and
 // services length-prefixed JSON-RPC requests by doing REAL XCUIApplication/XCUIElement work. TS stays
@@ -14,15 +15,33 @@ final class BridgeServer: XCTestCase {
     private let runnerInstanceId = UUID().uuidString
     private var sessionToken = ""
     private var app: XCUIApplication!
-    // The bundle id of the app currently under automation. nil = the default test-host target (fixture).
-    // app.open with a `bundleId` switches this to any already-installed app (XCUIApplication(bundleIdentifier:)),
-    // so CMS can read/act on App Store / system apps without re-signing them; only this Runner is signed.
+    // The bundle id of the app currently under automation. Default = SpringBoard (the home screen), since
+    // this is a standalone UI-test Runner with NO host app of its own. app.open with a `bundleId` switches
+    // this to any already-installed app (XCUIApplication(bundleIdentifier:)), so CMS can read/act on App
+    // Store / system apps without re-signing them; only this Runner is signed.
+    private static let springboard = "com.apple.springboard"
     private var targetBundleId: String? = nil
 
+    // PERF (the single biggest iOS speedup): XCUITest blocks EVERY query/gesture until the app reaches a
+    // quiescent state (animations + main-runloop idle). A media feed (TikTok, a game, any animation) never
+    // idles, so each call waits the full ~animation timeout and appears to hang / times out. Neutralize the
+    // private `waitForQuiescenceIncludingAnimationsIdle:` to a no-op — the same technique WebDriverAgent /
+    // Appium use. Guarded: if Apple renames it, we simply keep the default (slow but correct) behavior.
+    private static func disableQuiescenceWaiting() {
+        guard let cls = NSClassFromString("XCUIApplicationProcess") else { return }
+        let sel = NSSelectorFromString("waitForQuiescenceIncludingAnimationsIdle:")
+        guard let method = class_getInstanceMethod(cls, sel) else { return }
+        let noop: @convention(block) (AnyObject, Bool) -> Void = { _, _ in }
+        method_setImplementation(method, imp_implementationWithBlock(noop))
+        FileHandle.standardError.write("[runner] quiescence wait disabled (fast mode)\n".data(using: .utf8)!)
+    }
+
     func testServe() throws {
         continueAfterFailure = true
-        app = XCUIApplication()
-        app.launch()
+        BridgeServer.disableQuiescenceWaiting()
+        // Standalone Runner (no fixture host app): default to SpringBoard, which is always running, so a
+        // screen.get before any app.open reads the home screen instead of launching a nonexistent host.
+        app = XCUIApplication(bundleIdentifier: BridgeServer.springboard)
 
         let listenFd = try openListener(port: BridgeServer.port)
         defer { close(listenFd) }
@@ -73,6 +92,8 @@ final class BridgeServer: XCTestCase {
             return ok(snapshot())
         case "screen.act":
             return screenAct(params, ok: ok, err: err)
+        case "gesture.perform":
+            return gesturePerform(params, ok: ok, err: err)
         case "system.action":
             let a = params["action"] as? String ?? ""
             // rc.2: DISPATCH + evidence only. HOME is business-level with no intrinsic predicate; the
@@ -88,6 +109,56 @@ final class BridgeServer: XCTestCase {
         }
     }
 
+    // Coordinate gesture (mobile.gesture.perform): TAP / LONG_PRESS / SWIPE / DRAG by absolute screen
+    // points, for surfaces with no semantic node to act on (media feeds, canvas, maps). Points map onto
+    // the app window via a (0,0)-normalized coordinate + a point offset. PINCH is not expressible via a
+    // single XCUICoordinate, so it is honestly rejected.
+    private func gesturePerform(_ p: [String: Any], ok: ([String: Any]) -> ([String: Any], Bool), err: (String, String, [String]) -> ([String: Any], Bool)) -> ([String: Any], Bool) {
+        func num(_ v: Any?) -> Double? { if let d = v as? Double { return d }; if let i = v as? Int { return Double(i) }; if let s = v as? String { return Double(s) }; return nil }
+        let kind = (p["kind"] as? String ?? "TAP").uppercased()
+        guard let x = num(p["x"]), let y = num(p["y"]) else {
+            return err("ACTION_REJECTED", "gesture.perform needs numeric x,y.", ["Pass x,y (and x2,y2 for SWIPE/DRAG) in screen points."])
+        }
+        // Blind coordinate gesture: NO before/after snapshot (a heavy media feed's tree is slow to capture
+        // and needs no semantic verification here — the caller does an explicit screen.get if it wants one).
+        // PRIMARY path is MSHID: synthesized HID touch events that bypass the app process entirely, so a
+        // swipe on TikTok is injected in ~ms instead of ~1.2s via XCUICoordinate (which waits on the app).
+        // XCUICoordinate stays as a fallback only if the private HID API is unavailable on this OS.
+        let start = CGPoint(x: x, y: y)
+        var endPoint = start
+        if kind == "SWIPE" || kind == "DRAG" {
+            guard let x2 = num(p["x2"]), let y2 = num(p["y2"]) else {
+                return err("ACTION_REJECTED", "\(kind) needs x2,y2 (end point).", ["Pass x2,y2 in screen points."])
+            }
+            endPoint = CGPoint(x: x2, y: y2)
+        }
+        guard ["TAP", "LONG_PRESS", "SWIPE", "DRAG"].contains(kind) else {
+            return err("ACTION_UNSUPPORTED", "gesture kind '\(kind)' is not supported on iOS.", ["Use TAP, LONG_PRESS, SWIPE, or DRAG."])
+        }
+        // PRIMARY: HID injection (MODERN_HID iOS15+ → LEGACY_HID iOS14), which bypasses the app process so
+        // a swipe on a heavy/animated app lands in ~ms. MSHID returns the injector name, or nil → fall back
+        // to XCUICoordinate (slow, but always available) so the gesture is never lost.
+        var method: String?
+        switch kind {
+        case "TAP": method = MSHID.tap(at: start)
+        case "LONG_PRESS": method = MSHID.longPress(at: start, duration: 0.7)
+        case "SWIPE": method = MSHID.swipe(from: start, to: endPoint, duration: 0.12)
+        case "DRAG": method = MSHID.drag(from: start, to: endPoint, duration: 0.6)
+        default: break
+        }
+        if method == nil {
+            let origin = app.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0))
+            let s = origin.withOffset(CGVector(dx: x, dy: y))
+            switch kind {
+            case "TAP": s.tap()
+            case "LONG_PRESS": s.press(forDuration: 0.7)
+            default: s.press(forDuration: kind == "DRAG" ? 0.6 : 0.08, thenDragTo: origin.withOffset(CGVector(dx: endPoint.x, dy: endPoint.y)))
+            }
+            method = "COORDINATE"
+        }
+        return ok(["dispatch": ["status": "DISPATCHED", "method": method!, "fallbackType": "GESTURE"], "screenChanged": true])
+    }
+
     private func isValidBundleId(_ b: String) -> Bool {
         // reverse-DNS-ish: segments of [A-Za-z0-9-] joined by dots; guards against argv/format injection.
         guard b.count <= 255 else { return false }
@@ -95,7 +166,7 @@ final class BridgeServer: XCTestCase {
     }
 
     private func snapshot() -> [String: Any] {
-        let bundle = targetBundleId ?? (Bundle.main.bundleIdentifier ?? "fixture")
+        let bundle = targetBundleId ?? BridgeServer.springboard
         if let snap = try? app.snapshot() {
             return Xcui.toScreenSnapshot(snap, bundleId: bundle, deviceId: "ios-sim")
         }

package/resources/ios/MobileSemantic/UITests/MSHID.h

@@ -0,0 +1,25 @@
+// MSHID — HID-level gesture injection facade (Appium/WebDriverAgent technique). Synthesizes touch
+// events WITHOUT querying the app's accessibility tree and WITHOUT waiting on the app process, so a
+// TAP/SWIPE/DRAG/LONG_PRESS lands in ~ms regardless of how heavy/animated the foreground app is.
+//
+// Version-durable: a GestureInjector chain tries the MODERN path first
+// (XCSynthesizedEventRecord + XCPointerEventPath via XCUIDevice.eventSynthesizer, iOS 15+/current),
+// then the LEGACY path (XCEventGenerator, iOS 14). Each method returns the injector name that
+// succeeded ("MODERN_HID" / "LEGACY_HID") or nil, so the Swift caller can fall back to XCUICoordinate
+// and report which path ran. All coordinates are ABSOLUTE screen points.
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MSHID : NSObject
+/// True when any HID injector is usable on this OS (else the caller uses XCUICoordinate).
++ (BOOL)available;
+/// Each returns the method name that injected the gesture ("MODERN_HID"/"LEGACY_HID"), or nil on failure.
++ (nullable NSString *)tapAt:(CGPoint)point;
++ (nullable NSString *)longPressAt:(CGPoint)point duration:(double)duration;
++ (nullable NSString *)swipeFrom:(CGPoint)from to:(CGPoint)to duration:(double)duration;
++ (nullable NSString *)dragFrom:(CGPoint)from to:(CGPoint)to duration:(double)duration;
+@end
+
+NS_ASSUME_NONNULL_END

package/resources/ios/MobileSemantic/UITests/MSHID.m

@@ -0,0 +1,155 @@
+#import "MSHID.h"
+#import <XCTest/XCTest.h>
+
+// ---- Private XCTest event APIs (signatures from appium/WebDriverAgent PrivateHeaders) --------------
+
+// MODERN (iOS 15+/current): build a pointer path, wrap it in a synthesized event, dispatch via the
+// device's event synthesizer. This is what WDA switched to when Apple reworked XCTest internals.
+@interface XCPointerEventPath : NSObject
+- (instancetype)initForTouchAtPoint:(CGPoint)point offset:(double)offset;
+- (void)moveToPoint:(CGPoint)point atOffset:(double)offset;
+- (void)liftUpAtOffset:(double)offset;
+@end
+
+@interface XCSynthesizedEventRecord : NSObject
+- (instancetype)initWithName:(NSString *)name interfaceOrientation:(long long)orientation;
+- (void)addPointerEventPath:(XCPointerEventPath *)path;
+@end
+
+@interface NSObject (MSEventSynthesizer)
+- (id)eventSynthesizer;                                                        // on XCUIDevice
+- (void)synthesizeEvent:(id)event completion:(void (^)(BOOL result, NSError *error))completion;  // on the synthesizer
+@end
+
+// LEGACY (iOS 14): the older singleton generator.
+@interface XCEventGenerator : NSObject
++ (instancetype)sharedGenerator;
+- (double)pressAtPoint:(CGPoint)point forDuration:(double)duration liftAtPoint:(CGPoint)liftPoint velocity:(double)velocity orientation:(long long)orientation name:(NSString *)name handler:(void (^)(id record, NSError *error))handler;
+- (double)pressAtPoint:(CGPoint)point forDuration:(double)duration orientation:(long long)orientation handler:(void (^)(id record, NSError *error))handler;
+@end
+
+// Portrait; the CMS coordinates are already in portrait screen points.
+static const long long kPortrait = 1;
+
+// Run an async injector and wait (bounded) for its completion. The Runner's socket loop is NOT the main
+// thread, so a plain semaphore wait here does not deadlock a completion delivered on the main queue.
+static BOOL MSAwait(double timeout, void (^inject)(dispatch_semaphore_t sem)) {
+    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+    @try { inject(sem); }
+    @catch (NSException *e) { return NO; }
+    return dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeout * NSEC_PER_SEC))) == 0;
+}
+
+// ---- Injector protocol + two implementations ------------------------------------------------------
+
+@protocol MSGestureInjector <NSObject>
+- (BOOL)available;
+- (NSString *)name;
+- (BOOL)tapAt:(CGPoint)p;
+- (BOOL)longPressAt:(CGPoint)p duration:(double)dur;
+- (BOOL)swipeFrom:(CGPoint)from to:(CGPoint)to duration:(double)dur;
+- (BOOL)dragFrom:(CGPoint)from to:(CGPoint)to duration:(double)dur;
+@end
+
+// MODERN — XCSynthesizedEventRecord + XCPointerEventPath via XCUIDevice.eventSynthesizer.
+@interface MSModernInjector : NSObject <MSGestureInjector>
+@end
+@implementation MSModernInjector
+- (NSString *)name { return @"MODERN_HID"; }
+- (id)synthesizer {
+    XCUIDevice *dev = [XCUIDevice sharedDevice];
+    if (![dev respondsToSelector:@selector(eventSynthesizer)]) return nil;
+    return [dev eventSynthesizer];
+}
+- (BOOL)available {
+    return NSClassFromString(@"XCSynthesizedEventRecord") && NSClassFromString(@"XCPointerEventPath") && [self synthesizer];
+}
+// Build a single-finger path: touch-down at `from`, optional hold, move to `to`, lift. A tap is from==to.
+- (BOOL)injectPathFrom:(CGPoint)from to:(CGPoint)to hold:(double)hold move:(double)move name:(NSString *)name {
+    id synth = [self synthesizer]; if (!synth) return NO;
+    Class pathC = NSClassFromString(@"XCPointerEventPath");
+    Class recC = NSClassFromString(@"XCSynthesizedEventRecord");
+    if (!pathC || !recC) return NO;
+    XCPointerEventPath *path = [[pathC alloc] initForTouchAtPoint:from offset:0.0];
+    double t = 0.0;
+    if (hold > 0)  { [path moveToPoint:from atOffset:(t += hold)]; }
+    if (!CGPointEqualToPoint(from, to)) { [path moveToPoint:to atOffset:(t += MAX(move, 0.01))]; }
+    else { t += 0.05; }
+    [path liftUpAtOffset:t];
+    XCSynthesizedEventRecord *rec = [[recC alloc] initWithName:name interfaceOrientation:kPortrait];
+    [rec addPointerEventPath:path];
+    __block BOOL ok = NO;
+    BOOL fired = MSAwait(t + 5.0, ^(dispatch_semaphore_t sem) {
+        [synth synthesizeEvent:rec completion:^(BOOL result, NSError *error) { ok = (error == nil); dispatch_semaphore_signal(sem); }];
+    });
+    return fired && ok;
+}
+- (BOOL)tapAt:(CGPoint)p { return [self injectPathFrom:p to:p hold:0 move:0 name:@"tap"]; }
+- (BOOL)longPressAt:(CGPoint)p duration:(double)dur { return [self injectPathFrom:p to:p hold:dur move:0 name:@"longpress"]; }
+- (BOOL)swipeFrom:(CGPoint)f to:(CGPoint)t duration:(double)dur { return [self injectPathFrom:f to:t hold:0 move:dur name:@"swipe"]; }
+- (BOOL)dragFrom:(CGPoint)f to:(CGPoint)t duration:(double)dur { return [self injectPathFrom:f to:t hold:0.5 move:dur name:@"drag"]; }
+@end
+
+// LEGACY — XCEventGenerator (iOS 14).
+@interface MSLegacyInjector : NSObject <MSGestureInjector>
+@end
+@implementation MSLegacyInjector
+- (NSString *)name { return @"LEGACY_HID"; }
+- (nullable XCEventGenerator *)gen {
+    Class cls = NSClassFromString(@"XCEventGenerator");
+    if (!cls) return nil;
+    @try { return [cls sharedGenerator]; } @catch (NSException *e) { return nil; }
+}
+- (BOOL)available { return [self gen] != nil; }
+- (BOOL)tapAt:(CGPoint)p {
+    XCEventGenerator *g = [self gen]; if (!g) return NO;
+    return MSAwait(5.0, ^(dispatch_semaphore_t sem) {
+        [g pressAtPoint:p forDuration:0.0 liftAtPoint:p velocity:0 orientation:kPortrait name:@"tap" handler:^(id r, NSError *e) { dispatch_semaphore_signal(sem); }];
+    });
+}
+- (BOOL)longPressAt:(CGPoint)p duration:(double)dur {
+    XCEventGenerator *g = [self gen]; if (!g) return NO;
+    return MSAwait(dur + 5.0, ^(dispatch_semaphore_t sem) {
+        [g pressAtPoint:p forDuration:dur orientation:kPortrait handler:^(id r, NSError *e) { dispatch_semaphore_signal(sem); }];
+    });
+}
+- (BOOL)swipeFrom:(CGPoint)f to:(CGPoint)t duration:(double)dur { return [self dragFrom:f to:t duration:dur press:0.0]; }
+- (BOOL)dragFrom:(CGPoint)f to:(CGPoint)t duration:(double)dur { return [self dragFrom:f to:t duration:dur press:0.5]; }
+- (BOOL)dragFrom:(CGPoint)f to:(CGPoint)t duration:(double)dur press:(double)press {
+    XCEventGenerator *g = [self gen]; if (!g) return NO;
+    double vel = hypot(t.x - f.x, t.y - f.y) / MAX(dur, 0.05);
+    return MSAwait(dur + press + 5.0, ^(dispatch_semaphore_t sem) {
+        [g pressAtPoint:f forDuration:press liftAtPoint:t velocity:vel orientation:kPortrait name:@"swipe" handler:^(id r, NSError *e) { dispatch_semaphore_signal(sem); }];
+    });
+}
+@end
+
+// ---- Facade: try MODERN then LEGACY; return the name that ran (or nil → caller uses XCUICoordinate) --
+
+@implementation MSHID
+
++ (NSArray<id<MSGestureInjector>> *)chain {
+    static NSArray *chain; static dispatch_once_t once;
+    dispatch_once(&once, ^{ chain = @[[MSModernInjector new], [MSLegacyInjector new]]; });
+    return chain;
+}
+
++ (BOOL)available {
+    for (id<MSGestureInjector> inj in [self chain]) { if ([inj available]) return YES; }
+    return NO;
+}
+
++ (nullable NSString *)run:(BOOL (^)(id<MSGestureInjector> inj))op {
+    for (id<MSGestureInjector> inj in [self chain]) {
+        if (![inj available]) continue;
+        if (op(inj)) return [inj name];
+    }
+    return nil;
+}
+
++ (nullable NSString *)tapAt:(CGPoint)p { return [self run:^BOOL(id<MSGestureInjector> i) { return [i tapAt:p]; }]; }
++ (nullable NSString *)longPressAt:(CGPoint)p duration:(double)d { return [self run:^BOOL(id<MSGestureInjector> i) { return [i longPressAt:p duration:d]; }]; }
++ (nullable NSString *)swipeFrom:(CGPoint)f to:(CGPoint)t duration:(double)d { return [self run:^BOOL(id<MSGestureInjector> i) { return [i swipeFrom:f to:t duration:d]; }]; }
++ (nullable NSString *)dragFrom:(CGPoint)f to:(CGPoint)t duration:(double)d { return [self run:^BOOL(id<MSGestureInjector> i) { return [i dragFrom:f to:t duration:d]; }]; }
+
+@end

package/resources/ios/MobileSemantic/UITests/MobileSemanticUITests-Bridging.h

@@ -0,0 +1,2 @@
+// Swift ↔ ObjC bridging header for the UITests target: exposes MSHID (HID gesture injection) to Swift.
+#import "MSHID.h"

package/resources/ios/MobileSemantic/UITests/XcuiSnapshot.swift

@@ -41,9 +41,23 @@ enum Xcui {
     static func toScreenSnapshot(_ root: XCUIElementSnapshot, bundleId: String, deviceId: String) -> [String: Any] {
         var nodes: [[String: Any]] = []
         var counter = 0
-        func walk(_ el: XCUIElementSnapshot, parentId: String?) {
-            let id = "n\(counter)"; counter += 1
+        var truncated = false
+        // PERF (C): bound the tree on heavy apps (a TikTok/feed hierarchy is huge and slow to serialize on
+        // a 2GB device). Cap depth + total nodes; env-overridable. Truncation is reported, never silent.
+        let env = ProcessInfo.processInfo.environment
+        let maxDepth = Int(env["MSM_IOS_MAX_DEPTH"] ?? "") ?? 60
+        let maxNodes = Int(env["MSM_IOS_MAX_NODES"] ?? "") ?? 3000
+        func walk(_ el: XCUIElementSnapshot, parentId: String?, depth: Int) {
+            if nodes.count >= maxNodes || depth > maxDepth { truncated = true; return }
             let f = el.frame
+            // PERF: drop zero-area layout artifacts (they cannot be seen or tapped), but keep descending so
+            // any visible children still surface — this trims the tree on dense apps without losing a
+            // real target. The child keeps the current parentId so the hierarchy stays connected.
+            if f.width <= 0 || f.height <= 0 {
+                for c in el.children { walk(c, parentId: parentId, depth: depth + 1) }
+                return
+            }
+            let id = "n\(counter)"; counter += 1
             var node: [String: Any] = [
                 "nodeId": id,
                 "role": role(for: el.elementType),
@@ -58,9 +72,9 @@ enum Xcui {
             let isSecure = el.elementType == .secureTextField
             node["state"] = ["enabled": el.isEnabled, "selected": el.isSelected, "password": isSecure]
             nodes.append(node)
-            for c in el.children { walk(c, parentId: id) }
+            for c in el.children { walk(c, parentId: id, depth: depth + 1) }
         }
-        walk(root, parentId: nil)
+        walk(root, parentId: nil, depth: 0)
         let th = treeHash(nodes)
         return [
             "schemaVersion": 1, "platform": "IOS", "deviceId": deviceId,
@@ -68,6 +82,7 @@ enum Xcui {
             "timestamp": ISO8601DateFormatter().string(from: Date()),
             "packageName": bundleId, "appId": bundleId, "windowId": 0, "orientation": "portrait",
             "screenStateId": "ios:\(th.prefix(4))", "compact": true, "nodes": nodes, "treeHash": th,
+            "truncated": truncated,
         ]
     }
 }

package/resources/ios/MobileSemantic/gen_project.rb

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
-# Generate MobileSemantic.xcodeproj (fixture app + UI-test bundle) via the xcodeproj gem — no Xcode
-# GUI, no xcodegen. Simulator build, no signing. Run: `ruby gen_project.rb`.
+# Generate MobileSemantic.xcodeproj — ONE target: the standalone MobileSemanticUITests UI-test bundle
+# (WebDriverAgent style: no host application). The bundle's BridgeServer IS the device driver; it drives
+# arbitrary apps via XCUIApplication(bundleIdentifier:), so it needs no fixture/host app of its own.
+# No Xcode GUI, no xcodegen. Run: `ruby gen_project.rb`.
 require 'xcodeproj'
 
 here = File.dirname(File.expand_path(__FILE__))
@@ -12,22 +14,17 @@ DEPLOY = '14.0'
 # with this development team. Override with MSM_DEV_TEAM to use a different Apple account.
 DEV_TEAM = ENV['MSM_DEV_TEAM'] || 'A2KNU2X4F7'
 
-# --- fixture app target ------------------------------------------------------
-app = proj.new_target(:application, 'MobileSemanticFixture', :ios, DEPLOY)
-app_group = proj.new_group('Fixture', 'Fixture')
-Dir.glob(File.join(here, 'Fixture', '*.swift')).sort.each do |f|
-  ref = app_group.new_file(f)
-  app.source_build_phase.add_file_reference(ref)
-end
-
-# --- UI-test bundle target ---------------------------------------------------
+# --- UI-test bundle target (the ONLY target: the driver) ---------------------
+# A target-less ui_test_bundle: xcodebuild auto-generates the MobileSemanticUITests-Runner host app,
+# exactly like WebDriverAgent. No TEST_TARGET_NAME / no app dependency, so there is no second app to
+# install or confuse with the driver.
 uitest = proj.new_target(:ui_test_bundle, 'MobileSemanticUITests', :ios, DEPLOY)
 ui_group = proj.new_group('UITests', 'UITests')
-Dir.glob(File.join(here, 'UITests', '*.swift')).sort.each do |f|
+# Swift sources + the ObjC HID shim (MSHID.m). A bridging header (set below) exposes MSHID to Swift.
+Dir.glob(File.join(here, 'UITests', '*.{swift,m}')).sort.each do |f|
   ref = ui_group.new_file(f)
   uitest.source_build_phase.add_file_reference(ref)
 end
-uitest.add_dependency(app)
 
 # --- build settings ----------------------------------------------------------
 common = {
@@ -43,16 +40,13 @@ common = {
   'MARKETING_VERSION' => '1.0',
   'ALWAYS_SEARCH_USER_PATHS' => 'NO',
 }
-app.build_configurations.each do |c|
-  c.build_settings.merge!(common)
-  c.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'com.msm.MobileSemanticFixture'
-  c.build_settings['INFOPLIST_KEY_UILaunchScreen_Generation'] = 'YES'
-  c.build_settings['INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents'] = 'YES'
-end
 uitest.build_configurations.each do |c|
   c.build_settings.merge!(common)
   c.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'com.msm.MobileSemanticUITests'
-  c.build_settings['TEST_TARGET_NAME'] = 'MobileSemanticFixture'
+  # Bridging header so Swift can call the ObjC HID shim (MSHID); enable ObjC modules.
+  c.build_settings['SWIFT_OBJC_BRIDGING_HEADER'] = 'UITests/MobileSemanticUITests-Bridging.h'
+  c.build_settings['CLANG_ENABLE_MODULES'] = 'YES'
+  c.build_settings['SWIFT_INSTALL_OBJC_HEADER'] = 'NO'
 end
 
 # --- shared scheme so `xcodebuild -scheme MobileSemanticUITests test` works ---
@@ -61,7 +55,6 @@ proj.save
 scheme = Xcodeproj::XCScheme.new
 scheme.add_build_target(uitest)
 scheme.add_test_target(uitest)
-scheme.set_launch_target(app)
 scheme.save_as(proj_path, 'MobileSemanticUITests', true)
 
-puts "generated #{proj_path}"
+puts "generated #{proj_path} (standalone UITests-Runner, no fixture app)"

package/resources/ios/MobileSemantic/Fixture/MobileSemanticFixtureApp.swift

@@ -1,50 +0,0 @@
-import SwiftUI
-
-// Deterministic fixture app under test. Deployment target 14.0 so the same binary runs on the
-// physical iPhone 7 Plus (iOS 14.2) later. Elements carry stable accessibilityIdentifiers so the
-// TS resolver can locate by automationId; two same-labelled "Continue" buttons give a controlled
-// AMBIGUOUS_MATCH case; signing in flips to a "welcome" screen for wait/diff.
-@main
-struct MobileSemanticFixtureApp: App {
-    var body: some Scene {
-        WindowGroup { ContentView() }
-    }
-}
-
-struct ContentView: View {
-    @State private var username = ""
-    @State private var signedIn = false
-    @State private var playing = false
-
-    var body: some View {
-        if signedIn {
-            VStack(spacing: 16) {
-                Text("Welcome")
-                    .accessibilityIdentifier("welcome")
-                // A plain Button whose OWN title flips on tap — a reliable XCUI hit target (unlike a
-                // SwiftUI switch), giving a deterministic NODE_STATE_CHANGED postcondition.
-                Button(playing ? "Pause" : "Play") { playing.toggle() }
-                    .accessibilityIdentifier("playPause")
-                Button("Sign Out") { signedIn = false }
-                    .accessibilityIdentifier("signOut")
-            }
-            .padding()
-        } else {
-            VStack(spacing: 16) {
-                Text("Sign In").font(.title)
-                TextField("Username", text: $username)
-                    .accessibilityIdentifier("username")
-                    .textFieldStyle(.roundedBorder)
-                Button("Sign In") { signedIn = true }
-                    .accessibilityIdentifier("signIn")
-                // Two buttons with the SAME visible label "Continue" -> ambiguity when a NodeRef
-                // relies on ROLE_LABEL alone; distinct identifiers let a stronger locator disambiguate.
-                HStack(spacing: 24) {
-                    Button("Continue") {}.accessibilityIdentifier("continuePrimary")
-                    Button("Continue") {}.accessibilityIdentifier("continueSecondary")
-                }
-            }
-            .padding()
-        }
-    }
-}