[iOS] Retained page can become detached when temporary SwiftUI page hosts are loaded/discarded (9.0.7)

Addresses are replaced with placeholders. Application module names are replaced with ExampleApp; process IDs, device identifiers, local paths and application content are omitted. These are selected excerpts, not a complete raw log.

(lldb) expr -l objc++ -O -- [(id)<page-view-address> superview]
nil
(lldb) expr -l objc++ -O -- [(id)<page-view-address> window]
nil

Call stack at removal from the previous host. attachWrappedViewIfNeeded is the local helper present in the instrumented revision, not an upstream symbol; the relevant point is the transfer being initiated from viewDidLoad:

   * frame #0: <address> UIKitCore`-[UIView(Hierarchy) removeFromSuperview]
     frame #1: <address> ExampleApp.debug.dylib`PageChildViewController.attachWrappedViewIfNeeded() at Extensions.swift:65:17
  ﹍ frame #2: <address> ExampleApp.debug.dylib`PageChildViewController.viewDidLoad() at Extensions.swift:40:5
  ﹉ frame #4: <address> UIKitCore`-[UIViewController _sendViewDidLoadWithAppearanceProxyObjectTaggingEnabled] + 88
     frame #5: <address> UIKitCore`-[UIViewController loadViewIfRequired] + 916
     frame #6: <address> UIKitCore`-[UIViewController view] + 20
     frame #7: <address> SwiftUI`static PlatformViewRepresentable<>.platformView(for:) + 12
     frame #8: <address> SwiftUI`protocol witness for static CoreViewRepresentable.platformView(for:) in conformance PlatformViewControllerRepresentableAdaptor<τ_0_0> + 36

Save this next to a copy of ios/Extensions.swift from the version under test. The two pager type stubs let the unmodified remainder of that file compile; the attachment code itself is not mocked.

import UIKit
import SwiftUI

// Only the surrounding pager types are stubbed. The test compiles the actual
// patched Extensions.swift and runs its controllers inside an iOS window.
class PagerViewProvider: UIView {}
struct PagerView: View { var body: some View { EmptyView() } }

@main
class PagerRegressionApp: UIResponder, UIApplicationDelegate {
  var window: UIWindow?

  func application(_ application: UIApplication, didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    return true
  }

  func application(_ application: UIApplication, configurationForConnecting session: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
    let config = UISceneConfiguration(name: "Regression", sessionRole: session.role)
    config.delegateClass = PagerRegressionScene.self
    return config
  }

  func check(_ condition: Bool, _ name: String) {
    print("\(condition ? "PASS" : "FAIL"): \(name)")
    fflush(stdout)
    if !condition { exit(1) }
  }

  func mount(_ host: PageChildViewController, in container: UIViewController) {
    container.addChild(host)
    host.view.frame = container.view.bounds
    container.view.addSubview(host.view)
    host.didMove(toParent: container)
    host.viewDidLayoutSubviews()
  }

  func runChecks(in container: UIViewController) {
    let page = UIView(frame: container.view.bounds)
    let first = PageChildViewController()
    first.wrappedView = page
    mount(first, in: container)
    check(page.superview === first.view && page.window != nil, "initial mounted page is attached")

    let navigation = UIViewController()
    first.addChild(navigation)
    page.addSubview(navigation.view)
    navigation.didMove(toParent: first)

    autoreleasepool {
      let temporary = PageChildViewController()
      temporary.wrappedView = page
      temporary.loadViewIfNeeded()
      temporary.viewDidLayoutSubviews()
      check(page.superview === first.view, "temporary off-window host cannot steal visible page")
      check(navigation.parent === first, "temporary host preserves native controller containment")
    }
    first.viewDidLayoutSubviews()
    check(page.superview === first.view, "discarding temporary host leaves visible page intact")

    let replacement = PageChildViewController()
    replacement.wrappedView = page
    mount(replacement, in: container)
    check(page.superview === replacement.view && navigation.parent === replacement, "mounted replacement transfers page and native controller")
    first.viewDidLayoutSubviews()
    first.viewWillAppear(false)
    check(page.superview === replacement.view, "old host callbacks cannot reclaim displayed page")

    page.removeFromSuperview()
    replacement.viewDidLayoutSubviews()
    check(page.superview === replacement.view && page.window != nil, "layout repairs detached page")
    page.removeFromSuperview()
    replacement.viewDidAppear(false)
    check(page.superview === replacement.view && navigation.parent === replacement, "appearance repairs detached page")

    replacement.view.removeFromSuperview()
    first.viewDidLayoutSubviews()
    check(page.superview === first.view && navigation.parent === first, "surviving mounted host recovers page from removed replacement")
    replacement.viewDidLayoutSubviews()
    check(page.superview === first.view, "off-window former host cannot steal recovered page")
    print("Pager host regression: 10 checks passed")
  }
}

class PagerRegressionScene: UIResponder, UIWindowSceneDelegate {
  var window: UIWindow?

  func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options: UIScene.ConnectionOptions) {
    guard let scene = scene as? UIWindowScene else { return }
    let window = UIWindow(windowScene: scene)
    let container = UIViewController()
    window.rootViewController = container
    self.window = window
    window.makeKeyAndVisible()
    DispatchQueue.main.async {
      (UIApplication.shared.delegate as! PagerRegressionApp).runChecks(in: container)
      exit(0)
    }
  }
}

Place Extensions.swift, PagerHostRegression.swift, and this script in one directory, then run:

