Our app performs security checks (compromised-device detection, certificate pinning setup) once per app launch inside SceneDelegate's willConnectTo:options: and on scene-becomes-active. Given developer coverage states every app participates in iPhone Duo's multi-window support whether it opts in or not, and each window is presumably backed by its own scene/SceneDelegate instance: does opening a second window on the inner display spawn an independent scene that would re-run (or fail to run) this per-scene setup? For an app with security checks tied to scene lifecycle rather than app-level AppDelegate lifecycle, is there existing guidance on whether such checks should run per-scene, be coordinated across scenes via a shared app-level state, or whether Apple recommends opting out of multi-window support entirely for apps where per-window security state doesn't make sense (e.g. a single authenticated session shouldn't have divergent security state across two windows of itself)?

My app has a blocking condition that's meant to halt the entire app, not just the current screen — for example a mandatory-update check that must pass before any use, or a security check that should lock the whole app if it fails. Previously, with a single window, blocking that one window effectively blocked the whole app. With multi-window now standard on iPhone Duo, if this condition is detected while running in one scene, does it need to be manually propagated to every other currently-connected scene (e.g. via NotificationCenter or shared app-level state each scene observes), or does Apple provide a built-in mechanism for "this app-wide state changed, all active scenes should react" that I should be using instead of rolling my own?

My app currently handles push-notification taps by resolving a destination screen and presenting it. With multi-window now available to every app on iPhone Duo whether it opts in or not, if the app already has more than one window open when a notification is tapped, does the system pick an existing window to route into, always spawn a new one, or is that left entirely to the app to decide? Is there a way for the app to express a preference — e.g. "route into the window that's already showing related content, if one exists" — or does userNotificationCenter(_:didReceive:)/scene-continuation handling need to inspect all currently-connected scenes itself and make that decision manually?

My app presents a checkout/transaction screen owned by a third-party payment SDK — a UIViewController I don't control the internal layout of. If the user folds or unfolds the device while that screen is on-screen mid-transaction, and the SDK's internal views weren't written expecting a live resize, is there a recommended pattern for this situation? Options I can think of: constrain that specific scene/window to a fixed size for the duration of the SDK's flow, if that's still possible now that participation in resizing is effectively mandatory. do nothing and accept whatever the SDK does with an unexpected resize. something else Apple recommends for third-party UI you don't control during a sensitive, ideally-uninterrupted flow. Is there existing guidance for apps embedding SDKs that predate iPhone Duo and haven't been updated by their vendor yet?

Several of our sheets use custom fractional detents (.custom(identifier:resolver:), with the resolver computing a fraction of context.maximumDetentValue) to size a sheet relative to available height. If a user opens a sheet while iPhone Duo is unfolded (larger inner-display canvas) and then folds the device mid-presentation, does the resolver re-run against the new (smaller, outer-display) maximumDetentValue, or is the computed height locked in at presentation time — requiring the sheet to be dismissed and re-presented to pick up the new geometry?

We use a PreferenceKey-based pattern to measure real per-row content height in a List (via an invisible .background(GeometryReader { ... }) per row), caching the result in @State keyed by row index, since a fixed height estimate wasn't reliable. This is a common SwiftUI technique, not iPhone-Duo-specific. Apple's guidance on GeometryProxy.reservedRegion covers fold-aware layout for regions affected by the hinge, but I haven't found guidance on whether a live pose change (open → folded, or vice versa, without a relaunch) automatically invalidates cached measurements taken via a PreferenceKey at first layout, or whether SwiftUI's dependency tracking doesn't propagate that kind of external geometry change and the cache needs to be explicitly cleared on a pose-change notification. Is there a specific environment value or notification to observe for "the window's available geometry changed due to a fold event," separate from the standard horizontal/vertical size-class change?