@callstack/react-native-brownfield 5.3.0 → 6.0.1

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/utils/AndroidArchiveLibraryNamespaceFallbackTest.kt

@@ -0,0 +1,137 @@
+package com.callstack.react.brownfield.utils
+
+import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+class AndroidArchiveLibraryNamespaceFallbackTest {
+    private fun artifactFor(moduleName: String) =
+        UnresolvedArtifactInfo(
+            moduleGroup = "com.example",
+            moduleName = moduleName,
+            moduleVersion = "1.0.0",
+            file = null,
+            isExpoPublishDependency = false,
+        )
+
+    @Test
+    fun `falls back to the AndroidManifest package when build-gradle declares no namespace`() {
+        val root = ProjectBuilder.builder().build()
+        val subProject =
+            ProjectBuilder.builder()
+                .withParent(root)
+                .withName("react-native-launch-arguments")
+                .build()
+
+        // No `namespace` declaration, mirroring libraries whose build.gradle predates AGP namespaces.
+        subProject.projectDir.mkdirs()
+        subProject.buildFile.writeText(
+            """
+            apply plugin: 'com.android.library'
+            """.trimIndent(),
+        )
+        subProject.projectDir.resolve("src/main").mkdirs()
+        subProject.projectDir.resolve("src/main/AndroidManifest.xml").writeText(
+            """
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+                      package="com.reactnativelauncharguments">
+            </manifest>
+            """.trimIndent(),
+        )
+
+        val library = AndroidArchiveLibrary(root, artifactFor("react-native-launch-arguments"), "devRelease")
+
+        assertEquals("com.reactnativelauncharguments", library.getPackageName())
+    }
+
+    @Test
+    fun `prefers the namespace declared in build-gradle over the manifest package`() {
+        val root = ProjectBuilder.builder().build()
+        val subProject =
+            ProjectBuilder.builder()
+                .withParent(root)
+                .withName("react-native-screens")
+                .build()
+
+        subProject.projectDir.mkdirs()
+        subProject.buildFile.writeText(
+            """
+            apply plugin: 'com.android.library'
+            android {
+                namespace = "com.swmansion.rnscreens"
+            }
+            """.trimIndent(),
+        )
+        subProject.projectDir.resolve("src/main").mkdirs()
+        subProject.projectDir.resolve("src/main/AndroidManifest.xml").writeText(
+            """
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+                      package="com.swmansion.rnscreens.legacy">
+            </manifest>
+            """.trimIndent(),
+        )
+
+        val library = AndroidArchiveLibrary(root, artifactFor("react-native-screens"), "devRelease")
+
+        assertEquals("com.swmansion.rnscreens", library.getPackageName())
+    }
+
+    @Test
+    fun `reads the package from the manifest root element and ignores comments and child attributes`() {
+        val root = ProjectBuilder.builder().build()
+        val subProject =
+            ProjectBuilder.builder()
+                .withParent(root)
+                .withName("react-native-legacy-manifest")
+                .build()
+
+        subProject.projectDir.mkdirs()
+        subProject.buildFile.writeText(
+            """
+            apply plugin: 'com.android.library'
+            """.trimIndent(),
+        )
+        subProject.projectDir.resolve("src/main").mkdirs()
+        subProject.projectDir.resolve("src/main/AndroidManifest.xml").writeText(
+            """
+            <!-- legacy location: package="com.example.stale" -->
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+                      package="com.reactnativelegacymanifest">
+                <application>
+                    <activity
+                        android:name=".LegacyActivity"
+                        android:exported="false"
+                        android:targetPackage="com.example.target" />
+                </application>
+            </manifest>
+            """.trimIndent(),
+        )
+
+        val library = AndroidArchiveLibrary(root, artifactFor("react-native-legacy-manifest"), "devRelease")
+
+        assertEquals("com.reactnativelegacymanifest", library.getPackageName())
+    }
+
+    @Test
+    fun `errors when neither build-gradle nor the manifest declare a namespace`() {
+        val root = ProjectBuilder.builder().build()
+        val subProject =
+            ProjectBuilder.builder()
+                .withParent(root)
+                .withName("no-namespace-anywhere")
+                .build()
+
+        subProject.projectDir.mkdirs()
+        subProject.buildFile.writeText(
+            """
+            apply plugin: 'com.android.library'
+            """.trimIndent(),
+        )
+
+        val library = AndroidArchiveLibrary(root, artifactFor("no-namespace-anywhere"), "devRelease")
+
+        assertFailsWith<IllegalStateException> { library.getPackageName() }
+    }
+}

