react-native-acoustic-connect-beta 19.1.4 → 19.1.6

package/AcousticConnectRN.podspec

@@ -148,6 +148,7 @@ Pod::Spec.new do |s|
     ts.source_files = [
       'ios/Tests/**/*.swift',
       'ios/ConnectRNParsing.swift',
+      'ios/ConnectRNScreenResolution.swift',
       'nitrogen/generated/ios/swift/Variant_Bool_String_Double.swift',
     ]
     # ios/ConnectRNParsing.swift does `import Connect`. CocoaPods test_specs

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 19.1.6 (2026-10-01)
+
+### Reverts
+
+* Revert "Beta ReactNativeConnect build: 18.0.36" ([609ad7d](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/commit/609ad7d3244ec06f27dced5864d40585c5b3c9cf))
+## 19.1.5 (2026-10-01)
+
+### Reverts
+
+* Revert "Beta ReactNativeConnect build: 18.0.36" ([609ad7d](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/commit/609ad7d3244ec06f27dced5864d40585c5b3c9cf))
 ## 19.1.4 (2026-09-30)
 
 ### Reverts

package/README.md

@@ -106,7 +106,7 @@ Field summary (see [API reference](#api-reference) for full semantics):
 | `AppKey` | _(required)_ | Your Connect application key. |
 | `PostMessageUrl` | _(required)_ | Collector endpoint URL. |
 | `KillSwitchUrl` | _(optional)_ | Kill-switch endpoint URL. |
-| `useRelease` | `false` | `true` selects the release AcousticConnect iOS pod over the debug variant. |
+| `useRelease` | `false` | Release vs. beta native SDKs. iOS: `true` selects the release AcousticConnect pod over the debug variant. Android: `false` resolves Connect from the GitHub-hosted beta Maven repository (betas are not published to Maven Central); `true` resolves from Maven Central only and rejects beta versions. If your `settings.gradle` sets `repositoriesMode` to `PREFER_SETTINGS`, project repositories are ignored, so add the beta repository there yourself — the build prints the exact entry. |
 | `iOSVersion` | `""` | Pin a specific iOS pod version; empty = newest in the supported range. |
 | `AndroidVersion` | `""` | Pin a specific Android Connect SDK version; empty = newest in the supported range. |
 | `PushEnabled` | `false` | Master switch. On Android, also gates the `connect-push-fcm` artifact inclusion. |

package/android/build.gradle

@@ -165,6 +165,46 @@ android {
   }
 }
 
+// Read consumer config at script-evaluation time so the right Connect Android
+// artifact is selected without depending on config.gradle's text-rewriting
+// pass (which only matches the analytics artifact name). Read first, because
+// the repositories below depend on it:
+//   - `PushEnabled` picks between the analytics-only and push-fcm artifacts.
+//   - `AndroidVersion` (when set) pins the version against the active artifact.
+//   - `useRelease` picks where Connect comes from (see `allprojects` below).
+import groovy.json.JsonSlurper
+def acousticConfigFile = new File("$rootDir/../ConnectConfig.json")
+def acousticConfig = acousticConfigFile.exists()
+  ? new JsonSlurper().parse(acousticConfigFile)
+  : [Connect: [:]]
+def acousticPushEnabled = (acousticConfig.Connect?.PushEnabled ?: false).toString().toBoolean()
+def acousticUseRelease = (acousticConfig.Connect?.useRelease ?: false).toString().toBoolean()
+def acousticVersionPin = (acousticConfig.Connect?.AndroidVersion ?: '').trim()
+def acousticVersion = acousticVersionPin.isEmpty() ? '+' : acousticVersionPin
+def acousticArtifact = acousticPushEnabled ? 'connect-push-fcm' : 'connect'
+
+println "AcousticConnectRN: PushEnabled=$acousticPushEnabled, useRelease=$acousticUseRelease, artifact=io.github.go-acoustic:$acousticArtifact:$acousticVersion"
+
+// The supported Connect Android range — the same bounds as the `strictly`
+// constraints below. Checked up front because the constraint cannot reject a
+// pin on its own: a strict range is itself a request for the newest version in
+// range, so an out-of-range pin was silently replaced by that version.
+def acousticMinVersion = [11, 0, 11]
+def acousticMaxVersionExclusive = [12, 0, 0]
+def acousticSupportedRange = "[${acousticMinVersion.join('.')}, ${acousticMaxVersionExclusive.join('.')})"
+if (!acousticVersionPin.isEmpty()) {
+  def m = acousticVersionPin =~ /^(\d+)\.(\d+)\.(\d+)/
+  def compare = { a, b -> [a, b].transpose().collect { x, y -> x <=> y }.find { it != 0 } ?: 0 }
+  def parts = m.find() ? [m.group(1), m.group(2), m.group(3)].collect { it as int } : null
+  if (parts == null || compare(parts, acousticMinVersion) < 0 || compare(parts, acousticMaxVersionExclusive) >= 0) {
+    throw new GradleException(
+      "AcousticConnectRN: ConnectConfig.json Connect.AndroidVersion '$acousticVersionPin' is outside the " +
+      "supported Connect Android range $acousticSupportedRange. " +
+      "Set a version in that range, or leave it empty to use the newest."
+    )
+  }
+}
+
 repositories {
   mavenCentral()
   google()
@@ -174,36 +214,33 @@ allprojects {
     repositories {
         google()
 
-        // Beta Connect artifacts publish HERE, not to Maven Central. Central is
-        // still consulted below — it carries every version up to 11.0.31-beta —
-        // but newer betas land only in this GitHub-hosted Maven tree, so a build
-        // that does not know about it silently freezes `connect:+` at whatever
-        // Central happens to hold. That failure is invisible: resolution
-        // succeeds, just against a stale SDK, and the gap widens with each beta.
+        // `useRelease` decides where Connect comes from, for this module AND —
+        // via config.gradle, which declares the same switch in the consuming
+        // app — for the APK. The two must agree: this module compiles against
+        // whatever it resolves here, while the app packages what the app
+        // resolves, and a bridge compiled against a newer Connect than the APK
+        // carries fails at runtime with NoSuchMethodError, not at build time.
         //
-        // Declaring it is what fixes that; the position is close to cosmetic.
-        // `connect` is resolved through a dynamic version, and for those Gradle
-        // queries every declared repository and takes the newest match across
-        // all of them rather than stopping at the first repository that answers.
-        // Verified: with this entry declared LAST, after mavenCentral(),
-        // `connect:+` still resolves to the newest beta here rather than to
-        // Central's older newest. Order only decides which repository serves a
-        // PINNED version that both carry, where the artifact is identical
-        // anyway — it is kept first so a pin on a beta is served by the tree
-        // that is authoritative for betas.
+        //   useRelease: false (default) — the GitHub-hosted Maven tree, where
+        //     Connect betas publish (they do not reach Maven Central). Central
+        //     is still consulted for versions this tree does not carry.
+        //   useRelease: true — Maven Central only, betas rejected below.
         //
-        // The content filter is not cosmetic. Without it every dependency in
-        // the build (React Native, Kotlin, AndroidX, …) would hit
-        // raw.githubusercontent and 404 before falling through to a repository
-        // that has it. Inclusive `content`, not `exclusiveContent`, so Central
-        // still answers for versions this tree does not carry.
+        // `connect` resolves through a dynamic version, so Gradle queries
+        // every declared repository and takes the newest match across all of
+        // them; position only matters for a pinned version both carry, where
+        // the artifact is identical. The content filter is not cosmetic:
+        // without it every dependency in the build would hit
+        // raw.githubusercontent and 404 before falling through.
         //
         // Declared only here, not also in the top-level `repositories` block:
         // `allprojects` covers this project too, so both would feed the same
         // resolution and the pair could drift.
-        maven {
-            url = "https://raw.githubusercontent.com/go-acoustic/Android_Maven/master"
-            content { includeGroup "io.github.go-acoustic" }
+        if (!acousticUseRelease) {
+            maven {
+                url = "https://raw.githubusercontent.com/go-acoustic/Android_Maven/master"
+                content { includeGroup "io.github.go-acoustic" }
+            }
         }
 
         mavenCentral()
@@ -216,23 +253,22 @@ allprojects {
     }
 }
 
-// Read consumer config at script-evaluation time so the right Connect Android
-// artifact is selected without depending on config.gradle's text-rewriting
-// pass (which only matches the analytics artifact name). Both `PushEnabled`
-// and `AndroidVersion` are read directly here:
-//   - `PushEnabled` picks between the analytics-only and push-fcm artifacts.
-//   - `AndroidVersion` (when set) pins the version against the active artifact.
-import groovy.json.JsonSlurper
-def acousticConfigFile = new File("$rootDir/../ConnectConfig.json")
-def acousticConfig = acousticConfigFile.exists()
-  ? new JsonSlurper().parse(acousticConfigFile)
-  : [Connect: [:]]
-def acousticPushEnabled = (acousticConfig.Connect?.PushEnabled ?: false).toString().toBoolean()
-def acousticVersionPin = (acousticConfig.Connect?.AndroidVersion ?: '').trim()
-def acousticVersion = acousticVersionPin.isEmpty() ? '+' : acousticVersionPin
-def acousticArtifact = acousticPushEnabled ? 'connect-push-fcm' : 'connect'
-
-println "AcousticConnectRN: PushEnabled=$acousticPushEnabled, artifact=io.github.go-acoustic:$acousticArtifact:$acousticVersion"
+// Same beta rejection config.gradle applies to the app, so with
+// `useRelease: true` this module cannot compile against a beta either — a
+// beta reached through the Sonatype staging repo or an `AndroidVersion` pin
+// fails resolution here instead of diverging from the APK. eocore is exempt:
+// its release line carries a `-beta` suffix (see config.gradle).
+if (acousticUseRelease) {
+  configurations.all {
+    resolutionStrategy.componentSelection.all { selection ->
+      if (selection.candidate.group == 'io.github.go-acoustic' &&
+          selection.candidate.module != 'eocore' &&
+          selection.candidate.version.endsWith('-beta')) {
+        selection.reject("useRelease is true — rejecting beta version ${selection.candidate.version}")
+      }
+    }
+  }
+}
 
 dependencies {
   // Provided by the host app at runtime — compileOnly avoids version conflicts
@@ -284,18 +320,33 @@ dependencies {
   // to releases that lack APIs this bridge calls; upper bound prevents a
   // future 12.x major (with potentially breaking changes) from being picked
   // up automatically by Gradle's `+` resolver. Both halves are `strictly` so
-  // an attempted override via `Connect.AndroidVersion` fails loudly at
-  // resolution time rather than surfacing as a runtime `ClassNotFoundException`
-  // or method-missing error. Constraints are declared for both artifact
+  // nothing else in the build can move Connect outside them. A
+  // `Connect.AndroidVersion` outside the range fails at configuration time
+  // (the check after the config read above), not here. Constraints are declared for both artifact
   // names — Gradle only enforces the one that resolves into the graph, so
   // the unused entry is inert.
+  //
+  // An `AndroidVersion` pin is applied to BOTH constraints as `prefer`. With
+  // push enabled the only direct dependency is `connect-push-fcm`, so the pin
+  // used to reach `connect` only through that artifact's POM — and a strict
+  // range is itself a request that resolves to the newest version in range,
+  // so it outranked the transitive pin and floated `connect` past it
+  // (`connect-push-fcm:11.1.5-beta` shipped with `connect:11.1.6-beta`).
+  // `prefer` inside the strict range keeps the range as the hard bound and
+  // makes the pin the version chosen within it.
   constraints {
     implementation('io.github.go-acoustic:connect') {
-      version { strictly '[11.0.11, 12.0.0)' }
+      version {
+        strictly acousticSupportedRange
+        if (!acousticVersionPin.isEmpty()) { prefer acousticVersionPin }
+      }
       because 'AcousticConnectRN requires Connect Android SDK in [11.0.11, 12.0.0). Bump the upper bound after validating compatibility with a new major.'
     }
     implementation('io.github.go-acoustic:connect-push-fcm') {
-      version { strictly '[11.0.11, 12.0.0)' }
+      version {
+        strictly acousticSupportedRange
+        if (!acousticVersionPin.isEmpty()) { prefer acousticVersionPin }
+      }
       because 'connect-push-fcm tracks the same release line as the core connect artifact.'
     }
   }

package/android/config.gradle

@@ -425,13 +425,100 @@ def updateEOCoreAdvConfig(mp, json) {
     println("Updating:$eocoreAdvConfigPath")
 }
 
+// With `useRelease: false`, the app has to resolve Connect from the beta tree
+// too. The SDK module's android/build.gradle declares it for the module's own
+// classpath, but the APK packages what *this* project — the app — resolves,
+// and an app that cannot see the tree silently gets Central's newest release
+// instead: a different Connect from the one the bridge was compiled against,
+// which fails at runtime with NoSuchMethodError. This script is applied from
+// the app's build.gradle, so the repository declared here is the app's.
+//
+// Apps that centralise repositories in settings.gradle cannot take a project
+// repository: FAIL_ON_PROJECT_REPOS fails the build on one, PREFER_SETTINGS
+// ignores it — for every project, the SDK module included, so the two still
+// agree (on Central). For those, say what to add rather than fail or stay silent.
+def addBetaRepository(proj) {
+    // The GitHub-hosted Maven tree Connect betas publish to. They do not reach
+    // Maven Central, which carries release versions only. Local to the method:
+    // a script-level `def` is not visible inside script methods.
+    def ACOUSTIC_BETA_REPO_URL = "https://raw.githubusercontent.com/go-acoustic/Android_Maven/master"
+    def mode = null
+    def inSettings = false
+    try {
+        def drm = proj.gradle.settings.dependencyResolutionManagement
+        mode = drm.repositoriesMode.get().toString()
+        inSettings = drm.repositories.any { repo ->
+            repo.hasProperty('url') && repo.url.toString().startsWith(ACOUSTIC_BETA_REPO_URL)
+        }
+    } catch (Throwable ignored) {
+        // Older Gradle, or no settings-level repository management: nothing to respect.
+    }
+    if (inSettings) {
+        println("AcousticConnect: useRelease is false — Connect beta repository already declared in settings.gradle")
+        return
+    }
+    if (mode == "FAIL_ON_PROJECT_REPOS" || mode == "PREFER_SETTINGS") {
+        println("WARNING: AcousticConnect: useRelease is false, but settings.gradle sets repositoriesMode " +
+            "$mode, so the Connect beta repository cannot be added to the app. Add it to " +
+            "dependencyResolutionManagement.repositories in settings.gradle:\n" +
+            "    maven {\n" +
+            "        url = \"$ACOUSTIC_BETA_REPO_URL\"\n" +
+            "        content { includeGroup \"io.github.go-acoustic\" }\n" +
+            "    }\n" +
+            "Without it Connect resolves from Maven Central only — for the app and this SDK alike, since " +
+            "settings repositories replace project ones — so betas are not used. Or set useRelease to " +
+            "true to make that explicit.")
+        return
+    }
+    proj.repositories {
+        maven {
+            url = ACOUSTIC_BETA_REPO_URL
+            content { includeGroup "io.github.go-acoustic" }
+        }
+    }
+    println("AcousticConnect: useRelease is false — resolving Connect from $ACOUSTIC_BETA_REPO_URL")
+}
+
+// With `useRelease: true`, reject every go-acoustic beta in the app's resolution.
+// android/build.gradle applies the same rule to the SDK module.
+def rejectBetaVersions(proj) {
+    proj.configurations.all {
+        resolutionStrategy {
+            componentSelection {
+                all { selection ->
+                    // Exempt the eocore artifact from beta rejection.
+                    // Full Maven coordinate: io.github.go-acoustic:eocore
+                    // (verified on Maven Central — the POM declares
+                    // <groupId>io.github.go-acoustic</groupId> +
+                    // <artifactId>eocore</artifactId>, so candidate.module is
+                    // literally 'eocore').
+                    // Unlike the other go-acoustic artifacts, eocore's RELEASE
+                    // line carries a `-beta` suffix — Maven Central lists
+                    // 2.1.24-beta as <release>/<latest>, and the release
+                    // connect:11.0.13 → tealeaf:10.4.28 chain pins eocore
+                    // transitively to that version. Without this carve-out the
+                    // blanket `-beta` reject would drop a legitimate release
+                    // artifact and break every useRelease=true build.
+                    if (selection.candidate.group == 'io.github.go-acoustic' &&
+                        selection.candidate.module != 'eocore' &&
+                        selection.candidate.version.endsWith('-beta')) {
+                        selection.reject("useRelease is true — rejecting beta version ${selection.candidate.version}")
+                    }
+                }
+            }
+        }
+    }
+}
+
 def updateGradle(mp, json){
     def buildGradlePath = "$mp/build.gradle"
     def buildGradleFile = new File(buildGradlePath)
     def updatedBuildGradle = buildGradleFile.text
 
     if (json != null && json.Connect) {
-        def useRelease = json.Connect.useRelease ?: false
+        // Parsed as android/build.gradle parses it, so the module and the app agree on
+        // the value even when it is written as a string ("false" is truthy in Groovy).
+        def useRelease = (json.Connect.useRelease ?: false).toString().toBoolean()
 
         if(json.Connect.AndroidVersion != null) {
             def connectSDK = "io.github.go-acoustic:connect:"
@@ -443,33 +530,11 @@ def updateGradle(mp, json){
             updatedBuildGradle = updatedBuildGradle.replaceAll(~/io.github.go-acoustic:connect:(\+|\d+\.\d+\.\d+(-beta)?)/, connectSDK)
         }
 
+        // Exactly one of the two per build: release-only resolution, or the beta tree.
         if (useRelease) {
-            project.configurations.all {
-                resolutionStrategy {
-                    componentSelection {
-                        all { selection ->
-                            // Exempt the eocore artifact from beta rejection.
-                            // Full Maven coordinate: io.github.go-acoustic:eocore
-                            // (verified on Maven Central — the POM declares
-                            // <groupId>io.github.go-acoustic</groupId> +
-                            // <artifactId>eocore</artifactId>, so candidate.module is
-                            // literally 'eocore').
-                            // Unlike the other go-acoustic artifacts, eocore's RELEASE
-                            // line carries a `-beta` suffix — Maven Central lists
-                            // 2.1.24-beta as <release>/<latest>, and the release
-                            // connect:11.0.13 → tealeaf:10.4.28 chain pins eocore
-                            // transitively to that version. Without this carve-out the
-                            // blanket `-beta` reject would drop a legitimate release
-                            // artifact and break every useRelease=true build.
-                            if (selection.candidate.group == 'io.github.go-acoustic' &&
-                                selection.candidate.module != 'eocore' &&
-                                selection.candidate.version.endsWith('-beta')) {
-                                selection.reject("useRelease is true — rejecting beta version ${selection.candidate.version}")
-                            }
-                        }
-                    }
-                }
-            }
+            rejectBetaVersions(project)
+        } else {
+            addBetaRepository(project)
         }
     }
 

package/android/src/main/assets/ConnectBasicConfig.properties

@@ -1,4 +1,4 @@
-#Wed Sep 30 13:22:22 GMT 2026
+#Thu Oct 01 15:10:29 GMT 2026
 UseWhiteList=true
 PrintScreen=3
 UseRandomSample=false

package/ios/ConnectRNScreenResolution.swift

@@ -0,0 +1,116 @@
+//
+// Copyright (C) 2026 Acoustic, L.P. All rights reserved.
+//
+// NOTICE: This file contains material that is confidential and proprietary to
+// Acoustic, L.P. and/or other developers. No license is granted under any
+// intellectual or industrial property rights of Acoustic, L.P. except as may
+// be provided in an agreement with Acoustic, L.P. Any unauthorized copying or
+// distribution of content from this file is prohibited.
+//
+
+import UIKit
+
+/// Walks from a window's root view controller down to the screen a layout
+/// capture should describe.
+///
+/// Split out of `HybridAcousticConnectRN` so the walk can be unit-tested
+/// without a window, and compiled into the UnitTests bundle (see the
+/// podspec's test_spec for why the pod module itself cannot be imported).
+///
+/// Must be called on the main thread.
+enum ConnectRNScreenResolution {
+
+    /// The view controller that is actually showing under `root`.
+    ///
+    /// Walks the `presentedViewController` chain, unwraps navigation and tab
+    /// controllers to the child on screen, and descends into
+    /// react-native-screens' controllers (see `activeScreen(in:)`).
+    ///
+    /// The react-native-screens step is what makes a capture name the same
+    /// controller the SDK records for the screen. Those controllers are plain
+    /// child view controllers of React Native's root, not navigation or tab
+    /// containers, so without it the walk stopped at the root. The SDK, which
+    /// records the `RNSScreen` from its `viewDidAppear`, then saw a capture of
+    /// some other controller and posted a second LOAD for a screen already on
+    /// display, naming itself as its referrer.
+    ///
+    /// - Parameter root: The window's root view controller.
+    /// - Returns: The view controller to capture, or `nil` when `root` is nil.
+    static func topViewController(from root: UIViewController?) -> UIViewController? {
+        var top = root
+        // Bounded rather than an open `while`. In practice the chain is a short
+        // linked list, but this runs on every navigation, so a pathological
+        // cycle must not hang the main thread.
+        var hops = 0
+        while hops < 32, let current = top {
+            hops += 1
+            // Presentation first: `presentedViewController` also reports a
+            // modal put up by a descendant, so checking it before unwrapping a
+            // container lands on the modal directly instead of on the
+            // container's child underneath it.
+            if let presented = current.presentedViewController {
+                top = presented
+                continue
+            }
+            if let nav = current as? UINavigationController,
+               let visible = nav.topViewController {
+                top = visible
+                continue
+            }
+            if let tabs = current as? UITabBarController,
+               let selected = tabs.selectedViewController {
+                top = selected
+                continue
+            }
+            if let screen = activeScreen(in: current) {
+                top = screen
+                continue
+            }
+            break
+        }
+        return top
+    }
+
+    /// The react-native-screens child of `viewController` that is showing, if
+    /// it has one.
+    ///
+    /// - A screen container (`RNSViewController`) is asked through its own
+    ///   `findActiveChildVC`, which react-native-screens also uses to route
+    ///   status-bar and orientation queries to the screen on top; during a
+    ///   transition several screens are attached and only it knows which one.
+    /// - Anything else descends into its last visible react-native-screens
+    ///   child: React Native's root holds the container that way, and a
+    ///   screen holds a nested native stack (`RNSNavigationController`) that way.
+    ///
+    /// Only react-native-screens controllers are descended into, recognised by
+    /// the class-name prefix the SDK itself matches on (`isRNSScreen:`), so an
+    /// app that embeds React Native next to its own child controllers keeps
+    /// the controller it had before.
+    ///
+    /// - Parameter viewController: The controller the walk has reached.
+    /// - Returns: The child to continue from, or `nil` to stop at `viewController`.
+    static func activeScreen(in viewController: UIViewController) -> UIViewController? {
+        if isScreensController(viewController), let active = findActiveChild(of: viewController) {
+            return active
+        }
+        return viewController.children.last { child in
+            isScreensController(child) && child.viewIfLoaded?.isHidden != true
+        }
+    }
+
+    /// Whether `viewController` belongs to react-native-screens.
+    static func isScreensController(_ viewController: UIViewController) -> Bool {
+        NSStringFromClass(type(of: viewController)).hasPrefix("RNS")
+    }
+
+    private static let findActiveChildSelector = NSSelectorFromString("findActiveChildVC")
+
+    private static func findActiveChild(of container: UIViewController) -> UIViewController? {
+        guard container.responds(to: findActiveChildSelector),
+              let active = container.perform(findActiveChildSelector)?.takeUnretainedValue() as? UIViewController,
+              active.parent === container else {
+            return nil
+        }
+        return active
+    }
+}

package/ios/HybridAcousticConnectRN.swift

@@ -790,6 +790,11 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
     ///   The framework only unwraps navigation controllers; capturing a tab
     ///   controller is not wrong (its view contains the selected child), but
     ///   the selected child is the screen the capture is named after.
+    /// - It descends into react-native-screens' controllers to the screen on
+    ///   top (`ConnectRNScreenResolution`). The framework records that
+    ///   `RNSScreen` as the current screen, and only a capture of the same
+    ///   controller adds a layout to its screen view instead of posting a
+    ///   second, self-referencing LOAD.
     ///
     /// Must be called on the main thread — see `captureScreenLayout`.
     private static func resolveTopViewController() -> UIViewController? {
@@ -810,34 +815,7 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
             return nil
         }
 
-        var top = window.rootViewController
-        // Bounded rather than an open `while`. In practice the chain is a short
-        // linked list, but this runs on every navigation, so a pathological
-        // cycle must not hang the main thread.
-        var hops = 0
-        while hops < 32 {
-            hops += 1
-            // Presentation first: `presentedViewController` also reports a
-            // modal put up by a descendant, so checking it before unwrapping a
-            // container lands on the modal directly instead of on the
-            // container's child underneath it.
-            if let presented = top?.presentedViewController {
-                top = presented
-                continue
-            }
-            if let nav = top as? UINavigationController,
-               let visible = nav.topViewController {
-                top = visible
-                continue
-            }
-            if let tabs = top as? UITabBarController,
-               let selected = tabs.selectedViewController {
-                top = selected
-                continue
-            }
-            break
-        }
-        return top
+        return ConnectRNScreenResolution.topViewController(from: window.rootViewController)
     }
 
     /// Resolves the top view controller and hands it to the framework, as one

package/package.json

@@ -228,7 +228,7 @@
     "source": "src/index",
     "summary": "react-native ios android tealeaf connect cxa wxca er enhanced-replay",
     "types": "./lib/typescript/src/index.d.ts",
-    "version": "19.1.4",
+    "version": "19.1.6",
     "workspaces": [
         "example",
         "Examples/bare-workflow"