@nativescript/core 9.1.0-dev.0 → 9.1.0-next.0

package/application/application.ios.js

@@ -3,10 +3,14 @@ import { isEmbedded } from '../ui/embedding';
 import { IOSHelper } from '../ui/core/view/view-helper';
 import { getWindow } from '../utils/native-helper';
 import { SDK_VERSION } from '../utils/constants';
-import { ios as iosUtils, dataSerialize } from '../utils/native-helper';
-import { ApplicationCommon, initializeSdkVersionClass, SceneEvents } from './application-common';
+import { ios as iosUtils, dataSerialize, dataDeserialize } from '../utils/native-helper';
+import { ApplicationCommon } from './application-common';
+import { deliverShortcutItem, forwardContinueUserActivity, forwardOpenURLContexts, oneShotCompletion } from './scene-delegate-bridge';
 import { Observable } from '../data/observable';
 import { Trace } from '../trace';
+import { IOSNativeWindow } from '../native-window/native-window.ios';
+import { NativeWindow } from '../native-window/native-window-common';
+import { NativeWindowEvents } from '../native-window/native-window-interfaces';
 import { AccessibilityServiceEnabledPropName, CommonA11YServiceEnabledObservable, SharedA11YObservable, a11yServiceClasses, a11yServiceDisabledClass, a11yServiceEnabledClass, fontScaleCategoryClasses, fontScaleExtraLargeCategoryClass, fontScaleExtraSmallCategoryClass, fontScaleMediumCategoryClass, getCurrentA11YServiceClass, getCurrentFontScaleCategory, getCurrentFontScaleClass, getFontScaleCssClasses, setCurrentA11YServiceClass, setCurrentFontScaleCategory, setCurrentFontScaleClass, setFontScaleCssClasses, FontScaleCategory, getClosestValidFontScale, VALID_FONT_SCALES, setFontScale, getFontScale, setInitFontScale, getFontScaleCategory, setInitAccessibilityCssHelper, notifyAccessibilityFocusState, AccessibilityLiveRegion, AccessibilityRole, AccessibilityState, AccessibilityTrait, isA11yEnabled, setA11yEnabled, enforceArray, } from '../accessibility/accessibility-common';
 import { CoreTypes } from '../core-types';
 import { getiOSWindow, setA11yUpdatePropertiesCallback, setApplicationPropertiesCallback, setAppMainEntry, setiOSWindow, setRootView, setToggleApplicationEventListenersCallback } from './helpers-common';