package/ios/BrownfieldDisplayMetrics.swift

@@ -0,0 +1,265 @@
+import UIKit
+
+/// Frame cadence, not CPU utilization. A missing sampler produces nil FPS/busyRatio.
+@objcMembers public final class BrownfieldThreadMetrics: NSObject {
+  public let fps: NSNumber?
+  public let busyRatio: NSNumber?
+  public let sampledMs: Double
+  public let frameCount: Int
+
+  internal init(fps: Double?, busyRatio: Double?, sampledMs: Double, frameCount: Int) {
+    self.fps = fps.map { NSNumber(value: $0) }
+    self.busyRatio = busyRatio.map { NSNumber(value: $0) }
+    self.sampledMs = sampledMs
+    self.frameCount = frameCount
+  }
+}
+
+@objcMembers public final class BrownfieldDisplayInterval: NSObject {
+  public let duration: Double
+  public let jsThread: BrownfieldThreadMetrics
+  public let uiThread: BrownfieldThreadMetrics
+
+  internal init(duration: Double, jsThread: BrownfieldThreadMetrics, uiThread: BrownfieldThreadMetrics) {
+    self.duration = duration
+    self.jsThread = jsThread
+    self.uiThread = uiThread
+  }
+}
+
+/// An immutable completed snapshot, delivered once through onMetrics.
+@objcMembers public final class BrownfieldDisplayMetrics: NSObject {
+  public let presentationID: String
+  public let moduleName: String
+  public let initialDisplay: BrownfieldDisplayInterval?
+  public let fullDisplay: BrownfieldDisplayInterval?
+  public let isFinal: Bool
+  public let isCancelled: Bool
+
+  internal init(presentationID: String, moduleName: String, initialDisplay: BrownfieldDisplayInterval?,
+                fullDisplay: BrownfieldDisplayInterval?, isFinal: Bool, isCancelled: Bool = false) {
+    self.presentationID = presentationID
+    self.moduleName = moduleName
+    self.initialDisplay = initialDisplay
+    self.fullDisplay = fullDisplay
+    self.isFinal = isFinal
+    self.isCancelled = isCancelled
+  }
+}
+
+/// Pure cadence accumulator, kept separate from run-loop and locking mechanics.
+internal struct BrownfieldFrameSamples {
+  var start: CFTimeInterval?
+  var last: CFTimeInterval = 0
+  var budget: CFTimeInterval = 1 / 60
+  var frames = 0
+  var busy: CFTimeInterval = 0
+
+  mutating func begin(at now: CFTimeInterval) {
+    start = now
+    last = now
+  }
+
+  mutating func record(at now: CFTimeInterval, frameInterval: CFTimeInterval) {
+    budget = max(frameInterval, 1 / 240)
+    busy += max(0, now - last - budget)
+    frames += 1
+    last = now
+  }
+
+  func snapshot(at now: CFTimeInterval) -> BrownfieldThreadMetrics {
+    guard let start, now > start else {
+      return BrownfieldThreadMetrics(fps: nil, busyRatio: nil, sampledMs: 0, frameCount: 0)
+    }
+    let elapsed = now - start
+    let blocked = busy + max(0, now - last - budget)
+    return BrownfieldThreadMetrics(fps: Double(frames) / elapsed,
+      busyRatio: min(1, blocked / elapsed), sampledMs: elapsed * 1000, frameCount: frames)
+  }
+}
+
+/// Lock protects the JS run-loop sampler from main-thread snapshots and cancellation.
+internal final class BrownfieldFrameSampler: NSObject {
+  private let lock = NSLock()
+  private var link: CADisplayLink?
+  private var stopped = false
+  private var samples = BrownfieldFrameSamples()
+
+  func startOnCurrentRunLoop() {
+    lock.lock()
+    defer { lock.unlock() }
+    guard !stopped, link == nil else { return }
+    samples.begin(at: CACurrentMediaTime())
+    let link = CADisplayLink(target: self, selector: #selector(tick(_:)))
+    self.link = link
+    link.add(to: .current, forMode: .common)
+  }
+
+  @objc private func tick(_ link: CADisplayLink) {
+    lock.lock()
+    defer { lock.unlock() }
+    guard !stopped else { return }
+    samples.record(at: CACurrentMediaTime(), frameInterval: link.targetTimestamp - link.timestamp)
+  }
+
+  func snapshot(at now: CFTimeInterval) -> BrownfieldThreadMetrics {
+    lock.lock()
+    defer { lock.unlock() }
+    return samples.snapshot(at: now)
+  }
+
+  func stop() {
+    lock.lock()
+    stopped = true
+    let oldLink = link
+    link = nil
+    lock.unlock()
+    oldLink?.invalidate()
+  }
+}
+
+/// All session state belongs to the main thread. The JS sampler alone crosses threads.
+internal final class BrownfieldDisplaySession {
+  let id = UUID().uuidString
+  let moduleName: String
+  private let waitForFullDisplay: Bool
+  private var callback: ((BrownfieldDisplayMetrics) -> Void)?
+  private let start = CACurrentMediaTime()
+  private let ui: BrownfieldFrameSampler?
+  private let js: BrownfieldFrameSampler?
+  private var initial: BrownfieldDisplayInterval?
+  private var fullWasMarked = false
+  private var finished = false
+  private var jsScheduled = false
+  private var tokens: [NSObjectProtocol] = []
+  /// Set once the appearance probe is inside the React Native root view.
+  var hasRootView = false
+
+  init(moduleName: String, waitForFullDisplay: Bool, collectThreadMetrics: Bool = false, callback: ((BrownfieldDisplayMetrics) -> Void)?) {
+    precondition(Thread.isMainThread)
+    self.moduleName = moduleName
+    self.waitForFullDisplay = waitForFullDisplay
+    self.callback = callback
+    let shouldSample = collectThreadMetrics && callback != nil
+    ui = shouldSample ? BrownfieldFrameSampler() : nil
+    js = shouldSample ? BrownfieldFrameSampler() : nil
+    guard callback != nil else {
+      finished = true
+      return
+    }
+    ui?.startOnCurrentRunLoop()
+    scheduleJS()
+    if js != nil {
+      tokens.append(NotificationCenter.default.addObserver(
+        forName: Notification.Name("BrownfieldPerformanceBridgeReady"), object: nil, queue: .main
+      ) { [weak self] _ in
+        guard let self else { return }
+        if self.jsScheduled { self.cancel() } else { self.scheduleJS() }
+      })
+    }
+    if waitForFullDisplay {
+      tokens.append(NotificationCenter.default.addObserver(
+        forName: Notification.Name("BrownfieldMarkFullyDisplayed"), object: nil, queue: .main
+      ) { [weak self] notification in
+        guard let self, notification.object as? String == self.id, !self.finished else { return }
+        self.fullWasMarked = true
+        if self.initial != nil { self.complete() }
+      })
+    }
+    // Cancellation releases samplers when the application stops drawing.
+    tokens.append(NotificationCenter.default.addObserver(
+      forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: .main
+    ) { [weak self] _ in self?.cancel() })
+    tokens.append(NotificationCenter.default.addObserver(
+      forName: Notification.Name("RCTJavaScriptDidFailToLoadNotification"), object: nil, queue: .main
+    ) { [weak self] _ in self?.cancel() })
+    tokens.append(NotificationCenter.default.addObserver(
+      forName: Notification.Name("BrownfieldPerformanceStop"), object: nil, queue: .main
+    ) { [weak self] _ in self?.cancel() })
+  }
+
+  private func scheduleJS() {
+    guard !finished, !jsScheduled, let sampler = js else { return }
+    jsScheduled = BrownfieldPerformanceBridge.dispatch(toJavaScript: {
+      sampler.startOnCurrentRunLoop()
+    })
+  }
+
+  private func interval() -> BrownfieldDisplayInterval {
+    let now = CACurrentMediaTime()
+    return BrownfieldDisplayInterval(duration: (now - start) * 1000,
+      jsThread: js?.snapshot(at: now) ?? BrownfieldFrameSamples().snapshot(at: now),
+      uiThread: ui?.snapshot(at: now) ?? BrownfieldFrameSamples().snapshot(at: now))
+  }
+
+  func appeared() {
+    guard !finished, initial == nil else { return }
+    initial = interval()
+    if !waitForFullDisplay || fullWasMarked {
+      complete()
+    }
+  }
+
+  private func complete() {
+    guard !finished, let initial else { return }
+    let full = waitForFullDisplay ? interval() : initial
+    finished = true
+    let result = BrownfieldDisplayMetrics(presentationID: id, moduleName: moduleName,
+      initialDisplay: initial, fullDisplay: full, isFinal: true)
+    let completion = callback
+    callback = nil
+    stop()
+    completion?(result)
+  }
+
+  func cancel() {
+    guard !finished else { return }
+    finished = true
+    callback = nil
+    stop()
+  }
+
+  private func stop() {
+    ui?.stop()
+    js?.stop()
+    tokens.forEach(NotificationCenter.default.removeObserver)
+    tokens.removeAll()
+  }
+
+  deinit { stop() }
+}
+
+/// A child probe preserves the RN root view's type, layout, and touch handling.
+internal final class BrownfieldAppearanceProbe: UIView {
+  let session: BrownfieldDisplaySession
+  /// Set when a view controller hosts the root. The probe then reports appearance only while
+  /// that controller is visible, for a root that arrives after `viewDidAppear`.
+  var isHostVisible: (() -> Bool)?
+  private var hasAttached = false
+
+  init(session: BrownfieldDisplaySession) {
+    self.session = session
+    super.init(frame: .zero)
+    isUserInteractionEnabled = false
+    isHidden = true
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window != nil {
+      hasAttached = true
+      if let isHostVisible {
+        if isHostVisible() { session.appeared() }
+      } else {
+        DispatchQueue.main.async { [weak self] in
+          guard let self, self.window != nil else { return }
+          self.session.appeared()
+        }
+      }
+    } else if hasAttached {
+      session.cancel()
+    }
+  }
+}

package/ios/BrownfieldPerformanceBridge.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+@interface BrownfieldPerformanceBridge : NSObject
+// Call on main. Returns NO until the JS thread or an RN bridge/proxy is available.
++ (BOOL)dispatchToJavaScript:(dispatch_block_t)block;
+@end
+NS_ASSUME_NONNULL_END

package/ios/BrownfieldPerformanceBridge.mm

@@ -0,0 +1,103 @@
+#import "BrownfieldPerformanceBridge.h"
+#import <React/RCTBridge.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTConstants.h>
+#import <objc/runtime.h>
+#include <atomic>
+
+// Accessed on main, like BrownfieldDisplaySession.
+static __weak RCTBridge *sPerformanceBridge;
+static __weak NSThread *sJavaScriptThread;
+static std::atomic<uint64_t> sGeneration{0};
+
+static void BrownfieldPerformanceReset(void)
+{
+  ++sGeneration;
+  sPerformanceBridge = nil;
+  sJavaScriptThread = nil;
+}
+
+@implementation BrownfieldPerformanceBridge
++ (BOOL)dispatchToJavaScript:(dispatch_block_t)block
+{
+  NSThread *thread = sJavaScriptThread;
+  if (thread && !thread.finished && !thread.cancelled) {
+    [self performSelector:@selector(runJavaScriptBlock:)
+                 onThread:thread
+               withObject:[block copy]
+            waitUntilDone:NO
+                    modes:@[NSRunLoopCommonModes]];
+    return YES;
+  }
+
+  RCTBridge *bridge = sPerformanceBridge;
+  // NSProxy's respondsToSelector: does not reliably describe RCTBridgeProxy.
+  if (!bridge || !class_getInstanceMethod(object_getClass(bridge), @selector(dispatchBlock:queue:))) {
+    return NO;
+  }
+  [bridge dispatchBlock:block queue:RCTJSThread];
+  return YES;
+}
+
++ (void)runJavaScriptBlock:(dispatch_block_t)block
+{
+  block();
+}
+@end
+
+// A separate iOS-only module leaves Android's generated module contract unchanged.
+@interface BrownfieldPerformance : NSObject <RCTBridgeModule>
+@end
+@implementation BrownfieldPerformance
+RCT_EXPORT_MODULE();
++ (BOOL)requiresMainQueueSetup { return NO; }
+RCT_EXPORT_METHOD(markFullyDisplayed:(NSString *)presentationID)
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[NSNotificationCenter defaultCenter] postNotificationName:@"BrownfieldMarkFullyDisplayed"
+                                                      object:presentationID];
+  });
+}
+@end
+
+__attribute__((constructor)) static void BrownfieldPerformanceRegister(void)
+{
+  // Bridgeless RN (including 0.86) posts synchronously from loadScript's afterLoad
+  // callback on the JS thread. Observe without a queue so we capture that thread,
+  // whose run loop is maintained by RCTJSThreadManager. currentBridge is a stub
+  // when the legacy architecture is removed, and this notification has no payload.
+  [[NSNotificationCenter defaultCenter] addObserverForName:@"RCTInstanceDidLoadBundle"
+      object:nil queue:nil usingBlock:^(__unused NSNotification *notification) {
+    const auto generation = sGeneration.load();
+    NSThread *thread = NSThread.currentThread;
+    if (thread.isMainThread) {
+      return;
+    }
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (generation != sGeneration.load()) {
+        return;
+      }
+      sJavaScriptThread = thread;
+      sPerformanceBridge = nil;
+      [[NSNotificationCenter defaultCenter] postNotificationName:@"BrownfieldPerformanceBridgeReady" object:nil];
+    });
+  }];
+  [[NSNotificationCenter defaultCenter] addObserverForName:RCTJavaScriptDidLoadNotification
+      object:nil queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification *notification) {
+    sPerformanceBridge = notification.userInfo[@"bridge"];
+    // Newer RN also sends this notification after the instance notification.
+    // Announcing readiness twice would cancel an already attached display session.
+    if (!sJavaScriptThread) {
+      [[NSNotificationCenter defaultCenter] postNotificationName:@"BrownfieldPerformanceBridgeReady" object:nil];
+    }
+  }];
+  [[NSNotificationCenter defaultCenter] addObserverForName:@"BrownfieldPerformanceStop"
+      object:nil queue:NSOperationQueue.mainQueue usingBlock:^(__unused NSNotification *notification) {
+    BrownfieldPerformanceReset();
+  }];
+  [[NSNotificationCenter defaultCenter] addObserverForName:RCTJavaScriptDidFailToLoadNotification
+      object:nil queue:NSOperationQueue.mainQueue usingBlock:^(__unused NSNotification *notification) {
+    BrownfieldPerformanceReset();
+  }];
+}