bash run-pager-regression.sh <booted-simulator-udid>

Requires Xcode command-line tools, Python 3, and ripgrep. It briefly opens a disposable helper app with the generic bundle identifier org.example.pagerregression, then removes the helper app.

#!/usr/bin/env bash
set -euo pipefail

repro_root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
device="${1:?Usage: bash run-pager-regression.sh <booted-simulator-udid>}"
test_directory="$(mktemp -d "${TMPDIR:-/tmp}/pager-regression.XXXXXX")"
app_directory="$test_directory/PagerHostRegression.app"
app_identifier="org.example.pagerregression"
cleanup() {
  xcrun simctl uninstall "$device" "$app_identifier" >/dev/null 2>&1 || true
  rm -rf -- "$test_directory"
}
trap cleanup EXIT
mkdir -p "$app_directory"

python3 - "$app_directory/Info.plist" <<'PY'
import plistlib
import sys
from pathlib import Path

Path(sys.argv[1]).write_bytes(plistlib.dumps({
    'CFBundleIdentifier': 'org.example.pagerregression',
    'CFBundleExecutable': 'PagerHostRegression',
    'CFBundleName': 'PagerHostRegression',
    'CFBundlePackageType': 'APPL',
    'MinimumOSVersion': '17.0',
    'UIDeviceFamily': [1, 2],
    'UILaunchScreen': {},
    'UIApplicationSceneManifest': {
        'UIApplicationSupportsMultipleScenes': False,
        'UISceneConfigurations': {},
    },
}))
PY

xcrun --sdk iphonesimulator swiftc \
  -sdk "$(xcrun --sdk iphonesimulator --show-sdk-path)" \
  -target "$(uname -m)-apple-ios17.0-simulator" \
  "$repro_root/Extensions.swift" \
  "$repro_root/PagerHostRegression.swift" \
  -o "$app_directory/PagerHostRegression"
codesign --force --sign - "$app_directory"
xcrun simctl install "$device" "$app_directory"
xcrun simctl launch --console "$device" "$app_identifier" > "$test_directory/results.log" 2>&1
cat "$test_directory/results.log"
rg -q '^Pager host regression: 10 checks passed$' "$test_directory/results.log"

Update: Historical patch retained for comparison. Use the revised patch in the November 5 follow-up.

diff --git a/ios/Extensions.swift b/ios/Extensions.swift
--- a/ios/Extensions.swift
+++ b/ios/Extensions.swift
@@ -16,22 +16,81 @@
     return viewController
   }
 
-  func updateUIViewController(_ uiViewController: PageChildViewController, context: Context) {}
+  func updateUIViewController(_ uiViewController: PageChildViewController, context: Context) {
+    uiViewController.attachWrappedViewIfNeeded()
+  }
 }
 
 class PageChildViewController: UIViewController {
   var wrappedView: UIView?
+  private var hasAttachedWrappedView = false
 
   override func viewDidLoad() {
     super.viewDidLoad()
     view.backgroundColor = .clear
-    if let wrappedView {
-      view.addSubview(wrappedView)
-    }
+    attachWrappedViewIfNeeded()
+  }
+
+  override func viewWillAppear(_ animated: Bool) {
+    super.viewWillAppear(animated)
+    attachWrappedViewIfNeeded()
+  }
+
+  override func viewDidAppear(_ animated: Bool) {
+    super.viewDidAppear(animated)
+    attachWrappedViewIfNeeded()
+  }
+
+  func attachWrappedViewIfNeeded() {
+    // SwiftUI also loads temporary hosts that never enter the window. Taking
+    // a retained page in viewDidLoad strands it when such a host is discarded.
+    guard isViewLoaded,
+          view.window != nil,
+          let wrappedView,
+          wrappedView.superview !== view else { return }
+
+    // A replacement host can adopt the retained page once it is mounted.
+    // A host that already handed it over must not take it back while it is
+    // displayed elsewhere. A detached page can always recover on entry.
+    guard !hasAttachedWrappedView || wrappedView.window == nil else { return }
+
+    // SwiftUI can recreate a page host when the pager's child count changes.
+    // The retained RN page may contain a native stack whose controller still
+    // belongs to the previous host. Move that containment before moving its
+    // view, otherwise UIKit raises UIViewControllerHierarchyInconsistency.
+    let retainedControllers = controllersToReparent(in: wrappedView)
+    for controller in retainedControllers {
+      controller.willMove(toParent: nil)
+      controller.removeFromParent()
+    }
+    wrappedView.removeFromSuperview()
+    for controller in retainedControllers {
+      addChild(controller)
+    }
+    view.addSubview(wrappedView)
+    hasAttachedWrappedView = true
+    for controller in retainedControllers {
+      controller.didMove(toParent: self)
+    }
+  }
+
+  private func controllersToReparent(in wrappedView: UIView) -> [UIViewController] {
+    var responder: UIResponder? = wrappedView
+    while let current = responder {
+      if let previousHost = current as? PageChildViewController, previousHost !== self {
+        return previousHost.children.filter { controller in
+          guard let childView = controller.viewIfLoaded else { return false }
+          return childView === wrappedView || childView.isDescendant(of: wrappedView)
+        }
+      }
+      responder = current.next
+    }
+    return []
   }
 
   override func viewDidLayoutSubviews() {
     super.viewDidLayoutSubviews()
+    attachWrappedViewIfNeeded()
     propagateSafeArea()
   }