@@ -39,6 +43,7 @@ var CADisplayLinkTarget = (function (_super) {
         return target;
     };
     CADisplayLinkTarget.prototype.onDisplayed = function (link) {
+        var _a;
         link.invalidate();
         var owner = this._owner.deref();
         if (!owner) {
@@ -50,6 +55,7 @@ var CADisplayLinkTarget = (function (_super) {
             object: owner,
             ios: UIApplication.sharedApplication,
         });
+        (_a = owner.primaryWindow) === null || _a === void 0 ? void 0 : _a._notifyEvent(NativeWindowEvents.displayed);
         owner.displayedLinkTarget = null;
         owner.displayedLink = null;
     };
@@ -80,6 +86,15 @@ function supportsMultipleScenes() {
     }
     return UIApplication.sharedApplication?.supportsMultipleScenes;
 }
+/**
+ * Number of times the JS runtime has been soft-rebooted in this process via
+ * NativeScriptRuntime.reloadApplication / restartWithConfig. 0 on first boot.
+ * Provided as a global by the iOS runtime (v9+); older runtimes report 0.
+ */
+function getRuntimeReloadCount() {
+    const runtime = globalThis.NativeScriptRuntime;
+    return runtime && typeof runtime.reloadCount === 'number' ? runtime.reloadCount : 0;
+}
 var Responder = (function (_super) {
     __extends(Responder, _super);
     function Responder() {
@@ -104,8 +119,28 @@ if (supportsScenes()) {
      * Detected by the Info.plist existence 'UIApplicationSceneManifest'.
      * If this method is implemented when there is no manifest defined,
      * the app will boot to a white screen.
+     *
+     * Since we configure the delegate dynamically here, UISceneConfigurations
+     * does NOT need to be present in Info.plist — only UIApplicationSceneManifest is required.
+     *
+     * NativeScript only handles UIWindowSceneSessionRoleApplication by default.
+     * Other scene types (CarPlay, external displays, etc.) are ignored unless
+     * the user provides an `onSceneConfiguration` callback.
      */
     Responder.prototype.applicationConfigurationForConnectingSceneSessionOptions = function (application, connectingSceneSession, options) {
+        // Let the user intercept scene configuration for any/all scenes
+        const userHandler = Application.ios._onSceneConfiguration;
+        if (userHandler) {
+            const userConfig = userHandler(application, connectingSceneSession, options);
+            if (userConfig) {
+                return userConfig;
+            }
+        }
+        // Only handle the standard window scene role — skip CarPlay, external displays, etc.
+        if (connectingSceneSession.role !== UIWindowSceneSessionRoleApplication) {
+            // Return a bare configuration so iOS doesn't crash, but NativeScript won't manage it
+            return UISceneConfiguration.configurationWithNameSessionRole('Unmanaged', connectingSceneSession.role);
+        }
         const config = UISceneConfiguration.configurationWithNameSessionRole('Default Configuration', connectingSceneSession.role);
         config.sceneClass = UIWindowScene;
         config.delegateClass = SceneDelegate;
@@ -113,10 +148,20 @@ if (supportsScenes()) {
     };
     // scene session destruction handling
     Responder.prototype.applicationDidDiscardSceneSessions = function (application, sceneSessions) {
-        // Note: we could emit an event here if needed
-        // console.log('Scene sessions discarded:', sceneSessions.count);
+        Application.ios._onSceneSessionsDiscarded(sceneSessions);
     };
 }
+/**
+ * Reads the payload `openWindow()` put on the activating NSUserActivity.
+ */
+function getSceneConnectionData(connectionOptions) {
+    const activities = connectionOptions?.userActivities;
+    if (!activities || activities.count === 0) {
+        return undefined;
+    }
+    const activity = activities.allObjects.objectAtIndex(0);
+    return activity?.userInfo ? dataDeserialize(activity.userInfo) : undefined;
+}
 var SceneDelegate = (function (_super) {
     __extends(SceneDelegate, _super);
     function SceneDelegate() {
@@ -139,48 +184,234 @@ var SceneDelegate = (function (_super) {
         if (!(scene instanceof UIWindowScene)) {
             return;
         }
-        var isFirstScene = !Application.ios.getPrimaryScene() && !Application.hasLaunched();
-        this._scene = scene;
-        this._window = UIWindow.alloc().initWithWindowScene(scene);
-        Application.ios._setWindowForScene(this._window, scene);
-        Application.ios._setupWindowForScene(this._window, scene);
+        var windowScene = scene;
+        var isFirstScene = Application.ios._getWindows().length === 0;
+        this._scene = windowScene;
+        this._window = UIWindow.alloc().initWithWindowScene(windowScene);
+        if (!__VISIONOS__) {
+            this._window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
+        }
+        var nativeWindowId = IOSNativeWindow.getSceneId(windowScene);
+        var knownWindow = nativeWindowId ? Application.ios.getWindowById(nativeWindowId) : undefined;
+        var nativeWindow;
+        if ((knownWindow === null || knownWindow === void 0 ? void 0 : knownWindow.state) === "detached") {
+            nativeWindow = knownWindow;
+            nativeWindow._reattach(windowScene, this._window);
+        }
+        else {
+            var isPrimary_1 = isFirstScene || !Application.ios.primaryWindow;
+            nativeWindow = new IOSNativeWindow(windowScene, this._window, nativeWindowId, isPrimary_1);
+            Application.ios._registerWindow(nativeWindow);
+        }
+        var isPrimary = nativeWindow.isPrimary;
+        nativeWindow._notifyEvent(NativeWindowEvents.attached);
+        if (isPrimary) {
+            setiOSWindow(this._window);
+        }
+        nativeWindow.notify({
+            eventName: NativeWindowEvents.sceneWillConnect,
+            object: nativeWindow,
+            window: nativeWindow,
+            scene: windowScene,
+            uiWindow: this._window,
+            connectionOptions: connectionOptions,
+        });
         Application.ios.notify({
-            eventName: SceneEvents.sceneWillConnect,
+            eventName: NativeWindowEvents.sceneWillConnect,
             object: Application.ios,
-            scene: scene,
-            window: this._window,
+            window: nativeWindow,
+            scene: windowScene,
+            uiWindow: this._window,
             connectionOptions: connectionOptions,
         });
-        if (scene === Application.ios.getPrimaryScene()) {
+        if (isPrimary) {
             this._window.makeKeyAndVisible();
         }
-        else {
-            Application.ios.notify({
-                eventName: SceneEvents.sceneContentSetup,
-                object: Application.ios,
-                scene: scene,
-                window: this._window,
-                connectionOptions: connectionOptions,
+        if (nativeWindow.role === "application") {
+            Application.ios._resolveWindowContent(nativeWindow, {
+                window: nativeWindow,
+                isPrimary: isPrimary,
+                data: getSceneConnectionData(connectionOptions),
+                ios: { connectionOptions: connectionOptions },
             });
         }
-        if (isFirstScene) {
-            Application.ios._notifySceneAppStarted();
-        }
     };
     SceneDelegate.prototype.sceneDidBecomeActive = function (scene) {
+        var windowScene = scene;
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        if (nativeWindow) {
+            nativeWindow._notifyEvent(NativeWindowEvents.activate);
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.sceneDidActivate,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+            });
+        }
+        Application.ios.notify({
+            eventName: NativeWindowEvents.sceneDidActivate,
+            object: Application.ios,
+            window: nativeWindow,
+            scene: windowScene,
+        });
+        var rootView = nativeWindow === null || nativeWindow === void 0 ? void 0 : nativeWindow.rootView;
+        if (rootView && !rootView.isLoaded) {
+            rootView.callLoaded();
+        }
     };
     SceneDelegate.prototype.sceneWillResignActive = function (scene) {
+        var windowScene = scene;
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        if (nativeWindow) {
+            nativeWindow._notifyEvent(NativeWindowEvents.deactivate);
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.sceneWillResignActive,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+            });
+        }
         Application.ios.notify({
-            eventName: SceneEvents.sceneWillResignActive,
+            eventName: NativeWindowEvents.sceneWillResignActive,
             object: Application.ios,
-            scene: scene,
+            window: nativeWindow,
+            scene: windowScene,
         });
     };
     SceneDelegate.prototype.sceneWillEnterForeground = function (scene) {
+        var windowScene = scene;
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        if (nativeWindow) {
+            nativeWindow._notifyEvent(NativeWindowEvents.foreground);
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.sceneWillEnterForeground,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+            });
+        }
+        Application.ios.notify({
+            eventName: NativeWindowEvents.sceneWillEnterForeground,
+            object: Application.ios,
+            window: nativeWindow,
+            scene: windowScene,
+        });
     };
     SceneDelegate.prototype.sceneDidEnterBackground = function (scene) {
+        var windowScene = scene;
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        if (nativeWindow) {
+            nativeWindow._notifyEvent(NativeWindowEvents.background);
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.sceneDidEnterBackground,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+            });
+        }
+        Application.ios.notify({
+            eventName: NativeWindowEvents.sceneDidEnterBackground,
+            object: Application.ios,
+            window: nativeWindow,
+            scene: windowScene,
+        });
+        var rootView = nativeWindow === null || nativeWindow === void 0 ? void 0 : nativeWindow.rootView;
+        if (rootView && rootView.isLoaded) {
+            rootView.callUnloaded();
+        }
     };
     SceneDelegate.prototype.sceneDidDisconnect = function (scene) {
+        var windowScene = scene;
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        if (nativeWindow) {
+            var isClosing = nativeWindow._closeRequested || !nativeWindow._hasSessionIdentity;
+            if (isClosing) {
+                nativeWindow._notifyEvent(NativeWindowEvents.close);
+            }
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.sceneDidDisconnect,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+            });
+            if (isClosing) {
+                Application.ios._unregisterWindow(nativeWindow);
+            }
+            else {
+                nativeWindow._detach();
+            }
+        }
+        Application.ios.notify({
+            eventName: NativeWindowEvents.sceneDidDisconnect,
+            object: Application.ios,
+            window: nativeWindow,
+            scene: windowScene,
+        });
+    };
+    SceneDelegate.prototype.sceneOpenURLContexts = function (scene, URLContexts) {
+        var windowScene = scene;
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        if (nativeWindow) {
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.sceneOpenURLContexts,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+                urlContexts: URLContexts,
+            });
+        }
+        Application.ios.notify({
+            eventName: NativeWindowEvents.sceneOpenURLContexts,
+            object: Application.ios,
+            window: nativeWindow,
+            scene: windowScene,
+            urlContexts: URLContexts,
+        });
+        forwardOpenURLContexts(Application.ios.delegate, UIApplication.sharedApplication, URLContexts);
+    };
+    SceneDelegate.prototype.sceneContinueUserActivity = function (scene, userActivity) {
+        var windowScene = scene;
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        if (nativeWindow) {
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.sceneContinueUserActivity,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+                userActivity: userActivity,
+            });
+        }
+        Application.ios.notify({
+            eventName: NativeWindowEvents.sceneContinueUserActivity,
+            object: Application.ios,
+            window: nativeWindow,
+            scene: windowScene,
+            userActivity: userActivity,
+        });
+        forwardContinueUserActivity(Application.ios.delegate, UIApplication.sharedApplication, userActivity);
+    };
+    SceneDelegate.prototype.windowScenePerformActionForShortcutItemCompletionHandler = function (windowScene, shortcutItem, completionHandler) {
+        var nativeWindow = Application.ios._getWindowForScene(windowScene);
+        var deliver = oneShotCompletion(completionHandler);
+        if (nativeWindow) {
+            nativeWindow.notify({
+                eventName: NativeWindowEvents.scenePerformActionForShortcutItem,
+                object: nativeWindow,
+                window: nativeWindow,
+                scene: windowScene,
+                shortcutItem: shortcutItem,
+                completionHandler: deliver,
+            });
+        }
+        Application.ios.notify({
+            eventName: NativeWindowEvents.scenePerformActionForShortcutItem,
+            object: Application.ios,
+            window: nativeWindow,
+            scene: windowScene,
+            shortcutItem: shortcutItem,
+            completionHandler: deliver,
+        });
+        deliverShortcutItem(Application.ios.delegate, UIApplication.sharedApplication, shortcutItem, deliver);
     };
     SceneDelegate.ObjCProtocols = [UIWindowSceneDelegate];
     return SceneDelegate;