package/ios/Expo/ExpoHostRuntime.swift

@@ -15,6 +15,17 @@ final class ExpoHostRuntime {
   private var delegate = ExpoHostRuntimeDelegate()
   private var reactNativeFactory: RCTReactNativeFactory?
   private var expoDelegate: ExpoAppDelegate?
+  #if canImport(EXUpdates)
+  private let updatesStartup = ExpoUpdatesStartup()
+  #endif
+
+  func prepareReactNative(_ completion: @escaping () -> Void) {
+    #if canImport(EXUpdates)
+    updatesStartup.prepareReactNative(completion)
+    #else
+    completion()
+    #endif
+  }
 
   private func configureDevLoadingView(with bundleURL: URL? = nil) {
     #if DEBUG
@@ -37,7 +48,7 @@ final class ExpoHostRuntime {
    *
    * @param onBundleLoaded Optional callback invoked on the main thread after JS bundle is fully loaded.
    */
-  public func startReactNative(onBundleLoaded: (() -> Void)?) {
+  public func startReactNative(onBundleLoaded: ((JSBundleTimings) -> Void)?) {
     // The callback registration is outside of the guard below. An earlier `startReactNative` call
     // can already have made the factory, and the callback must still run.
     if let onBundleLoaded {
@@ -73,6 +84,9 @@ final class ExpoHostRuntime {
     reactNativeFactory = nil
     expoDelegate = nil
     preloadState.reset()
+    #if canImport(EXUpdates)
+    updatesStartup.cancelPendingRequests()
+    #endif
   }
 
   /**
@@ -164,11 +178,42 @@ final class ExpoHostRuntime {
     return ExpoAppDelegateSubscriberManager.application(application, willFinishLaunchingWithOptions: launchOptions)
   }
 
+  /// `onRootView` receives the React Native root view, or `nil` when React Native can't create
+  /// it. While Updates selects its launch asset, this happens after `view` returns a container.
   func view(
+    moduleName: String,
+    initialProps: [AnyHashable: Any]?,
+    launchOptions: [AnyHashable: Any]?,
+    onRootView: ((UIView?) -> Void)? = nil
+  ) -> UIView? {
+    // Return a container while Updates selects its launch asset. This also supports the
+    // public view API, which does not go through ReactNativeViewController.
+    let container = UIView()
+    var immediateView: UIView?
+    var preparing = true
+    prepareReactNative { [weak self, weak container] in
+      guard let self, preparing || container != nil else { return }
+      let root = self.createView(moduleName: moduleName, initialProps: initialProps,
+                                 launchOptions: launchOptions)
+      if preparing {
+        immediateView = root
+      } else if let container, let root {
+        root.frame = container.bounds
+        root.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        container.addSubview(root)
+      }
+      onRootView?(root)
+    }
+    preparing = false
+    return immediateView ?? container
+  }
+
+  private func createView(
     moduleName: String,
     initialProps: [AnyHashable: Any]?,
     launchOptions: [AnyHashable: Any]?
   ) -> UIView? {
+    startReactNative()
     let bundleURL = delegate.bundleURL()
     configureDevLoadingView(with: bundleURL)
 
@@ -201,8 +246,8 @@ extension ExpoHostRuntime: ReactHostPreloading {
 
   /**
    * expo-dev-launcher finds the Metro URL only after the user selects an app in the launcher. This
-   * is a Debug behavior. In Release the class is in the binary, but it does nothing. Thus this
-   * check is also only in Debug.
+   * is a Debug behavior. Packaged apps opting into an embedded bundle or an explicit URL
+   * can preload without the launcher. In Release the launcher does nothing.
    *
    * The check reads the class name, because this pod has no dependency on expo-dev-launcher.
    * `EXDevLauncherController` is the name in expo-dev-launcher 56 and 57. If a later version
@@ -213,7 +258,8 @@ extension ExpoHostRuntime: ReactHostPreloading {
    */
   func canPreloadReactNative() -> Bool {
     #if DEBUG
-    if NSClassFromString("EXDevLauncherController") != nil {
+    if !preferEmbeddedBundleInDebug && bundleURLOverride?() == nil,
+      NSClassFromString("EXDevLauncherController") != nil {
       return false
     }
     #endif
@@ -251,8 +297,9 @@ class ExpoHostRuntimeDelegate: ExpoReactNativeFactoryDelegate {
       }
 
       #if canImport(EXUpdates)
-      if !isDebug,
-        AppController.isInitialized(),
+      if AppController.isInitialized(),
+        AppController.sharedInstance.isActiveController,
+        AppController.sharedInstance.isStarted,
         let launchAssetURL = AppController.sharedInstance.launchAssetUrl()
       {
         return launchAssetURL
@@ -286,20 +333,19 @@ class ExpoHostRuntimeDelegate: ExpoReactNativeFactoryDelegate {
    *
    * The override wins over every other step, thus an override makes the URL stable.
    *
-   * expo-updates selects the launch asset while `AppController` starts. `ReactNativeViewController`
-   * starts `AppController`. Before this operation is complete, `launchAssetUrl()` is nil, and
-   * `bundleURL()` gives the embedded bundle. A host from that time keeps the embedded bundle, and
-   * Expo never applies the update. Thus the URL is stable only after `launchAssetUrl()` has a
-   * value. The class can be in the binary while the app does not use it, thus this check reads the
-   * state and not the class.
+   * The shared runtime waits for Updates before preloading or creating views. Inactive
+   * controllers use the normal bundle resolver and do not need an Updates launch asset.
    */
   var isBundleURLStable: Bool {
     if bundleURLOverride?() != nil {
       return true
     }
 
-    #if canImport(EXUpdates) && !DEBUG
-    return AppController.isInitialized() && AppController.sharedInstance.launchAssetUrl() != nil
+    #if canImport(EXUpdates)
+    guard AppController.isInitialized() else { return false }
+    return !AppController.sharedInstance.isActiveController
+      || (AppController.sharedInstance.isStarted
+        && AppController.sharedInstance.launchAssetUrl() != nil)
     #else
     return true
     #endif