@@ -194,12 +425,12 @@ export class iOSApplication extends ApplicationCommon {
     constructor() {
         super();
         this._delegateHandlers = new Map();
-        this.launchEventCalled = false;
-        this._windowSceneMap = new Map();
-        this._primaryScene = null;
-        this._openedScenesById = new Map();
         this._notificationObservers = [];
+        this._softRebootSceneDelegates = new Map();
         this.displayedOnce = false;
+        /**
+         * @deprecated Has no effect. Application initialization is signalled by the 'ready' event, which is never deferred.
+         */
         this.shouldDelayLaunchEvent = false;
         this.addNotificationObserver(UIApplicationDidFinishLaunchingNotification, this.didFinishLaunchingWithOptions.bind(this));
         this.addNotificationObserver(UIApplicationDidBecomeActiveNotification, this.didBecomeActive.bind(this));
@@ -207,26 +438,58 @@ export class iOSApplication extends ApplicationCommon {
         this.addNotificationObserver(UIApplicationWillTerminateNotification, this.willTerminate.bind(this));
         this.addNotificationObserver(UIApplicationDidReceiveMemoryWarningNotification, this.didReceiveMemoryWarning.bind(this));
         this.addNotificationObserver(UIApplicationDidChangeStatusBarOrientationNotification, this.didChangeStatusBarOrientation.bind(this));
-        // Add scene lifecycle notification observers only if scenes are supported
-        if (this.supportsScenes()) {
-            this.addNotificationObserver('UISceneWillConnectNotification', this.sceneWillConnect.bind(this));
-            this.addNotificationObserver('UISceneDidActivateNotification', this.sceneDidActivate.bind(this));
-            this.addNotificationObserver('UISceneWillEnterForegroundNotification', this.sceneWillEnterForeground.bind(this));
-            this.addNotificationObserver('UISceneDidEnterBackgroundNotification', this.sceneDidEnterBackground.bind(this));
-            this.addNotificationObserver('UISceneDidDisconnectNotification', this.sceneDidDisconnect.bind(this));
-        }
     }
     getRootView() {
         return this._rootView;
     }
-    resetRootView(view) {
-        super.resetRootView(view);
+    resetRootView(entry) {
+        super.resetRootView(entry);
         this.setWindowContent();
     }
     run(entry) {
         setAppMainEntry(typeof entry === 'string' ? { moduleName: entry } : entry);
         this.started = true;
         if (this.nativeApp) {
+            // During Vite HMR dev boot, the placeholder has already started
+            // the app lifecycle. A second run() with an entry should replace
+            // the placeholder root, NOT present a modal via runAsEmbeddedApp.
+            // The HTTP ESM realm creates a separate @nativescript/core instance,
+            // so JS-level patching of Application.run can't intercept this call.
+            // Detect HMR mode via the placeholder's global flag and use
+            // setWindowContent on the PRIMARY Application singleton (bundled realm)
+            // which has the actual window and root view hierarchy.
+            const g = globalThis;
+            if (g.__NS_DEV_PLACEHOLDER_ROOT_VIEW__ || g.__NS_DEV_PLACEHOLDER_ROOT_EARLY__) {
+                if (entry) {
+                    // Defer to next run loop tick so resetRootView executes outside the
+                    // HTTP ESM import context. Direct calls can fail with
+                    // "ReferenceError: __COMMONJS__ is not defined" because the JS
+                    // execution stack is in the HTTP realm when Builder loads modules.
+                    const resolvedEntry = typeof entry === 'string' ? { moduleName: entry } : entry;
+                    setTimeout(() => {
+                        try {
+                            const primaryApp = g.Application;
+                            if (primaryApp && typeof primaryApp.resetRootView === 'function') {
+                                primaryApp.resetRootView(resolvedEntry);
+                            }
+                        }
+                        catch (e) {
+                            if (__DEV__)
+                                console.warn('[app-ios] deferred resetRootView failed:', e);
+                        }
+                        delete g.__NS_DEV_PLACEHOLDER_ROOT_VIEW__;
+                        delete g.__NS_DEV_PLACEHOLDER_ROOT_EARLY__;
+                    }, 0);
+                }
+                else {
+                    // Framework (e.g. Angular) calls run() with no entry — it manages
+                    // root views itself via resetRootView(). No-op to avoid presenting
+                    // a modal via runAsEmbeddedApp or throwing "Main entry is missing".
+                    if (__DEV__)
+                        console.info('[app-ios] run() called with no entry during HMR placeholder; framework manages root view');
+                }
+                return;
+            }
             this.runAsEmbeddedApp();
         }
         else {
@@ -237,6 +500,8 @@ export class iOSApplication extends ApplicationCommon {
         UIApplicationMain(0, null, null, this.delegate ? NSStringFromClass(this.delegate) : NSStringFromClass(Responder));
     }
     runAsEmbeddedApp() {
+        this.notifyReady();
+        this._reattachNativeDelegatesAfterSoftReboot();
         // TODO: this rootView should be held alive until rootController dismissViewController is called.
         const rootView = this.createRootView(this._rootView, true);
         if (!rootView) {
@@ -245,38 +510,126 @@ export class iOSApplication extends ApplicationCommon {
         this._rootView = rootView;
         setRootView(rootView);
         // Attach to the existing iOS app
-        const window = getWindow();
+        let window = getWindow();
         if (!window) {
-            return;
+            // In-process soft reboot with OTAs.
+            // Original UIWindow is deallocated when the old JS isolate is torn down.
+            // Recreate a window bound to the active UIWindowScene so the
+            // root has somewhere to attach.
+            const app = UIApplication.sharedApplication;
+            const all = app && app.connectedScenes ? app.connectedScenes.allObjects : null;
+            let targetScene;
+            if (all) {
+                for (let i = 0; i < all.count; i++) {
+                    const s = all.objectAtIndex(i);
+                    // Only UIWindowScene exposes `windows`; prefer a foreground-active one.
+                    if (s && typeof s.windows !== 'undefined') {
+                        targetScene = s;
+                        if (s.activationState === 0 /* UISceneActivationState.ForegroundActive */) {
+                            break;
+                        }
+                    }
+                }
+            }
+            if (targetScene) {
+                window = UIWindow.alloc().initWithWindowScene(targetScene);
+                if (!__VISIONOS__) {
+                    window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
+                }
+                // The registry lives in JS and was lost with the previous isolate, so
+                // the still-connected scene needs a fresh NativeWindow to be reachable.
+                const isPrimary = !this.primaryWindow;
+                const nativeWindow = new IOSNativeWindow(targetScene, window, IOSNativeWindow.getSceneId(targetScene), isPrimary);
+                this._registerWindow(nativeWindow);
+                if (isPrimary) {
+                    setiOSWindow(window);
+                }
+                // If the scene's delegate was recreated after a soft reboot, point it
+                // at the new window so `scene.delegate.window` queries resolve.
+                const freshSceneDelegate = this._softRebootSceneDelegates.get(targetScene);
+                if (freshSceneDelegate) {
+                    freshSceneDelegate.window = window;
+                }
+            }
         }
-        const rootController = window.rootViewController;
-        if (!rootController) {
+        if (!window) {
             return;
         }
-        const controller = this.getViewController(rootView);
+        // May be null on a freshly recreated window — expected; the replace-root
+        // path below sets it. Only the embedder path needs an existing controller.
+        const rootController = window.rootViewController;
         const embedderDelegate = NativeScriptEmbedder.sharedInstance().delegate;
-        rootView._setupAsRootView({});
-        rootView.on(IOSHelper.traitCollectionColorAppearanceChangedEvent, () => {
-            const userInterfaceStyle = controller.traitCollection.userInterfaceStyle;
-            const newSystemAppearance = this.getSystemAppearanceValue(userInterfaceStyle);
-            this.setSystemAppearance(newSystemAppearance);
-        });
-        rootView.on(IOSHelper.traitCollectionLayoutDirectionChangedEvent, () => {
-            const layoutDirection = controller.traitCollection.layoutDirection;
-            const newLayoutDirection = this.getLayoutDirectionValue(layoutDirection);
-            this.setLayoutDirection(newLayoutDirection);
-        });
-        if (embedderDelegate) {
-            this.setViewControllerView(rootView);
-            embedderDelegate.presentNativeScriptApp(controller);
+        // Embed into host app requires an existing root view controller
+        if (embedderDelegate && !rootController) {
+            return;
         }
-        else {
-            const visibleVC = iosUtils.getVisibleViewController(rootController);
-            visibleVC.presentViewControllerAnimatedCompletion(controller, true, null);
+        let hostWindow = this.primaryWindow;
+        if (!hostWindow) {
+            // Only an embedder delegate makes this window a guest: without one NativeScript
+            // owns the UIApplication and the window has to attach its own content.
+            const role = embedderDelegate ? 'embedded' : 'application';
+            hostWindow = new IOSNativeWindow(window.windowScene ?? undefined, window, 'embedded-main', true, role);
+            this._registerWindow(hostWindow);
+            hostWindow._notifyEvent(NativeWindowEvents.attached);
         }
-        this.initRootView(rootView);
+        hostWindow.setContent(rootView);
         this.notifyAppStarted();
     }
+    /**
+     * After an in-process soft reboot (NativeScriptRuntime.reloadApplication /
+     * restartWithConfig), the Objective-C delegate classes created by the
+     * previous JS isolate still exist and UIKit keeps dispatching to their
+     * now-inert instances: their method callbacks bail out because the isolate
+     * that implemented them is gone. Notification-center observers are
+     * re-registered by the new isolate, but delegate-based dispatch (custom
+     * UIApplicationDelegate methods like push-token/openURL callbacks, and the
+     * UIScene delegates used by scene-lifecycle apps) stays pinned to the old
+     * bundle. Recreate those delegates from this bundle's classes and re-point
+     * UIKit at them.
+     */
+    _reattachNativeDelegatesAfterSoftReboot() {
+        if (getRuntimeReloadCount() <= 0) {
+            // First boot: UIApplicationMain (or the host app) set up delegates.
+            return;
+        }
+        if (isEmbedded()) {
+            // The host app owns the UIApplication delegate; never touch it.
+            return;
+        }
+        const app = UIApplication.sharedApplication;
+        if (!app) {
+            return;
+        }
+        // Fresh application delegate from the new bundle. Assigning `delegate`
+        // does not retain (unlike the UIApplicationMain launch path), so keep a
+        // strong reference ourselves.
+        this.delegate ?? (this.delegate = Responder);
+        const freshDelegate = this.delegate.new();
+        this._softRebootAppDelegate = freshDelegate;
+        app.delegate = freshDelegate;
+        // Re-point already-connected scenes at fresh scene delegates so scene
+        // lifecycle and user-implemented scene delegate methods (shortcuts,
+        // openURLContexts, userActivity continuation, etc.) reach this isolate.
+        // Newly connecting scenes are covered by the fresh application delegate's
+        // applicationConfigurationForConnectingSceneSessionOptions, which returns
+        // this bundle's SceneDelegate class.
+        if (this.supportsScenes()) {
+            this._softRebootSceneDelegates.clear();
+            const scenes = app.connectedScenes?.allObjects;
+            for (let i = 0; scenes && i < scenes.count; i++) {
+                const scene = scenes.objectAtIndex(i);
+                if (!(scene instanceof UIWindowScene)) {
+                    continue;
+                }
+                const freshSceneDelegate = SceneDelegate.new();
+                scene.delegate = freshSceneDelegate;
+                this._softRebootSceneDelegates.set(scene, freshSceneDelegate);
+            }
+        }
+        if (Trace.isEnabled()) {
+            Trace.write(`Reattached application delegate${this._softRebootSceneDelegates.size ? ` and ${this._softRebootSceneDelegates.size} scene delegate(s)` : ''} after soft reboot (reloadCount: ${getRuntimeReloadCount()})`, Trace.categories.NativeLifecycle);
+        }
+    }
     getViewController(rootView) {
         let viewController = rootView.viewController || rootView.ios;
         if (!(viewController instanceof UIViewController)) {
@@ -461,7 +814,6 @@ export class iOSApplication extends ApplicationCommon {
         }
     }
     notifyAppStarted(notification) {
-        this.launchEventCalled = true;
         const root = this.notifyLaunch({
             ios: notification?.userInfo?.objectForKey('UIApplicationLaunchOptionsLocalNotificationKey') ?? null,
         });
@@ -474,10 +826,6 @@ export class iOSApplication extends ApplicationCommon {
             setiOSWindow(this.window);
         }
     }
-    // Public method for scene-based app startup
-    _notifySceneAppStarted() {
-        this.notifyAppStarted();
-    }
     _onLivesync(context) {
         // Handle application root module
         const isAppRootModuleChanged = context && context.path && context.path.includes(this.getMainEntry().moduleName) && context.type !== 'style';
@@ -492,14 +840,23 @@ export class iOSApplication extends ApplicationCommon {
         }
     }
     setWindowContent(view) {
+        const rootView = this.createRootView(view);
+        const primaryWindow = this.primaryWindow;
+        if (primaryWindow) {
+            primaryWindow.setContent(rootView);
+            return;
+        }
+        this.setWindowContentFallback(rootView);
+    }
+    /**
+     * Attaches content to the raw `UIWindow`. Every launch path registers a primary
+     * NativeWindow, so this only runs when no window is left to own the content.
+     */
+    setWindowContentFallback(rootView) {
         if (this._rootView) {
-            // if we already have a root view, we reset it.
             this._rootView._onRootViewReset();
         }
-        const rootView = this.createRootView(view);
         const controller = this.getViewController(rootView);
-        this._rootView = rootView;
-        setRootView(rootView);
         // setup view as styleScopeHost
         rootView._setupAsRootView({});
         this.setViewControllerView(rootView);
@@ -509,17 +866,7 @@ export class iOSApplication extends ApplicationCommon {
         if (!haveController) {
             win.makeKeyAndVisible();
         }
-        this.initRootView(rootView);
-        rootView.on(IOSHelper.traitCollectionColorAppearanceChangedEvent, () => {
-            const userInterfaceStyle = controller.traitCollection.userInterfaceStyle;
-            const newSystemAppearance = this.getSystemAppearanceValue(userInterfaceStyle);
-            this.setSystemAppearance(newSystemAppearance);
-        });
-        rootView.on(IOSHelper.traitCollectionLayoutDirectionChangedEvent, () => {
-            const layoutDirection = controller.traitCollection.layoutDirection;
-            const newLayoutDirection = this.getLayoutDirectionValue(layoutDirection);
-            this.setLayoutDirection(newLayoutDirection);
-        });
+        this.adoptRootView(rootView);
     }
     // Observers
     didFinishLaunchingWithOptions(notification) {
@@ -537,6 +884,8 @@ export class iOSApplication extends ApplicationCommon {
                 }
             }
         }
+        // Must precede every window registration below and every scene connect that follows.
+        this.notifyReady();
         this.setMaxRefreshRate();
         // Only set up window if NOT using scene-based lifecycle
         if (!this.supportsScenes()) {
@@ -550,9 +899,26 @@ export class iOSApplication extends ApplicationCommon {
             if (!__VISIONOS__) {
                 this.window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
             }
-            this.launchEventCalled = false;
-            if (!this.shouldDelayLaunchEvent) {
-                this.notifyAppStarted();
+            if (!this.primaryWindow) {
+                const nativeWindow = new IOSNativeWindow(undefined, this.window, 'main', true, 'application');
+                this._registerWindow(nativeWindow);
+                nativeWindow._notifyEvent(NativeWindowEvents.attached);
+            }
+            const primaryWindow = this.primaryWindow;
+            const resolveContent = () => this._resolveWindowContent(primaryWindow, {
+                window: primaryWindow,
+                isPrimary: true,
+            }, {
+                launchData: {
+                    ios: notification?.userInfo?.objectForKey('UIApplicationLaunchOptionsLocalNotificationKey') ?? null,
+                },
+            });
+            if (UIApplication.sharedApplication.applicationState === 2 /* UIApplicationState.Background */) {
+                // A background launch has no UI to build yet, so content waits for the first activation.
+                this._pendingWindowContentResolve = resolveContent;
+            }
+            else {
+                resolveContent();
             }
         }
         else {
@@ -560,17 +926,22 @@ export class iOSApplication extends ApplicationCommon {
         }
     }
     didBecomeActive(notification) {
-        if (!this.launchEventCalled) {
-            this.notifyAppStarted(notification);
+        const pendingWindowContentResolve = this._pendingWindowContentResolve;
+        if (pendingWindowContentResolve) {
+            this._pendingWindowContentResolve = null;
+            pendingWindowContentResolve();
         }
         const additionalData = {
             ios: UIApplication.sharedApplication,
         };
         this.setInBackground(false, additionalData);
         this.setSuspended(false, additionalData);
-        const rootView = this._rootView;
-        if (rootView && !rootView.isLoaded) {
-            rootView.callLoaded();
+        // In scene mode the root view belongs to a window, so the scene delegate loads it.
+        if (!this.supportsScenes()) {
+            const rootView = this._rootView;
+            if (rootView && !rootView.isLoaded) {
+                rootView.callLoaded();
+            }
         }
     }
     didEnterBackground(notification) {
@@ -579,9 +950,11 @@ export class iOSApplication extends ApplicationCommon {
         };
         this.setInBackground(true, additionalData);
         this.setSuspended(true, additionalData);
-        const rootView = this._rootView;
-        if (rootView && rootView.isLoaded) {
-            rootView.callUnloaded();
+        if (!this.supportsScenes()) {
+            const rootView = this._rootView;
+            if (rootView && rootView.isLoaded) {
+                rootView.callUnloaded();
+            }
         }
     }
     willTerminate(notification) {
@@ -603,151 +976,111 @@ export class iOSApplication extends ApplicationCommon {
         });
     }
     didChangeStatusBarOrientation(notification) {
-        const statusBarOrientation = UIApplication.sharedApplication.statusBarOrientation;
-        const newOrientation = this.getOrientationValue(statusBarOrientation);
-        this.setOrientation(newOrientation);
-    }
-    // Scene lifecycle notification handlers
-    sceneWillConnect(notification) {
-        const scene = notification.object;
-        if (!scene || !(scene instanceof UIWindowScene)) {
-            return;
-        }
-        // Store as primary scene if it's the first one
-        if (!this._primaryScene) {
-            this._primaryScene = scene;
+        // The notification is app-wide, but scenes rotate independently, so every attached
+        // window is refreshed from its own scene.
+        for (const nativeWindow of this._windows) {
+            if (nativeWindow.state !== 'attached') {
+                continue;
+            }
+            const orientation = nativeWindow.ios?.scene?.interfaceOrientation ?? UIApplication.sharedApplication.statusBarOrientation;
+            nativeWindow._setOrientation(this.getOrientationValue(orientation));
         }
-        this.notify({
-            eventName: SceneEvents.sceneWillConnect,
-            object: this,
-            scene: scene,
-            userInfo: notification.userInfo,
-        });
     }
-    sceneDidActivate(notification) {
-        const scene = notification.object;
-        this.notify({
-            eventName: SceneEvents.sceneDidActivate,
-            object: this,
-            scene: scene,
-        });
-        // If this is the primary scene, trigger traditional app lifecycle
-        if (scene === this._primaryScene) {
-            const additionalData = {
-                ios: UIApplication.sharedApplication,
-                scene: scene,
-            };
-            this.setInBackground(false, additionalData);
-            this.setSuspended(false, additionalData);
-            if (this._rootView && !this._rootView.isLoaded) {
-                this._rootView.callLoaded();
-            }
+    // --- App-level root view mirror ---
+    /**
+     * Keeps the app-level root view state (`getRootView()`, the global root view and the
+     * `initRootView` event) following whatever the primary window shows.
+     */
+    mirrorPrimaryWindow(nativeWindow) {
+        if (this._mirroredWindow === nativeWindow) {
+            return;
+        }
+        this._mirroredWindow?.off(NativeWindowEvents.contentLoaded, this.onPrimaryWindowContentLoaded, this);
+        this._mirroredWindow = nativeWindow;
+        nativeWindow.on(NativeWindowEvents.contentLoaded, this.onPrimaryWindowContentLoaded, this);
+        if (nativeWindow.rootView && nativeWindow.rootView !== this._rootView) {
+            this.adoptRootView(nativeWindow.rootView);
         }
     }
-    sceneWillEnterForeground(notification) {
-        const scene = notification.object;
-        this.notify({
-            eventName: SceneEvents.sceneWillEnterForeground,
-            object: this,
-            scene: scene,
-        });
+    onPrimaryWindowContentLoaded(data) {
+        this.adoptRootView(data.window.rootView);
     }
-    sceneDidEnterBackground(notification) {
-        const scene = notification.object;
-        this.notify({
-            eventName: SceneEvents.sceneDidEnterBackground,
-            object: this,
-            scene: scene,
-        });
-        // If this is the primary scene, trigger traditional app lifecycle
-        if (scene === this._primaryScene) {
-            const additionalData = {
-                ios: UIApplication.sharedApplication,
-                scene: scene,
-            };
-            this.setInBackground(true, additionalData);
-            this.setSuspended(true, additionalData);
-            if (this._rootView && this._rootView.isLoaded) {
-                this._rootView.callUnloaded();
-            }
+    adoptRootView(rootView) {
+        if (!rootView) {
+            return;
         }
+        this._rootView = rootView;
+        setRootView(rootView);
+        this.initRootView(rootView, this._mirroredWindow);
     }
-    sceneDidDisconnect(notification) {
-        const scene = notification.object;
-        this._removeWindowForScene(scene);
-        // If primary scene disconnected, clear it
-        if (scene === this._primaryScene) {
-            this._primaryScene = null;
-        }
-        if (this._primaryScene) {
-            if (SDK_VERSION >= 17) {
-                const request = UISceneSessionActivationRequest.requestWithSession(this._primaryScene.session);
-                UIApplication.sharedApplication.activateSceneSessionForRequestErrorHandler(request, (err) => {
-                    if (err) {
-                        console.log('Failed to activate primary scene:', err.localizedDescription);
-                    }
-                });
-            }
-            else {
-                UIApplication.sharedApplication.requestSceneSessionActivationUserActivityOptionsErrorHandler(this._primaryScene.session, null, null, (err) => {
-                    if (err) {
-                        console.log('Failed to activate primary scene (legacy):', err.localizedDescription);
-                    }
-                });
-            }
+    // --- NativeWindow registry ---
+    /**
+     * @internal - iOS reports discarded sessions for windows this JS context may never
+     * have seen (they can arrive on a later launch), so unknown ids are ignored.
+     */
+    _onSceneSessionsDiscarded(sessions) {
+        const all = sessions?.allObjects;
+        if (!all) {
+            return;
         }
-        this.notify({
-            eventName: SceneEvents.sceneDidDisconnect,
-            object: this,
-            scene: scene,
-        });
-    }
-    // Scene management helper methods
-    _setWindowForScene(window, scene) {
-        this._windowSceneMap.set(scene, window);
-    }
-    _removeWindowForScene(scene) {
-        this._windowSceneMap.delete(scene);
-        // also untrack opened scene id
-        try {
-            const s = scene;
-            if (s && s.session) {
-                const id = this._getSceneId(s);
-                this._openedScenesById.delete(id);
+        for (let i = 0; i < all.count; i++) {
+            const persistentIdentifier = all.objectAtIndex(i)?.persistentIdentifier;
+            const nativeWindow = persistentIdentifier ? this.getWindowById(`${persistentIdentifier}`) : undefined;
+            if (!nativeWindow) {
+                continue;
             }
+            nativeWindow._notifyEvent(NativeWindowEvents.close);
+            this._unregisterWindow(nativeWindow);
         }
-        catch { }
     }
+    /**
+     * @internal - Get a NativeWindow by its scene.
+     */
     _getWindowForScene(scene) {
-        return this._windowSceneMap.get(scene);
+        return this._windows.find((nw) => nw.ios?.scene === scene);
     }
-    _setupWindowForScene(window, scene) {
-        if (!window) {
-            return;
-        }
-        // track opened scene
-        try {
-            const id = this._getSceneId(scene);
-            this._openedScenesById.set(id, scene);
+    _onWindowRegistered(nativeWindow) {
+        if (nativeWindow.isPrimary) {
+            this.mirrorPrimaryWindow(nativeWindow);
         }
-        catch { }
-        // Set up window background
-        if (!__VISIONOS__) {
-            window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
-        }
-        // If this is the primary scene, set up the main application content
-        if (scene === this._primaryScene || !this._primaryScene) {
-            this._primaryScene = scene;
-            if (!getiOSWindow()) {
-                setiOSWindow(window);
-            }
-            // During initial scene startup we must wait for launch to be notified first.
-            // Some frameworks provide root content from launch handlers.
-            if (this.hasLaunched()) {
-                this.setWindowContent();
-            }
+    }
+    _onPrimaryWindowPromoted(nativeWindow) {
+        const promotedWindow = nativeWindow.ios?.uiWindow;
+        if (promotedWindow) {
+            setiOSWindow(promotedWindow);
         }
+        this.mirrorPrimaryWindow(nativeWindow);
+    }
+    /**
+     * Register a callback to intercept scene configuration.
+     *
+     * Called for every new scene session. Return a `UISceneConfiguration` to handle
+     * the scene yourself (e.g. CarPlay, external display), or return `null`/`undefined`
+     * to let NativeScript handle it with the default SceneDelegate.
+     *
+     * NativeScript only auto-manages `UIWindowSceneSessionRoleApplication` scenes.
+     * All other scene roles are ignored unless you provide a configuration here.
+     *
+     * @example
+     * ```ts
+     * Application.ios.onSceneConfiguration = (app, session, options) => {
+     *   if (session.role === CPTemplateApplicationSceneSessionRoleApplication) {
+     *     const config = UISceneConfiguration.configurationWithNameSessionRole('CarPlay', session.role);
+     *     config.delegateClass = MyCarPlaySceneDelegate;
+     *     return config;
+     *   }
+     *   // Return null to let NativeScript handle the default window scene
+     *   return null;
+     * };
+     * ```
+     */
+    set onSceneConfiguration(handler) {
+        this._onSceneConfiguration = handler;
     }
+    get onSceneConfiguration() {
+        return this._onSceneConfiguration;
+    }
+    // Scene management helper methods (kept for backward compat)
     get sceneDelegate() {
         if (!this._sceneDelegate) {
             this._sceneDelegate = SceneDelegate.new();
@@ -761,10 +1094,12 @@ export class iOSApplication extends ApplicationCommon {
      * Multi-window support
      */
     /**
-     * Opens a new window with the specified data.
-     * @param data The data to pass to the new window.
+     * Opens a new window (scene).
+     *
+     * @param options Options for the new window. `options.data` is serialized into the
+     * activating scene's `NSUserActivity.userInfo`.
      */
-    openWindow(data) {
+    openWindow(options) {
         if (!supportsMultipleScenes()) {
             console.log('Cannot create a new scene - not supported on this device.');
             return;
@@ -773,34 +1108,18 @@ export class iOSApplication extends ApplicationCommon {
             const app = UIApplication.sharedApplication;
             // iOS 17+
             if (SDK_VERSION >= 17) {
-                // Create a new scene activation request with proper role
                 let request;
                 try {
-                    // Use the correct factory method to create request with role
-                    // Based on the type definitions, this is the proper way
                     request = UISceneSessionActivationRequest.requestWithRole(UIWindowSceneSessionRoleApplication);
-                    // Note: may be useful to allow user defined activity type through optional string typed data in future
                     const activity = NSUserActivity.alloc().initWithActivityType(`${NSBundle.mainBundle.bundleIdentifier}.scene`);
-                    activity.userInfo = dataSerialize(data);
+                    activity.userInfo = dataSerialize(options?.data ?? {});
                     request.userActivity = activity;
-                    // Set proper options with requesting scene
-                    const options = UISceneActivationRequestOptions.new();
-                    // Note: explore secondary windows spawning other windows
-                    // and if this context needs to change in those cases
-                    const mainWindow = Application.ios.getPrimaryWindow();
-                    options.requestingScene = mainWindow?.windowScene;
-                    /**
-                     * Note: This does not work in testing but worth exploring further sometime
-                     * regarding the size/dimensions of opened secondary windows.
-                     * The initial size is ultimately determined by the system
-                     * based on available space and user context.
-                     */
-                    // Get the size restrictions from the window scene
-                    // const sizeRestrictions = (options.requestingScene as UIWindowScene).sizeRestrictions;
-                    // // Set your minimum and maximum dimensions
-                    // sizeRestrictions.minimumSize = CGSizeMake(320, 400);
-                    // sizeRestrictions.maximumSize = CGSizeMake(600, 800);
-                    request.options = options;
+                    const activationOptions = UISceneActivationRequestOptions.new();
+                    const primary = this.primaryWindow;
+                    if (primary?.ios?.scene) {
+                        activationOptions.requestingScene = primary.ios.scene;
+                    }
+                    request.options = activationOptions;
                 }
                 catch (roleError) {
                     console.log('Error creating request:', roleError);
@@ -809,32 +1128,25 @@ export class iOSApplication extends ApplicationCommon {
                 app.activateSceneSessionForRequestErrorHandler(request, (error) => {
                     if (error) {
                         console.log('Error creating new scene (iOS 17+):', error);
-                        // Log additional debugging info
                         if (error.userInfo) {
                             console.error(`Error userInfo: ${error.userInfo.description}`);
                         }
-                        // Handle specific error types
                         if (error.localizedDescription.includes('role') && error.localizedDescription.includes('nil')) {
-                            this.createSceneWithLegacyAPI(data);
+                            this.createSceneWithLegacyAPI(options?.data);
                         }
                         else if (error.domain === 'FBSWorkspaceErrorDomain' && error.code === 2) {
-                            this.createSceneWithLegacyAPI(data);
+                            this.createSceneWithLegacyAPI(options?.data);
                         }
                     }
                 });
             }
-            // iOS 13-16 - Use the legacy requestSceneSessionActivationUserActivityOptionsErrorHandler method
             else if (SDK_VERSION >= 13 && SDK_VERSION < 17) {
-                app.requestSceneSessionActivationUserActivityOptionsErrorHandler(null, // session
-                null, // userActivity
-                null, // options
-                (error) => {
+                app.requestSceneSessionActivationUserActivityOptionsErrorHandler(null, null, null, (error) => {
                     if (error) {
                         console.log('Error creating new scene (legacy):', error);
                     }
                 });
             }
-            // Fallback for older iOS versions or unsupported configurations
             else {
                 console.log('Neither new nor legacy scene activation methods are available');
             }
@@ -845,71 +1157,66 @@ export class iOSApplication extends ApplicationCommon {
     }
     /**
      * Closes a secondary window/scene.
-     * Usage examples:
-     *  - Application.ios.closeWindow() // best-effort close of a non-primary scene
-     *  - Application.ios.closeWindow(button) // from a tap handler within the scene
-     *  - Application.ios.closeWindow(window)
-     *  - Application.ios.closeWindow(scene)
-     *  - Application.ios.closeWindow('scene-id')
+     * Accepts a NativeWindow, View, UIWindow, UIWindowScene, or string id.
      */
     closeWindow(target) {
         if (!__APPLE__) {
             return;
         }
         try {
-            const scene = this._resolveScene(target);
-            if (!scene) {
-                console.log('closeWindow: No scene resolved for target');
-                return;
+            let nativeWindow;
+            if (target instanceof NativeWindow) {
+                nativeWindow = target;
             }
-            // Don't allow closing the primary scene
-            if (scene === this._primaryScene) {
-                console.log('closeWindow: Refusing to close the primary scene');
-                return;
+            else {
+                const scene = this._resolveScene(target);
+                if (scene) {
+                    nativeWindow = this._getWindowForScene(scene);
+                }
             }
-            const session = scene.session;
-            if (!session) {
-                console.log('closeWindow: Scene has no session to destroy');
+            if (!nativeWindow) {
+                console.log('closeWindow: No window resolved for target');
                 return;
             }
-            const app = UIApplication.sharedApplication;
-            if (app.requestSceneSessionDestructionOptionsErrorHandler) {
-                app.requestSceneSessionDestructionOptionsErrorHandler(session, null, (error) => {
-                    if (error) {
-                        console.log('closeWindow: destruction error', error);
-                    }
-                    else {
-                        // clean up tracked id
-                        const id = this._getSceneId(scene);
-                        this._openedScenesById.delete(id);
-                    }
-                });
-            }
-            else {
-                console.info('closeWindow: Scene destruction API not available on this iOS version');
-            }
+            nativeWindow.close();
         }
         catch (err) {
             console.log('closeWindow: Unexpected error', err);
         }
     }
+    /**
+     * @deprecated Use `getWindows()` instead.
+     */
     getAllWindows() {
-        return Array.from(this._windowSceneMap.values());
+        return this._windows.map((nw) => nw.ios?.uiWindow).filter(Boolean);
     }
+    /**
+     * @deprecated Use `getWindows()` instead.
+     */
     getAllScenes() {
-        return Array.from(this._windowSceneMap.keys());
+        return this._windows.map((nw) => nw.ios?.scene).filter(Boolean);
     }
+    /**
+     * @deprecated Use `getWindows()` instead.
+     */
     getWindowScenes() {
         return this.getAllScenes().filter((scene) => scene instanceof UIWindowScene);
     }
+    /**
+     * @deprecated Use `primaryWindow?.ios?.uiWindow` instead.
+     */
     getPrimaryWindow() {
-        if (this._primaryScene) {
-            return this._getWindowForScene(this._primaryScene) || getiOSWindow();
+        const primary = this.primaryWindow;
+        if (primary?.ios?.uiWindow) {
+            return primary.ios.uiWindow;
         }
         return getiOSWindow();
     }
+    /**
+     * @deprecated Use `primaryWindow?.ios?.scene` instead.
+     */
     getPrimaryScene() {
-        return this._primaryScene;
+        return this.primaryWindow?.ios?.scene || null;
     }
     // Scene lifecycle management
     supportsScenes() {
@@ -919,7 +1226,7 @@ export class iOSApplication extends ApplicationCommon {
         return supportsMultipleScenes();
     }
     isUsingSceneLifecycle() {
-        return this.supportsScenes() && this._windowSceneMap.size > 0;
+        return this.supportsScenes() && this._windows.length > 0;
     }
     // Call this to set up scene-based configuration
     configureForScenes() {
@@ -927,34 +1234,6 @@ export class iOSApplication extends ApplicationCommon {
             console.warn('Scene-based lifecycle is only supported on iOS 13+ iPad or visionOS with multi-scene enabled apps.');
             return;
         }
-        // Additional scene configuration can be added here
-        // For now, the notification observers are already set up in the constructor
-    }
-    // Stable scene id for lookups
-    _getSceneId(scene) {
-        try {
-            if (!scene) {
-                return 'Unknown';
-            }
-            // Prefer session persistentIdentifier when available (stable across lifetime)
-            const session = scene.session;
-            const persistentId = session && session.persistentIdentifier;
-            if (persistentId) {
-                return `${persistentId}`;
-            }
-            // Fallbacks
-            if (scene.hash != null) {
-                return `${scene.hash}`;
-            }
-            const desc = scene.description;
-            if (desc) {
-                return `${desc}`;
-            }
-        }
-        catch (err) {
-            // ignore
-        }
-        return 'Unknown';
     }
     // Resolve a UIWindowScene from various input types
     _resolveScene(target) {
@@ -962,12 +1241,10 @@ export class iOSApplication extends ApplicationCommon {
             return null;
         }
         if (!target) {
-            // Try to pick a non-primary foreground active scene, else last known scene
-            const scenes = this.getWindowScenes?.() || [];
-            const nonPrimary = scenes.filter((s) => s !== this._primaryScene);
-            return nonPrimary[0] || scenes[0] || null;
+            // Try to pick a non-primary window's scene
+            const nonPrimary = this._windows.filter((nw) => !nw.isPrimary);
+            return nonPrimary[0]?.ios?.scene || this.primaryWindow?.ios?.scene || null;
         }
-        // If a View was passed, derive its window.scene
         if (target && typeof target === 'object') {
             // UIWindowScene
             if (target.session && target.activationState !== undefined) {
@@ -986,15 +1263,15 @@ export class iOSApplication extends ApplicationCommon {
         }
         // String id lookup
         if (typeof target === 'string') {
-            if (this._openedScenesById.has(target)) {
-                return this._openedScenesById.get(target);
+            const found = this.getWindowById(target);
+            if (found) {
+                return found.ios?.scene || null;
             }
-            // Try matching by persistentIdentifier or hash among known scenes
-            const scenes = this.getWindowScenes?.() || [];
-            for (const s of scenes) {
-                const sid = this._getSceneId(s);
-                if (sid === target) {
-                    return s;
+            // Try matching among known scenes
+            for (const nw of this._windows) {
+                const scene = nw.ios?.scene;
+                if (scene && IOSNativeWindow.getSceneId(scene) === target) {
+                    return scene;
                 }
             }
         }
@@ -1007,7 +1284,7 @@ export class iOSApplication extends ApplicationCommon {
         }
         // Create user activity for the new scene
         const userActivity = NSUserActivity.alloc().initWithActivityType(`${NSBundle.mainBundle.bundleIdentifier}.scene`);
-        userActivity.userInfo = dataSerialize(data);
+        userActivity.userInfo = dataSerialize(data ?? {});
         // Use the legacy API
         const options = UISceneActivationRequestOptions.new();
         options.requestingScene = windowScene;
@@ -1058,6 +1335,7 @@ global.__onLiveSyncCore = function (context) {
     iosApp._onLivesync(context);
 };
 export * from './application-common';
+export * from './application-interfaces';
 export const Application = iosApp;
 export const AndroidApplication = undefined;
 function fontScaleChanged(origFontScale) {
@@ -1387,14 +1665,12 @@ export class AccessibilityServiceEnabledObservable extends CommonA11YServiceEnab
     }
 }
 let accessibilityServiceObservable;
-export function ensureClasses() {
+export function ensureA11yClasses() {
     if (accessibilityServiceObservable) {
         return;
     }
     setFontScaleCssClasses(new Map(VALID_FONT_SCALES.map((fs) => [fs, `a11y-fontscale-${Number(fs * 100).toFixed(0)}`])));
     accessibilityServiceObservable = new AccessibilityServiceEnabledObservable();
-    // Initialize SDK version CSS class once
-    initializeSdkVersionClass(Application.getRootView());
 }
 export function updateCurrentHelperClasses(applyRootCssClass) {
     const fontScale = getFontScale();
@@ -1463,7 +1739,7 @@ function applyFontScaleToRootViews() {
     rootModalViews.forEach((rootModalView) => (rootModalView.style.fontScaleInternal = fontScale));
 }
 export function initAccessibilityCssHelper() {
-    ensureClasses();
+    ensureA11yClasses();
     updateCurrentHelperClasses(applyRootCssClass);
     applyFontScaleToRootViews();
     Application.on(Application.fontScaleChangedEvent, () => {