diff --git a/apps/toolbox/src/main-page.ts b/apps/toolbox/src/main-page.ts
index da045f370e..4c04eb38a8 100644
--- a/apps/toolbox/src/main-page.ts
+++ b/apps/toolbox/src/main-page.ts
@@ -41,7 +41,7 @@ function setupSceneEvents() {
 			// Listen to scene events
 			Application.on(SceneEvents.sceneWillConnect, (args: SceneEventData) => {
 				console.log('New scene connecting:', args.scene);
-				console.log('Window:', args.window);
+				console.log('Window:', args.uiWindow);
 				console.log('Connection options:', args.connectionOptions);
 			});
 
diff --git a/apps/toolbox/src/pages/multiple-scenes.ts b/apps/toolbox/src/pages/multiple-scenes.ts
index 916c6449b4..f8ccac2353 100644
--- a/apps/toolbox/src/pages/multiple-scenes.ts
+++ b/apps/toolbox/src/pages/multiple-scenes.ts
@@ -1,523 +1,406 @@
-import { Observable, EventData, Page, Application, Frame, StackLayout, Label, Button, Dialogs, View, Color, SceneEvents, SceneEventData, Utils } from '@nativescript/core';
+import { Application, Button, Color, Dialogs, EventData, isAndroid, isIOS, Label, NativeWindowEvents, Observable, Page, StackLayout, WindowEvents } from '@nativescript/core';
+import type { NativeWindow, NativeWindowEventData, PrimaryWindowChangedEventData, WindowCloseEventData, WindowContentRequest, WindowOpenEventData } from '@nativescript/core';
 
-let page: Page;
 let viewModel: MultipleScenesModel;
 
 export function navigatingTo(args: EventData) {
-	page = <Page>args.object;
+	installWindowContentResolver();
 	viewModel = new MultipleScenesModel();
-	page.bindingContext = viewModel;
+	(<Page>args.object).bindingContext = viewModel;
 }
 
-export class MultipleScenesModel extends Observable {
-	private _sceneCount = 0;
-	private _isMultiSceneSupported = false;
-	private _currentScenes: any[] = [];
-	private _currentWindows: any[] = [];
-	private _sceneEvents: string[] = [];
+export function navigatingFrom(args: EventData) {
+	viewModel?.destroy();
+	viewModel = undefined;
+}
 
-	constructor() {
-		super();
-		this.checkSceneSupport();
-		this.setupSceneEventListeners();
-		this.updateSceneInfo();
-		this.checkSceneDelegateRegistration();
-	}
+/**
+ * The demo can open two different kinds of window. The kind is chosen when the window is
+ * requested and travels to the new window as `openWindow({ data })`.
+ */
+type DemoWindowKind = 'newSceneBasic' | 'newSceneAlt';
 
-	get sceneCount(): number {
-		return this._sceneCount;
-	}
+const DEMO_WINDOW_KINDS: Record<DemoWindowKind, { title: string; background: string; accent: string; titleColor: string }> = {
+	newSceneBasic: { title: 'Basic demo window', background: '#cdffdb', accent: '#ff4444', titleColor: '#1c4d2e' },
+	newSceneAlt: { title: 'Alternate demo window', background: '#65adf1', accent: '#006ead', titleColor: '#00305c' },
+};
 
-	get isMultiSceneSupported(): boolean {
-		return this._isMultiSceneSupported;
-	}
+/** Per-window events the demo mirrors into its log and its live window list. */
+const TRACKED_WINDOW_EVENTS: string[] = [NativeWindowEvents.attached, NativeWindowEvents.detached, NativeWindowEvents.activate, NativeWindowEvents.deactivate, NativeWindowEvents.background, NativeWindowEvents.foreground, NativeWindowEvents.contentLoaded, NativeWindowEvents.displayed, NativeWindowEvents.close, NativeWindowEvents.orientationChanged, NativeWindowEvents.systemAppearanceChanged, NativeWindowEvents.layoutDirectionChanged];
 
-	get currentScenes(): any[] {
-		return this._currentScenes;
-	}
+// --- Window content ---
 
-	get currentWindows(): any[] {
-		return this._currentWindows;
-	}
+let contentResolverInstalled = false;
 
-	get sceneEvents(): string[] {
-		return this._sceneEvents;
+function installWindowContentResolver() {
+	if (contentResolverInstalled) {
+		return;
 	}
+	contentResolverInstalled = true;
+
+	// The resolver stays installed for the rest of the process: a window that detaches and
+	// re-attaches (iOS scene reconnect, Android activity recreation) asks for its content
+	// again, long after this page may have been navigated away from.
+	Application.setWindowContentResolver(resolveWindowContent);
+}
 
-	get canCreateNewScene(): boolean {
-		return this._isMultiSceneSupported && __APPLE__;
+function resolveWindowContent(request: WindowContentRequest): Page | undefined {
+	// `data` is exactly what openWindow({ data }) was called with, carried across by the
+	// platform: NSUserActivity.userInfo on iOS, intent extras on Android.
+	const kind = request.data?.kind as DemoWindowKind;
+
+	// Returning undefined hands the window back to the default main-entry behaviour, which
+	// is what every window this demo did not open should get - the primary window, a cold
+	// start, or a window the system restored on its own.
+	if (request.isPrimary || !DEMO_WINDOW_KINDS[kind]) {
+		return undefined;
 	}
 
-	get statusText(): string {
-		if (!__APPLE__) {
-			return 'Scene support is only available on iOS';
-		}
-		if (!this._isMultiSceneSupported) {
-			return 'Multi-scene support not enabled. Add scene configuration to Info.plist';
-		}
+	viewModel?.logEvent(`content resolved for ${request.window.id} (${kind})`);
 
-		// Check which API is available
-		let apiInfo = '';
-		try {
-			if (typeof UIApplication !== 'undefined') {
-				const app = UIApplication.sharedApplication;
-				if (typeof app.activateSceneSessionForRequestErrorHandler === 'function') {
-					apiInfo = ' (iOS 17+ API available)';
-				} else if (typeof app.requestSceneSessionActivationUserActivityOptionsErrorHandler === 'function') {
-					apiInfo = ' (iOS 13-16 API available)';
-				}
-			}
-		} catch (e) {
-			// Ignore errors in API detection
-		}
+	return createDemoWindowPage(kind, request.window);
+}
 
-		return `Multi-scene support enabled. ${this._sceneCount} scene(s) active${apiInfo}`;
+/**
+ * Views built in plain code are only reachable through the closures that created them, so
+ * an unreferenced button can be collected while its window is still on screen and stop
+ * responding to taps. Holding the buttons here keeps them alive for the window's lifetime.
+ */
+const liveCloseButtons = new Set<Button>();
+
+function createDemoWindowPage(kind: DemoWindowKind, window: NativeWindow): Page {
+	const style = DEMO_WINDOW_KINDS[kind];
+
+	const page = new Page();
+	page.backgroundColor = new Color(style.background);
+
+	const layout = new StackLayout();
+	layout.padding = 32;
+	page.content = layout;
+
+	const title = new Label();
+	title.text = style.title;
+	title.fontSize = 32;
+	title.fontWeight = 'bold';
+	title.color = new Color(style.titleColor);
+	title.textAlignment = 'center';
+	title.textWrap = true;
+	title.marginBottom = 24;
+	layout.addChild(title);
+
+	const identity = new Label();
+	identity.text = `id: ${window.id}\nrole: ${window.role}\n${describeNativeSurface(window)}`;
+	identity.fontSize = 18;
+	identity.textAlignment = 'center';
+	identity.textWrap = true;
+	identity.marginBottom = 16;
+	layout.addChild(identity);
+
+	const traits = new Label();
+	traits.fontSize = 18;
+	traits.textAlignment = 'center';
+	traits.textWrap = true;
+	traits.marginBottom = 28;
+	const refreshTraits = () => {
+		traits.text = describeWindowTraits(window);
+	};
+	refreshTraits();
+	// Each window reports its own traits, so rotating or theming one window updates only it.
+	// No unsubscribe is needed: the framework drops every listener on a window right after
+	// its `close` event.
+	for (const eventName of [NativeWindowEvents.orientationChanged, NativeWindowEvents.systemAppearanceChanged, NativeWindowEvents.layoutDirectionChanged, NativeWindowEvents.attached, NativeWindowEvents.detached]) {
+		window.on(eventName, refreshTraits);
 	}
+	layout.addChild(traits);
+
+	const closeButton = new Button();
+	closeButton.text = 'Close this window';
+	closeButton.fontSize = 22;
+	closeButton.fontWeight = 'bold';
+	closeButton.backgroundColor = new Color(style.accent);
+	closeButton.color = new Color('white');
+	closeButton.borderRadius = 8;
+	closeButton.padding = 16;
+	closeButton.width = 300;
+	closeButton.horizontalAlignment = 'center';
+	closeButton.on('tap', () => window.close());
+	liveCloseButtons.add(closeButton);
+	window.on(NativeWindowEvents.close, () => liveCloseButtons.delete(closeButton));
+	layout.addChild(closeButton);
+
+	return page;
+}
 
-	private checkSceneSupport() {
-		if (__APPLE__) {
-			try {
-				// Check if the supportsScenes method exists and call it
-				if (typeof Application.ios.supportsScenes === 'function') {
-					this._isMultiSceneSupported = Application.ios.supportsScenes();
-				} else {
-					// Fallback: check for scene manifest in bundle
-					this._isMultiSceneSupported = false;
-					try {
-						const bundle = NSBundle.mainBundle;
-						const sceneManifest = bundle.objectForInfoDictionaryKey('UIApplicationSceneManifest');
-						this._isMultiSceneSupported = !!sceneManifest;
-					} catch (e) {
-						console.log('Error checking scene manifest:', e);
-					}
-				}
-				console.log('Scene support check:', this._isMultiSceneSupported);
-			} catch (error) {
-				console.log('Error checking scene support:', error);
-				this._isMultiSceneSupported = false;
-			}
-		}
-		this.notifyPropertyChange('isMultiSceneSupported', this._isMultiSceneSupported);
-		this.notifyPropertyChange('canCreateNewScene', this.canCreateNewScene);
-		this.notifyPropertyChange('statusText', this.statusText);
+// --- Window description helpers ---
+
+function describeNativeSurface(window: NativeWindow): string {
+	if (window.ios) {
+		const scene = window.ios.scene;
+		return scene ? `scene: ${scene.session.persistentIdentifier}` : 'no scene (pre-scene lifecycle)';
 	}
 
-	private setupSceneEventListeners() {
-		if (!__APPLE__) return;
+	if (window.android) {
+		const activity = window.android.activity;
+		return `activity: ${activity.getClass().getSimpleName()}@${activity.hashCode()}`;
+	}
 
-		// Listen to all scene lifecycle events
-		Application.on(SceneEvents.sceneWillConnect, (args: SceneEventData) => {
-			this.addSceneEvent(`Scene Will Connect: ${this.getSceneDescription(args.scene)}`);
-			this.updateSceneInfo();
-		});
+	return 'no native surface attached';
+}
 
-		Application.on(SceneEvents.sceneDidActivate, (args: SceneEventData) => {
-			this.addSceneEvent(`Scene Did Activate: ${this.getSceneDescription(args.scene)}`);
-			this.updateSceneInfo();
-		});
+function describeWindowTraits(window: NativeWindow): string {
+	return [window.isPrimary ? 'primary' : 'secondary', window.orientation(), window.systemAppearance() ?? 'appearance unknown', window.layoutDirection() ?? 'direction unknown'].join(' · ');
+}
 
-		Application.on(SceneEvents.sceneWillResignActive, (args: SceneEventData) => {
-			this.addSceneEvent(`Scene Will Resign Active: ${this.getSceneDescription(args.scene)}`);
-		});
+// --- Capability detection ---
 
-		Application.on(SceneEvents.sceneWillEnterForeground, (args: SceneEventData) => {
-			this.addSceneEvent(`Scene Will Enter Foreground: ${this.getSceneDescription(args.scene)}`);
-		});
+interface MultiWindowCapability {
+	canOpenWindows: boolean;
+	status: string;
+	note: string;
+	showIosSceneSetup: boolean;
+}
 
-		Application.on(SceneEvents.sceneDidEnterBackground, (args: SceneEventData) => {
-			this.addSceneEvent(`Scene Did Enter Background: ${this.getSceneDescription(args.scene)}`);
-		});
+/**
+ * Multi-window is a device/configuration capability, not a platform one: an iPhone and an
+ * iPad run the same iOS build but only one of them can show two scenes.
+ */
+function detectMultiWindowCapability(): MultiWindowCapability {
+	if (isIOS) {
+		if (!Application.ios.supportsScenes()) {
+			return {
+				canOpenWindows: false,
+				status: 'Scene lifecycle is off - the app is running the pre-scene UIApplication lifecycle.',
+				note: 'Per-window events below still work, but there can only ever be one window.',
+				showIosSceneSetup: true,
+			};
+		}
 
-		Application.on(SceneEvents.sceneDidDisconnect, (args: SceneEventData) => {
-			this.addSceneEvent(`Scene Did Disconnect: ${this.getSceneDescription(args.scene)}`);
-			this.updateSceneInfo();
-		});
+		if (!Application.ios.supportsMultipleScenes()) {
+			return {
+				canOpenWindows: false,
+				status: 'Scene lifecycle is on, but this device allows only one scene at a time.',
+				note: 'UIApplication.supportsMultipleScenes is false - either the device is an iPhone or UIApplicationSupportsMultipleScenes is missing from Info.plist. Try an iPad.',
+				showIosSceneSetup: false,
+			};
+		}
 
-		// Listen for scene content setup events to provide content for new scenes
-		Application.on(SceneEvents.sceneContentSetup, (args: SceneEventData) => {
-			this.addSceneEvent(`Setting up content for new scene: ${this.getSceneDescription(args.scene)}`);
-			this.setupSceneContent(args);
-		});
+		return {
+			canOpenWindows: true,
+			status: 'Scene lifecycle is on and this device allows multiple scenes.',
+			note: 'Each new window is a UIWindowScene. Use Split View or Stage Manager to see them side by side.',
+			showIosSceneSetup: false,
+		};
 	}
 
-	private getSceneDescription(scene: UIWindowScene): string {
-		if (!scene) return 'Unknown';
-		return `Scene ${this.getSceneId(scene)}`;
+	if (isAndroid) {
+		return {
+			canOpenWindows: true,
+			status: 'Windows map to activities launched into their own task.',
+			note: 'Application.openWindow() is experimental on Android. The activity launchMode in AndroidManifest.xml must allow a second instance (singleInstancePerTask or standard; the template default singleTask does not). Each window is its own task: on a phone the new one covers this one and both appear in recents; split screen, desktop windowing or a foldable shows them side by side.',
+			showIosSceneSetup: false,
+		};
 	}
 
-	private getSceneId(scene: UIWindowScene): string {
-		return scene?.hash ? `${scene?.hash}` : scene?.description || 'Unknown';
-	}
+	return {
+		canOpenWindows: false,
+		status: 'Multi-window is not available on this platform.',
+		note: '',
+		showIosSceneSetup: false,
+	};
+}
 
-	private setupSceneContent(args: SceneEventData) {
-		if (!args.scene || !args.window || !__APPLE__) return;
+interface WindowRow {
+	id: string;
+	summary: string;
+	traits: string;
+	native: string;
+	canClose: boolean;
+	requestClose: () => void;
+}
 
-		try {
-			let nsViewId: string;
-			if (args.connectionOptions?.userActivities?.count > 0) {
-				const activity = args.connectionOptions.userActivities.allObjects.objectAtIndex(0) as NSUserActivity;
-				nsViewId = Utils.dataDeserialize(activity.userInfo).id;
-			}
-			console.log('--- Open scene for nsViewId:', nsViewId);
-			let page: Page;
-			switch (nsViewId) {
-				case 'newSceneBasic':
-					page = this._createPageForScene(args.scene, args.window);
-					break;
-				case 'newSceneAlt':
-					page = this._createAltPageForScene(args.scene, args.window);
-					break;
-				// Note: can implement any number of other scene views
-			}
+export class MultipleScenesModel extends Observable {
+	private _capability = detectMultiWindowCapability();
+	private _windows: WindowRow[] = [];
+	private _events: string[] = [];
+	private _trackedWindows = new Map<string, { window: NativeWindow; handler: (args: NativeWindowEventData) => void }>();
+
+	private _onWindowOpen = (args: WindowOpenEventData) => {
+		this.logEvent(`windowOpen: ${args.window.id}`);
+		this.trackWindow(args.window);
+		this.refreshWindows();
+	};
+
+	private _onWindowClose = (args: WindowCloseEventData) => {
+		this.logEvent(`windowClose: ${args.window.id}`);
+		this.refreshWindows();
+	};
+
+	private _onPrimaryWindowChanged = (args: PrimaryWindowChangedEventData) => {
+		this.logEvent(`primaryWindowChanged: ${args.window.id}`);
+		this.refreshWindows();
+	};
 
-			console.log('setWindowRootView for:', args.window);
-			Application.ios.setWindowRootView(args.window, page);
-			this.addSceneEvent(`Content successfully set for scene: ${this.getSceneDescription(args.scene)}`);
-		} catch (error) {
-			this.addSceneEvent(`Error setting up scene content: ${error.message}`);
-		}
-	}
+	constructor() {
+		super();
 
-	/**
-	 * Note: When creating UI's with plain core, buttons will be garbage collected if not referenced.
-	 * Particularly when opening many new scenes.
-	 * If the button is GC'd by the system, the taps will no longer function.
-	 * This is more related to iOS delegates getting GC'd than anything.
-	 * Most flavors circumvent things like that because their components are retained.
-	 * We circumvent the core demo (xml ui) issue but just retaining a map of the created UI buttons.
-	 */
-	private _closeButtons = new Map<string, Button>();
-	private _createPageForScene(scene: UIWindowScene, window: UIWindow): Page {
-		const page = new Page();
-		page.backgroundColor = new Color('#cdffdb');
-		// Create a simple layout for the new scene
-		const layout = new StackLayout();
-		layout.padding = 32;
-
-		page.content = layout;
-
-		// Add title
-		const title = new Label();
-		title.text = 'New NativeScript Scene';
-		title.fontSize = 35;
-		title.fontWeight = 'bold';
-		title.textAlignment = 'center';
-		title.marginBottom = 30;
-		layout.addChild(title);
-
-		// Add scene info
-		const sceneInfo = new Label();
-		sceneInfo.text = `Scene ID: ${scene.hash || 'Unknown'}\nWindow: ${window.description || 'Unknown'}`;
-		sceneInfo.fontSize = 22;
-		sceneInfo.textAlignment = 'center';
-		sceneInfo.marginBottom = 25;
-		layout.addChild(sceneInfo);
-
-		// Add close button
-		const closeButton = new Button();
-		const sceneId = this.getSceneId(scene);
-		closeButton.id = sceneId;
-		console.log('scene assigning id to button:', closeButton.id);
-		closeButton.text = 'Close This Scene';
-		closeButton.fontSize = 22;
-		closeButton.fontWeight = 'bold';
-		closeButton.backgroundColor = new Color('#ff4444');
-		closeButton.color = new Color('white');
-		closeButton.borderRadius = 8;
-		closeButton.padding = 16;
-		closeButton.width = 300;
-		closeButton.horizontalAlignment = 'center';
-		closeButton.on('tap', this._closeScene.bind(this));
-		// retain the close button so we don't lose the tap (iOS delegate binding)
-		this._closeButtons.set(sceneId, closeButton);
-		layout.addChild(closeButton);
-
-		// Set up the layout as a root view (this creates the native iOS view)
-		page._setupAsRootView({});
-		return page;
-	}
+		Application.on(WindowEvents.windowOpen, this._onWindowOpen);
+		Application.on(WindowEvents.windowClose, this._onWindowClose);
+		Application.on(WindowEvents.primaryWindowChanged, this._onPrimaryWindowChanged);
 
-	private _createAltPageForScene(scene: UIWindowScene, window: UIWindow): Page {
-		const page = new Page();
-		page.backgroundColor = new Color('#65ADF1');
-		// Create a simple layout for the new scene
-		const layout = new StackLayout();
-		layout.padding = 32;
-
-		page.content = layout;
-
-		// Add title
-		const title = new Label();
-		title.text = 'New Alternate NativeScript Scene';
-		title.fontSize = 35;
-		title.color = new Color('blue');
-		title.fontWeight = 'bold';
-		title.textAlignment = 'center';
-		title.marginBottom = 35;
-		layout.addChild(title);
-
-		// Add scene info
-		const sceneInfo = new Label();
-		sceneInfo.text = `Scene ID: ${scene.hash || 'Unknown'}\nWindow: ${window.description || 'Unknown'}`;
-		sceneInfo.fontSize = 24;
-		sceneInfo.textAlignment = 'center';
-		sceneInfo.marginBottom = 32;
-		layout.addChild(sceneInfo);
-
-		// Add close button
-		const closeButton = new Button();
-		const sceneId = this.getSceneId(scene);
-		closeButton.id = sceneId;
-		console.log('scene assigning id to button:', closeButton.id);
-		closeButton.text = 'Close This Scene';
-		closeButton.fontSize = 25;
-		closeButton.fontWeight = 'bold';
-		closeButton.backgroundColor = new Color('#006ead');
-		closeButton.color = new Color('white');
-		closeButton.borderRadius = 8;
-		closeButton.padding = 16;
-		closeButton.width = 350;
-		closeButton.horizontalAlignment = 'center';
-		closeButton.on('tap', this._closeScene.bind(this));
-		// retain the close button so we don't lose the tap (iOS delegate binding)
-		this._closeButtons.set(sceneId, closeButton);
-		layout.addChild(closeButton);
-
-		// Set up the layout as a root view (this creates the native iOS view)
-		page._setupAsRootView({});
-		return page;
-	}
+		for (const window of Application.getWindows()) {
+			this.trackWindow(window);
+		}
 
-	private _closeScene(args: EventData) {
-		const btn = args.object as Button;
-		console.log('closing scene from button tap');
-		// Let core resolve the scene from the view/window context
-		Application.ios.closeWindow(btn);
+		this.refreshWindows();
 	}
 
-	private getSceneAPIInfo(): string {
-		if (!__APPLE__) return 'Not iOS';
-
-		try {
-			if (typeof UIApplication !== 'undefined') {
-				const app = UIApplication.sharedApplication;
+	destroy() {
+		Application.off(WindowEvents.windowOpen, this._onWindowOpen);
+		Application.off(WindowEvents.windowClose, this._onWindowClose);
+		Application.off(WindowEvents.primaryWindowChanged, this._onPrimaryWindowChanged);
 
-				if (typeof app.activateSceneSessionForRequestErrorHandler === 'function') {
-					return `iOS ${Utils.SDK_VERSION} - Modern API (iOS 17+) available`;
-				} else if (typeof app.requestSceneSessionActivationUserActivityOptionsErrorHandler === 'function') {
-					return `iOS ${Utils.SDK_VERSION} - Legacy API (iOS 13-16) available`;
-				} else {
-					return `iOS ${Utils.SDK_VERSION} - No scene activation API available`;
-				}
+		for (const { window, handler } of this._trackedWindows.values()) {
+			for (const eventName of TRACKED_WINDOW_EVENTS) {
+				window.off(eventName, handler);
 			}
-		} catch (e) {
-			return `Error detecting API: ${e.message}`;
 		}
-
-		return 'Unknown API status';
+		this._trackedWindows.clear();
 	}
 
-	private addSceneEvent(event: string) {
-		const timestamp = new Date().toLocaleTimeString();
-		const evt = `${timestamp}: ${event}`;
-		this._sceneEvents.unshift(evt);
-		console.log(evt);
+	get statusText(): string {
+		return this._capability.status;
+	}
 
-		// Keep only last 20 events
-		if (this._sceneEvents.length > 20) {
-			this._sceneEvents = this._sceneEvents.slice(0, 20);
-		}
+	get capabilityNote(): string {
+		return this._capability.note;
+	}
 
-		this.notifyPropertyChange('sceneEvents', this._sceneEvents);
+	get canOpenWindows(): boolean {
+		return this._capability.canOpenWindows;
 	}
 
-	private updateSceneInfo() {
-		if (__APPLE__ && this._isMultiSceneSupported) {
-			try {
-				this._currentScenes = Application.ios.getAllScenes() || [];
+	get showIosSceneSetup(): boolean {
+		return this._capability.showIosSceneSetup;
+	}
 
-				this._currentWindows = Application.ios.getAllWindows() || [];
+	get windowCount(): number {
+		return this._windows.length;
+	}
 
-				this._sceneCount = this._currentScenes.length;
-			} catch (error) {
-				console.log('Error getting scene info:', error);
-				this._sceneCount = 0;
-				this._currentScenes = [];
-				this._currentWindows = [];
-			}
-		} else {
-			this._sceneCount = 1; // Traditional single window
-			this._currentScenes = [];
-			this._currentWindows = [];
-		}
+	get windows(): WindowRow[] {
+		return this._windows;
+	}
 
-		this.notifyPropertyChange('sceneCount', this._sceneCount);
-		this.notifyPropertyChange('currentScenes', this._currentScenes);
-		this.notifyPropertyChange('currentWindows', this._currentWindows);
-		this.notifyPropertyChange('statusText', this.statusText);
+	get events(): string[] {
+		return this._events;
 	}
 
-	onCreateNewScene() {
-		Application.ios.openWindow({ id: 'newSceneBasic' });
+	onOpenBasicWindow() {
+		this.openWindow('newSceneBasic');
 	}
 
-	onCreateNewSceneAlt() {
-		Application.ios.openWindow({ id: 'newSceneAlt' });
+	onOpenAltWindow() {
+		this.openWindow('newSceneAlt');
 	}
 
-	onRefreshSceneInfo() {
-		this.updateSceneInfo();
-		this.addSceneEvent('Scene info refreshed');
+	onRefresh() {
+		this.refreshWindows();
+		this.logEvent('window list refreshed');
 	}
 
 	onClearEvents() {
-		this._sceneEvents = [];
-		this.notifyPropertyChange('sceneEvents', this._sceneEvents);
+		this._events = [];
+		this.notifyPropertyChange('events', this._events);
 	}
 
-	onShowSceneDetails() {
-		if (!__APPLE__) {
-			Dialogs.alert({
-				title: 'Scene Details',
-				message: 'Scene functionality is only available on iOS 13+',
-				okButtonText: 'OK',
-			});
-			return;
-		}
-
-		const apiInfo = this.getSceneAPIInfo();
-		const sceneInfo = this.getSceneAPIInfo(); // Using getSceneAPIInfo for now
+	onShowDetails() {
+		const lines = [this._capability.status, ''];
 
-		// Add SceneDelegate registration info
-		let delegateInfo = '\n--- SceneDelegate Status ---\n';
-		if (typeof global.SceneDelegate !== 'undefined') {
-			delegateInfo += '✅ SceneDelegate: Registered globally\n';
-		} else {
-			delegateInfo += '❌ SceneDelegate: NOT registered\n';
+		for (const window of Application.getWindows()) {
+			lines.push(`${window.id} · ${window.role} · ${window.state}`);
+			lines.push(`  ${describeWindowTraits(window)}`);
+			lines.push(`  ${describeNativeSurface(window)}`);
+			lines.push(`  root view: ${window.rootView ?? 'none'}`);
 		}
 
-		if (typeof UIWindowSceneDelegate !== 'undefined') {
-			delegateInfo += '✅ UIWindowSceneDelegate: Available\n';
-		} else {
-			delegateInfo += '❌ UIWindowSceneDelegate: Not available\n';
+		// getWindows() defaults to the view-carrying roles; 'all' also reports surfaces such
+		// as CarPlay or an external display, which host no NativeScript view tree.
+		const otherSurfaces = Application.getWindows('all').filter((surface) => surface.role !== 'application' && surface.role !== 'embedded');
+		if (otherSurfaces.length) {
+			lines.push('', 'Other surfaces:');
+			for (const surface of otherSurfaces) {
+				lines.push(`${surface.id} · ${surface.role} · ${surface.state}`);
+			}
 		}
 
-		const fullDetails = `${sceneInfo}\n\n${apiInfo}${delegateInfo}`;
-
-		// Show in alert dialog
-		const alertOptions = {
-			title: 'Scene & API Details',
-			message: fullDetails,
+		Dialogs.alert({
+			title: 'Window details',
+			message: lines.join('\n'),
 			okButtonText: 'OK',
-		};
+		});
+	}
+
+	logEvent(event: string) {
+		const entry = `${new Date().toLocaleTimeString()}: ${event}`;
+		console.log(entry);
 
-		Dialogs.alert(alertOptions);
+		this._events = [entry, ...this._events].slice(0, 30);
+		this.notifyPropertyChange('events', this._events);
 	}
-	onTestSceneAPI() {
-		const apiInfo = this.getSceneAPIInfo();
-		this.addSceneEvent(`API Test: ${apiInfo}`);
-
-		// Also log current scene/window counts
-		this.addSceneEvent(`Current state: ${this._currentScenes.length} scenes, ${this._currentWindows.length} windows`);
-
-		// Add device and system info
-		try {
-			const device = UIDevice.currentDevice;
-			this.addSceneEvent(`Device: ${device.model} (${device.systemName} ${device.systemVersion})`);
-
-			// Check if this is iPad (more likely to support multiple scenes)
-			if (device.userInterfaceIdiom === UIUserInterfaceIdiom.Pad) {
-				this.addSceneEvent('📱 iPad detected - better scene support expected');
-			} else {
-				this.addSceneEvent('📱 iPhone detected - limited scene support');
-			}
-		} catch (e) {
-			this.addSceneEvent('Could not get device info');
-		}
+
+	private openWindow(kind: DemoWindowKind) {
+		this.logEvent(`openWindow requested (${kind})`);
+		// The payload is handed to the new window's content request on both platforms.
+		Application.openWindow({ data: { kind } });
 	}
 
-	private checkSceneDelegateRegistration() {
-		if (!__APPLE__) {
+	private trackWindow(window: NativeWindow) {
+		if (this._trackedWindows.has(window.id)) {
 			return;
 		}
 
-		this.addSceneEvent('Checking SceneDelegate registration...');
+		const handler = (args: NativeWindowEventData) => {
+			this.logEvent(`${args.eventName}: ${window.id}`);
 
-		// Check if SceneDelegate is available globally
-		if (typeof global.SceneDelegate !== 'undefined') {
-			this.addSceneEvent('✅ SceneDelegate is registered globally');
-		} else {
-			this.addSceneEvent('❌ SceneDelegate NOT found in global scope!');
-		}
+			if (args.eventName === NativeWindowEvents.close) {
+				// The framework clears a window's listeners right after `close`, so only the
+				// demo's own reference has to go, otherwise the list would keep showing it.
+				this._trackedWindows.delete(window.id);
+			}
 
-		// Check if UIWindowSceneDelegate is available
-		if (typeof UIWindowSceneDelegate !== 'undefined') {
-			this.addSceneEvent('✅ UIWindowSceneDelegate protocol available');
-		} else {
-			this.addSceneEvent('❌ UIWindowSceneDelegate protocol not available');
+			this.refreshWindows();
+		};
+
+		for (const eventName of TRACKED_WINDOW_EVENTS) {
+			window.on(eventName, handler);
 		}
+
+		this._trackedWindows.set(window.id, { window, handler });
+	}
+
+	private refreshWindows() {
+		this._windows = Application.getWindows().map((window) => ({
+			id: window.id,
+			summary: `${window.id} · ${window.role} · ${window.state}`,
+			traits: describeWindowTraits(window),
+			native: describeNativeSurface(window),
+			canClose: !window.isPrimary && window.state !== 'closed',
+			requestClose: () => this.closeWindow(window.id),
+		}));
+
+		this.notifyPropertyChange('windows', this._windows);
+		this.notifyPropertyChange('windowCount', this._windows.length);
 	}
 
-	// private closeScene(scene: UIWindowScene) {
-	// 	if (!scene || !__APPLE__) return;
-
-	// 	try {
-	// 		this.addSceneEvent(`Attempting to close scene: ${this.getSceneDescription(scene)}`);
-
-	// 		// Get the scene session
-	// 		const session = scene.session;
-	// 		if (session) {
-	// 			// Check if this is the primary scene (typically can't be closed)
-	// 			const isPrimaryScene = Application.ios.getPrimaryScene() === scene;
-	// 			const sceneId = this.getSceneId(scene);
-	// 			console.log('isPrimaryScene:', isPrimaryScene, 'sceneId:', sceneId);
-
-	// 			if (isPrimaryScene) {
-	// 				this.addSceneEvent(`⚠️  This appears to be the primary scene`);
-	// 				this.addSceneEvent(`💡 Primary scenes typically cannot be closed programmatically`);
-	// 				return;
-	// 			} else {
-	// 				this.addSceneEvent(`✅ This appears to be a secondary scene - closure should work`);
-	// 			}
-
-	// 			// Try the correct iOS API for scene destruction
-	// 			const app = UIApplication.sharedApplication;
-
-	// 			if (app.requestSceneSessionDestructionOptionsErrorHandler) {
-	// 				this.addSceneEvent(`📞 Calling scene destruction API...`);
-	// 				app.requestSceneSessionDestructionOptionsErrorHandler(session, null, (error: NSError) => {
-	// 					if (error) {
-	// 						console.log('scene destroy error:', error);
-	// 						this.addSceneEvent(`❌ Scene destruction failed: ${error.localizedDescription}`);
-	// 						this.addSceneEvent(`📋 Error details - Domain: ${error.domain}, Code: ${error.code}`);
-
-	// 						// Provide specific guidance based on error
-	// 						if (error.localizedDescription.includes('primary') || error.code === 1) {
-	// 							this.addSceneEvent(`💡 Cannot close primary scene - this is iOS system behavior`);
-	// 							this.addSceneEvent(`ℹ️  Only secondary scenes can be closed via API`);
-	// 						} else if (error.code === 22 || error.domain.includes('FBSWorkspace')) {
-	// 							this.addSceneEvent(`💡 System declined scene destruction request`);
-	// 							this.addSceneEvent(`🔄 This may be due to system resource management`);
-	// 						} else {
-	// 							this.addSceneEvent(`🔍 Unexpected error - scene destruction may not be fully supported`);
-	// 						}
-
-	// 						this.addSceneEvent(`🖱️  Alternative: Use system UI to close (app switcher or split-screen controls)`);
-	// 					} else {
-	// 						this._closeButtons.delete(sceneId);
-	// 						this.addSceneEvent(`✅ Scene destruction request accepted`);
-	// 						this.addSceneEvent(`⏳ Scene should close within a few seconds...`);
-	// 					}
-	// 				});
-	// 			} else {
-	// 				this.addSceneEvent(`❌ Scene destruction API not available`);
-	// 				this.addSceneEvent(`📱 This iOS version/configuration may not support programmatic scene closure`);
-	// 			}
-	// 		} else {
-	// 			this.addSceneEvent('❌ Error: Could not find scene session to close');
-	// 		}
-	// 	} catch (error) {
-	// 		this.addSceneEvent(`❌ Error closing scene: ${error.message}`);
-	// 	}
-	// }
+	private closeWindow(id: string) {
+		const window = Application.getWindowById(id);
+
+		if (!window) {
+			this.logEvent(`no window registered with id ${id}`);
+			return;
+		}
+
+		this.logEvent(`close requested for ${id}`);
+		window.close();
+	}
 }
diff --git a/apps/toolbox/src/pages/multiple-scenes.xml b/apps/toolbox/src/pages/multiple-scenes.xml
index 50a8036701..2a464c8762 100644
--- a/apps/toolbox/src/pages/multiple-scenes.xml
+++ b/apps/toolbox/src/pages/multiple-scenes.xml
@@ -1,82 +1,95 @@
-<Page xmlns="http://schemas.nativescript.org/tns.xsd" navigatingTo="navigatingTo" class="page">
+<Page xmlns="http://schemas.nativescript.org/tns.xsd" navigatingTo="navigatingTo" navigatingFrom="navigatingFrom" class="page">
     <Page.actionBar>
-        <ActionBar title="Multiple Scenes Demo" class="action-bar">
+        <ActionBar title="Multiple Windows Demo" class="action-bar">
         </ActionBar>
     </Page.actionBar>
 
     <ScrollView>
         <StackLayout class="p-20">
-            
-            <!-- Scene Support Status -->
+
+            <!-- Capability status -->
             <StackLayout class="card p-20 m-b-20">
-                <Label text="Scene Support Status" class="h3 text-center m-b-15"/>
-                <Label text="{{ statusText }}" class="body text-center m-b-15" textWrap="true"/>
-                
-                <GridLayout columns="*, *" class="m-t-10">
-                    <Label col="0" text="Scene Count:" class="body"/>
-                    <Label col="1" text="{{ sceneCount }}" class="body font-weight-bold"/>
+                <Label text="Multi-window support" class="h3 text-center m-b-15"/>
+                <Label text="{{ statusText }}" class="body text-center m-b-10" textWrap="true"/>
+                <Label text="{{ capabilityNote }}" class="caption text-center m-b-15" textWrap="true"
+                       visibility="{{ capabilityNote ? 'visible' : 'collapsed' }}"/>
+
+                <GridLayout columns="*, auto" class="m-t-10">
+                    <Label col="0" text="Open windows:" class="body"/>
+                    <Label col="1" text="{{ windowCount }}" class="body font-weight-bold"/>
+                </GridLayout>
+
+                <GridLayout columns="*, *" class="m-t-15">
+                    <Button col="0" text="Refresh" tap="{{ onRefresh }}" class="btn btn-outline m-r-10"/>
+                    <Button col="1" text="Window details" tap="{{ onShowDetails }}" class="btn btn-outline m-l-10"/>
                 </GridLayout>
-                
-                <Button text="Refresh Info" tap="{{ onRefreshSceneInfo }}" class="btn btn-outline m-t-15"/>
             </StackLayout>
 
-            <!-- Scene Controls -->
-            <StackLayout class="card p-20 m-b-20" visibility="{{ canCreateNewScene ? 'visible' : 'collapsed' }}">
-                <Label text="Scene Controls (Test on Physical iPad Only)" class="h3 text-center m-b-15"/>
-                <Label text="Create additional windows on iPad (requires scene support enabled in Info.plist)" 
+            <!-- Window controls -->
+            <StackLayout class="card p-20 m-b-20" visibility="{{ canOpenWindows ? 'visible' : 'collapsed' }}">
+                <Label text="Open a window" class="h3 text-center m-b-15"/>
+                <Label text="Each button calls Application.openWindow() with a different payload. The window content resolver reads that payload and builds the matching UI."
                        class="caption text-center m-b-15" textWrap="true"/>
-                
-                <GridLayout columns="*,*,*" class="m-t-10">
-                    <Button col="0" text="New Scene" tap="{{ onCreateNewScene }}" class="btn btn-primary m-r-10"/>
-                    <Button col="1" text="New Alternate Scene" tap="{{ onCreateNewSceneAlt }}" class="btn btn-primary m-r-10"/>
-                    <Button col="2" text="Scene Details" tap="{{ onShowSceneDetails }}" class="btn btn-outline m-l-10"/>
+
+                <GridLayout columns="*, *" class="m-t-10">
+                    <Button col="0" text="Basic window" tap="{{ onOpenBasicWindow }}" class="btn btn-primary m-r-10"/>
+                    <Button col="1" text="Alternate window" tap="{{ onOpenAltWindow }}" class="btn btn-primary m-l-10"/>
                 </GridLayout>
-                
-                <Button text="Test API Info" tap="{{ onTestSceneAPI }}" class="btn btn-outline m-t-10"/>
             </StackLayout>
 
-            <!-- Configuration Help -->
-            <StackLayout class="card p-20 m-b-20" visibility="{{ isMultiSceneSupported ? 'collapsed' : 'visible' }}">
-                <Label text="Setup Instructions" class="h3 text-center m-b-15"/>
-                <Label text="To enable multi-scene support, add this to your Info.plist:" 
+            <!-- Live window list -->
+            <StackLayout class="card p-20 m-b-20">
+                <Label text="Windows" class="h3 text-center m-b-15"/>
+                <Label text="Updated live from the per-window lifecycle and trait events."
+                       class="caption text-center m-b-15" textWrap="true"/>
+
+                <Repeater items="{{ windows }}">
+                    <Repeater.itemTemplate>
+                        <StackLayout class="event-item p-10 m-b-10">
+                            <Label text="{{ summary }}" class="body font-weight-bold" textWrap="true"/>
+                            <Label text="{{ traits }}" class="caption" textWrap="true"/>
+                            <Label text="{{ native }}" class="caption" textWrap="true"/>
+                            <Button text="Close window" tap="{{ requestClose }}" class="btn btn-outline m-t-10"
+                                    visibility="{{ canClose ? 'visible' : 'collapsed' }}"/>
+                        </StackLayout>
+                    </Repeater.itemTemplate>
+                </Repeater>
+            </StackLayout>
+
+            <!-- iOS scene setup help -->
+            <StackLayout class="card p-20 m-b-20" visibility="{{ showIosSceneSetup ? 'visible' : 'collapsed' }}">
+                <Label text="Enable the iOS scene lifecycle" class="h3 text-center m-b-15"/>
+                <Label text="Add this to App_Resources/iOS/Info.plist and rebuild:"
                        class="body m-b-10" textWrap="true"/>
-                
+
                 <Label class="code-block m-b-15" textWrap="true">
                     <Span text="&lt;key&gt;UIApplicationSceneManifest&lt;/key&gt;&#10;"/>
                     <Span text="&lt;dict&gt;&#10;"/>
+                    <Span text="    &lt;key&gt;UIApplicationPreferredDefaultSceneSessionRole&lt;/key&gt;&#10;"/>
+                    <Span text="    &lt;string&gt;UIWindowSceneSessionRoleApplication&lt;/string&gt;&#10;"/>
                     <Span text="    &lt;key&gt;UIApplicationSupportsMultipleScenes&lt;/key&gt;&#10;"/>
                     <Span text="    &lt;true/&gt;&#10;"/>
-                    <Span text="    &lt;key&gt;UISceneConfigurations&lt;/key&gt;&#10;"/>
-                    <Span text="    &lt;dict&gt;&#10;"/>
-                    <Span text="        &lt;key&gt;UIWindowSceneSessionRoleApplication&lt;/key&gt;&#10;"/>
-                    <Span text="        &lt;array&gt;&#10;"/>
-                    <Span text="            &lt;dict&gt;&#10;"/>
-                    <Span text="                &lt;key&gt;UISceneDelegateClassName&lt;/key&gt;&#10;"/>
-                    <Span text="                &lt;string&gt;SceneDelegate&lt;/string&gt;&#10;"/>
-                    <Span text="            &lt;/dict&gt;&#10;"/>
-                    <Span text="        &lt;/array&gt;&#10;"/>
-                    <Span text="    &lt;/dict&gt;&#10;"/>
                     <Span text="&lt;/dict&gt;"/>
                 </Label>
-                
-                <Label text="After adding this configuration, rebuild and test on iPad for best multi-window experience." 
+
+                <Label text="Core registers its own scene delegate, so no UISceneDelegateClassName entry is needed."
                        class="caption" textWrap="true"/>
             </StackLayout>
 
-            <!-- Scene Events Log -->
+            <!-- Event log -->
             <StackLayout class="card p-20 m-b-20">
                 <GridLayout columns="*, auto" class="m-b-15">
-                    <Label col="0" text="Scene Events Log" class="h3"/>
+                    <Label col="0" text="Window events" class="h3"/>
                     <Button col="1" text="Clear" tap="{{ onClearEvents }}" class="btn btn-outline"/>
                 </GridLayout>
-                
+
                 <ScrollView height="250" class="border">
                     <StackLayout class="p-10">
-                        <Label visibility="{{ sceneEvents.length === 0 ? 'visible' : 'collapsed' }}" 
-                               text="No scene events yet. Scene events will appear here when scenes are created, activated, or destroyed."
+                        <Label visibility="{{ events.length === 0 ? 'visible' : 'collapsed' }}"
+                               text="No events yet. Open a window, rotate the device, or switch between light and dark mode."
                                class="caption text-center" textWrap="true"/>
-                        
-                        <Repeater items="{{ sceneEvents }}">
+
+                        <Repeater items="{{ events }}">
                             <Repeater.itemTemplate>
                                 <StackLayout class="event-item p-5">
                                     <Label text="{{ $value }}" class="caption" textWrap="true"/>
@@ -87,29 +100,26 @@
                 </ScrollView>
             </StackLayout>
 
-            <!-- Usage Instructions -->
+            <!-- How to test -->
             <StackLayout class="card p-20 m-b-20">
-                <Label text="How to Test" class="h3 text-center m-b-15"/>
-                
+                <Label text="How to test" class="h3 text-center m-b-15"/>
+
                 <StackLayout class="m-b-10">
-                    <Label text="1. iPad Testing:" class="body font-weight-bold"/>
-                    <Label text="• Use iPad with iOS 13+ for multi-window experience" class="caption m-l-15" textWrap="true"/>
-                    <Label text="• iOS 17+: Uses modern activateSceneSessionForRequestErrorHandler API" class="caption m-l-15" textWrap="true"/>
-                    <Label text="• iOS 13-16: Uses legacy requestSceneSessionActivation API" class="caption m-l-15" textWrap="true"/>
-                    <Label text="• Tap 'New Scene' to request additional windows" class="caption m-l-15" textWrap="true"/>
-                    <Label text="• Use split view or slide over gestures" class="caption m-l-15" textWrap="true"/>
+                    <Label text="iOS" class="body font-weight-bold"/>
+                    <Label text="• An iPad (or Stage Manager) is needed for a second scene; iPhone reports a single scene." class="caption m-l-15" textWrap="true"/>
+                    <Label text="• Drag the new window out of the app switcher to place it side by side." class="caption m-l-15" textWrap="true"/>
                 </StackLayout>
-                
+
                 <StackLayout class="m-b-10">
-                    <Label text="2. iPhone Testing:" class="body font-weight-bold"/>
-                    <Label text="• Scene events still work but limited to single window" class="caption m-l-15" textWrap="true"/>
-                    <Label text="• Watch background/foreground transitions" class="caption m-l-15" textWrap="true"/>
+                    <Label text="Android" class="body font-weight-bold"/>
+                    <Label text="• Windows are activities in their own task. The activity's launchMode in AndroidManifest.xml must be singleInstancePerTask (or standard); the template default singleTask reuses the existing activity and nothing opens." class="caption m-l-15" textWrap="true"/>
+                    <Label text="• On a phone the new window covers this one; open recents to see both. Put the app in split screen first and the new window opens in the other pane. Foldables and desktop windowing show them side by side." class="caption m-l-15" textWrap="true"/>
                 </StackLayout>
-                
+
                 <StackLayout>
-                    <Label text="3. Scene Events:" class="body font-weight-bold"/>
-                    <Label text="• Monitor the events log for scene lifecycle changes" class="caption m-l-15" textWrap="true"/>
-                    <Label text="• Each scene activation/deactivation is logged" class="caption m-l-15" textWrap="true"/>
+                    <Label text="Both" class="body font-weight-bold"/>
+                    <Label text="• Rotate one window or switch the system theme: only that window's row changes." class="caption m-l-15" textWrap="true"/>
+                    <Label text="• Background the app and return to it to watch the per-window foreground/background events." class="caption m-l-15" textWrap="true"/>
                 </StackLayout>
             </StackLayout>
 
diff --git a/packages/core/accessibility/accessibility-common.ts b/packages/core/accessibility/accessibility-common.ts
index 5eaea0569b..bf377e547b 100644
--- a/packages/core/accessibility/accessibility-common.ts
+++ b/packages/core/accessibility/accessibility-common.ts
@@ -240,6 +240,39 @@ export function getCurrentA11YServiceClass() {
 	return currentA11YServiceClass;
 }
 
+/**
+ * Applies the current accessibility state — the a11y service class, the font scale
+ * classes and the inherited font scale — to a root view.
+ *
+ * Runs for every window's root view; the `readyInit*` helpers next to it only wire up
+ * the process-wide listeners that keep this state current, and do so once.
+ */
+export function applyAccessibilityCssToRoot(rootView: View): void {
+	if (!rootView) {
+		return;
+	}
+
+	const a11yServiceClass = getCurrentA11YServiceClass();
+	if (a11yServiceClass) {
+		rootView.cssClasses.add(a11yServiceClass);
+	}
+
+	const fontScaleClass = getCurrentFontScaleClass();
+	if (fontScaleClass) {
+		rootView.cssClasses.add(fontScaleClass);
+	}
+
+	const fontScaleCategoryClass = getCurrentFontScaleCategory();
+	if (fontScaleCategoryClass) {
+		rootView.cssClasses.add(fontScaleCategoryClass);
+	}
+
+	const fontScale = getFontScale();
+	if (fontScale) {
+		rootView.style.fontScaleInternal = fontScale;
+	}
+}
+
 export enum AccessibilityTrait {
 	/**
 	 * The element allows direct touch interaction for VoiceOver users.
diff --git a/packages/core/application/application-common.ts b/packages/core/application/application-common.ts
index b9c474c82e..d784b2241f 100644
--- a/packages/core/application/application-common.ts
+++ b/packages/core/application/application-common.ts
@@ -11,41 +11,38 @@ import type { Frame } from '../ui/frame';
 import type { NavigationEntry } from '../ui/frame/frame-interfaces';
 import type { StyleScope } from '../ui/styling/style-scope';
 import type { AndroidApplication as AndroidApplicationType, iOSApplication as iOSApplicationType } from '.';
-import type { ApplicationEventData, CssChangedEventData, DiscardedErrorEventData, FontScaleChangedEventData, InitRootViewEventData, LaunchEventData, LoadAppCSSEventData, NativeScriptError, OrientationChangedEventData, SystemAppearanceChangedEventData, LayoutDirectionChangedEventData, UnhandledErrorEventData } from './application-interfaces';
-import { readyInitAccessibilityCssHelper, readyInitFontScale } from '../accessibility/accessibility-common';
-import { getAppMainEntry, isAppInBackground, setAppInBackground, setAppMainEntry } from './helpers-common';
+import type { ApplicationEventData, CssChangedEventData, DiscardedErrorEventData, FontScaleChangedEventData, InitRootViewEventData, LaunchEventData, LoadAppCSSEventData, NativeScriptError, OrientationChangedEventData, SystemAppearanceChangedEventData, LayoutDirectionChangedEventData, UnhandledErrorEventData, SceneOpenURLContextsEventData, SceneContinueUserActivityEventData, ScenePerformActionForShortcutItemEventData } from './application-interfaces';
+import { applyAccessibilityCssToRoot, readyInitAccessibilityCssHelper, readyInitFontScale } from '../accessibility/accessibility-common';
+import { getActiveWindow, getAppMainEntry, getAutoSystemAppearanceChanged, isAppInBackground, setActiveWindow, setAppInBackground, setAppMainEntry, setAutoSystemAppearanceChanged } from './helpers-common';
 import { getNativeScriptGlobals } from '../globals/global-utils';
 import { SDK_VERSION } from '../utils/constants';
+import type { NativeWindow, NativeWindowEventData, PrimaryWindowChangedEventData, WindowBase, WindowCloseEventData, WindowContentRequest, WindowContentResolver, WindowLayoutDirectionChangedEventData, WindowOpenEventData, WindowOpenOptions, WindowOrientationChangedEventData, WindowRole, WindowSystemAppearanceChangedEventData } from '../native-window';
+import { NativeWindowEvents, WindowEvents } from '../native-window/native-window-interfaces';
 
-// prettier-ignore
-const ORIENTATION_CSS_CLASSES = [
-	`${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.portrait}`,
-	`${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.landscape}`,
-	`${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.unknown}`,
-];
-
-// prettier-ignore
-const SYSTEM_APPEARANCE_CSS_CLASSES = [
-	`${CSSUtils.CLASS_PREFIX}${CoreTypes.SystemAppearance.light}`,
-	`${CSSUtils.CLASS_PREFIX}${CoreTypes.SystemAppearance.dark}`,
-];
-
-// prettier-ignore
-const LAYOUT_DIRECTION_CSS_CLASSES = [
-	`${CSSUtils.CLASS_PREFIX}${CoreTypes.LayoutDirection.ltr}`,
-	`${CSSUtils.CLASS_PREFIX}${CoreTypes.LayoutDirection.rtl}`,
-];
+const ORIENTATION_CSS_CLASSES = CSSUtils.ORIENTATION_CSS_CLASSES;
+const SYSTEM_APPEARANCE_CSS_CLASSES = CSSUtils.SYSTEM_APPEARANCE_CSS_CLASSES;
+const LAYOUT_DIRECTION_CSS_CLASSES = CSSUtils.LAYOUT_DIRECTION_CSS_CLASSES;
 
 const globalEvents = getNativeScriptGlobals().events;
 
 // Scene lifecycle event names
+/**
+ * @deprecated Use `NativeWindowEvents` from `@nativescript/core/native-window` instead.
+ */
 export const SceneEvents = {
+	/** @deprecated Use `NativeWindowEvents.sceneWillConnect` instead. */
 	sceneWillConnect: 'sceneWillConnect',
+	/** @deprecated Use `NativeWindowEvents.sceneDidActivate` instead. */
 	sceneDidActivate: 'sceneDidActivate',
+	/** @deprecated Use `NativeWindowEvents.sceneWillResignActive` instead. */
 	sceneWillResignActive: 'sceneWillResignActive',
+	/** @deprecated Use `NativeWindowEvents.sceneWillEnterForeground` instead. */
 	sceneWillEnterForeground: 'sceneWillEnterForeground',
+	/** @deprecated Use `NativeWindowEvents.sceneDidEnterBackground` instead. */
 	sceneDidEnterBackground: 'sceneDidEnterBackground',
+	/** @deprecated Use `NativeWindowEvents.sceneDidDisconnect` instead. */
 	sceneDidDisconnect: 'sceneDidDisconnect',
+	/** @deprecated Use the Application 'windowOpen' event and NativeWindow.setContent() instead. */
 	sceneContentSetup: 'sceneContentSetup',
 };
 
@@ -73,6 +70,11 @@ interface ApplicationEvents {
 	 */
 	on(event: 'launch', callback: (args: LaunchEventData) => void, thisArg?: any): void;
 
+	/**
+	 * This event is raised once the JS context is initialized.
+	 */
+	on(event: 'ready', callback: (args: ApplicationEventData) => void, thisArg?: any): void;
+
 	/**
 	 * This event is raised after the application has performed most of its startup actions.
 	 * Its intent is to be suitable for measuring app startup times.
@@ -92,6 +94,9 @@ interface ApplicationEvents {
 
 	/**
 	 * This event is raised when the Application is about to exit.
+	 *
+	 * On Android it is raised when the last window closes; the process may stay alive.
+	 * On iOS it is raised when the process itself terminates.
 	 */
 	on(event: 'exit', callback: (args: ApplicationEventData) => void, thisArg?: any): void;
 
@@ -129,15 +134,44 @@ interface ApplicationEvents {
 	on(event: 'layoutDirectionChanged', callback: (args: LayoutDirectionChangedEventData) => void, thisArg?: any): void;
 
 	on(event: 'fontScaleChanged', callback: (args: FontScaleChangedEventData) => void, thisArg?: any): void;
+
+	on(event: 'windowOpen', callback: (args: WindowOpenEventData) => void, thisArg?: any): void;
+	on(event: 'windowClose', callback: (args: WindowCloseEventData) => void, thisArg?: any): void;
+	on(event: 'primaryWindowChanged', callback: (args: PrimaryWindowChangedEventData) => void, thisArg?: any): void;
+
+	on(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	on(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
 }
 
 export class ApplicationCommon {
+	/**
+	 * @deprecated Use the 'ready' event for application initialization and Application.setWindowContentResolver() to provide window UI. 'launch' continues to fire before the first window's content is created, and its 'root' property is still honored, for backwards compatibility. It will not fire for additional windows or for background launches.
+	 */
 	readonly launchEvent = 'launch';
+	/**
+	 * Raised once per JS context, as soon as the context is initialized. It is never deferred,
+	 * so it also fires on a background launch where no window is created.
+	 *
+	 * Guaranteed ordering: `ready` -> `windowOpen` -> raw connect/create events -> content
+	 * resolution (the legacy `launch` bridge runs here, for the first window only) ->
+	 * `contentLoaded` -> `activate`/`displayed`.
+	 */
+	readonly readyEvent = 'ready';
+	/**
+	 * Reflects whole-app state: with multiple windows it is raised once the app itself is
+	 * no longer in the foreground, not when an individual window backgrounds. Listen on a
+	 * NativeWindow for per-window state.
+	 */
 	readonly suspendEvent = 'suspend';
 	readonly displayedEvent = 'displayed';
 	readonly backgroundEvent = 'background';
 	readonly foregroundEvent = 'foreground';
 	readonly resumeEvent = 'resume';
+	/**
+	 * On Android, raised when the last window closes; the process may stay alive.
+	 * On iOS, raised when the process itself terminates.
+	 */
 	readonly exitEvent = 'exit';
 	readonly lowMemoryEvent = 'lowMemory';
 	readonly uncaughtErrorEvent = 'uncaughtError';
@@ -150,6 +184,9 @@ export class ApplicationCommon {
 	readonly loadAppCssEvent = 'loadAppCss';
 	readonly cssChangedEvent = 'cssChanged';
 	readonly initRootViewEvent = 'initRootView';
+	readonly windowOpenEvent = WindowEvents.windowOpen;
+	readonly windowCloseEvent = WindowEvents.windowClose;
+	readonly primaryWindowChangedEvent = WindowEvents.primaryWindowChanged;
 
 	// Expose statically for backwards compat on AndroidApplication.on etc.
 	/**
@@ -186,6 +223,10 @@ export class ApplicationCommon {
 	private _inBackground: boolean = false;
 	private _suspended: boolean = false;
 	private _cssFile = './app.css';
+	private _readyNotified = false;
+	private _appCssLoaded = false;
+	private _launchBridgeConsumed = false;
+	private _windowContentResolver: WindowContentResolver | null = null;
 
 	protected mainEntry: NavigationEntry;
 
@@ -193,7 +234,13 @@ export class ApplicationCommon {
 	/**
 	 * Boolean to enable/disable systemAppearanceChanged
 	 */
-	public autoSystemAppearanceChanged = true;
+	public get autoSystemAppearanceChanged(): boolean {
+		return getAutoSystemAppearanceChanged();
+	}
+
+	public set autoSystemAppearanceChanged(value: boolean) {
+		setAutoSystemAppearanceChanged(value);
+	}
 
 	/**
 	 * @internal - should not be constructed by the user.
@@ -288,6 +335,28 @@ export class ApplicationCommon {
 		rootView.cssClasses.delete(cssClass);
 	}
 
+	/**
+	 * Same as {@link applyCssClass}, minus the system class list: window-scoped classes
+	 * must not leak into it, because it seeds every window's root view.
+	 */
+	private applyWindowScopedCssClass(rootView: View, cssClasses: string[], newCssClass: string): void {
+		if (rootView.cssClasses.has(newCssClass)) {
+			return;
+		}
+
+		cssClasses.forEach((cssClass) => rootView.cssClasses.delete(cssClass));
+		rootView.cssClasses.add(newCssClass);
+		this.increaseStyleScopeApplicationCssSelectorVersion(rootView);
+	}
+
+	/**
+	 * The modal registry is process-wide, so only the modals presented over this root
+	 * view may follow its window-scoped classes.
+	 */
+	private getOwnedModalViews(rootView: View): View[] {
+		return (<Array<View>>rootView._getRootModalViews()).filter((modalView) => modalView._getRootModalHost() === rootView);
+	}
+
 	private increaseStyleScopeApplicationCssSelectorVersion(rootView: View) {
 		const styleScope: StyleScope = rootView._styleScope ?? (rootView as Frame)?.currentPage?._styleScope;
 
@@ -296,12 +365,12 @@ export class ApplicationCommon {
 		}
 	}
 
-	private setRootViewCSSClasses(rootView: View): void {
+	private setRootViewCSSClasses(rootView: View, window?: NativeWindow): void {
 		const platform = Device.os.toLowerCase();
 		const deviceType = Device.deviceType.toLowerCase();
-		const orientation = this.orientation();
-		const systemAppearance = this.systemAppearance();
-		const layoutDirection = this.layoutDirection();
+		const orientation = window ? window.orientation() : this.orientation();
+		const systemAppearance = window ? window.systemAppearance() : this.systemAppearance();
+		const layoutDirection = window ? window.layoutDirection() : this.layoutDirection();
 
 		if (platform) {
 			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${platform}`);
@@ -317,22 +386,24 @@ export class ApplicationCommon {
 			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${deviceType}`);
 		}
 
+		rootView.cssClasses.add(CSSUtils.ROOT_VIEW_CSS_CLASS);
+		const rootViewCssClasses = CSSUtils.getSystemCssClasses();
+		rootViewCssClasses.forEach((c) => rootView.cssClasses.add(c));
+
+		// Two windows can disagree on these, so they never reach the process-wide
+		// system class list — see CSSUtils.WINDOW_SCOPED_CSS_CLASSES.
 		if (orientation) {
-			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${orientation}`);
+			rootView.cssClasses.add(`${CSSUtils.CLASS_PREFIX}${orientation}`);
 		}
 
 		if (systemAppearance) {
-			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${systemAppearance}`);
+			rootView.cssClasses.add(`${CSSUtils.CLASS_PREFIX}${systemAppearance}`);
 		}
 
 		if (layoutDirection) {
-			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${layoutDirection}`);
+			rootView.cssClasses.add(`${CSSUtils.CLASS_PREFIX}${layoutDirection}`);
 		}
 
-		rootView.cssClasses.add(CSSUtils.ROOT_VIEW_CSS_CLASS);
-		const rootViewCssClasses = CSSUtils.getSystemCssClasses();
-		rootViewCssClasses.forEach((c) => rootView.cssClasses.add(c));
-
 		this.increaseStyleScopeApplicationCssSelectorVersion(rootView);
 		rootView._onCssStateChange();
 
@@ -366,8 +437,360 @@ export class ApplicationCommon {
 		return getAppMainEntry();
 	}
 
+	/**
+	 * Sets the callback that supplies the UI for windows that need content.
+	 * Pass `null` to remove a previously set resolver.
+	 */
+	setWindowContentResolver(resolver: WindowContentResolver | null): void {
+		this._windowContentResolver = resolver ?? null;
+	}
+
+	/**
+	 * @returns The callback currently supplying window content, if any.
+	 */
+	getWindowContentResolver(): WindowContentResolver | null {
+		return this._windowContentResolver;
+	}
+
+	// --- NativeWindow registry ---
+
+	protected _windows: NativeWindow[] = [];
+
+	/**
+	 * Get the primary NativeWindow.
+	 */
+	get primaryWindow(): NativeWindow | undefined {
+		return this._windows.find((nw) => nw.isPrimary);
+	}
+
+	/**
+	 * Get the NativeWindow the user is currently interacting with - the one that activated most
+	 * recently and is still attached. Falls back to the primary window while no window holds
+	 * activation, which is the case before the first window activates and on a platform that
+	 * never raises `activate`.
+	 */
+	get activeWindow(): NativeWindow | undefined {
+		const active = getActiveWindow();
+		if (active && active.state === 'attached' && this._windows.indexOf(active) !== -1) {
+			return active;
+		}
+
+		return this.primaryWindow;
+	}
+
+	/**
+	 * Get the active windows, filtered by role.
+	 *
+	 * Defaults to the view-carrying app windows (`application` and `embedded`).
+	 * Pass `'all'` to include every registered surface, including ones that carry no view tree.
+	 */
+	getWindows(role: 'all'): WindowBase[];
+	getWindows(role?: WindowRole | WindowRole[]): NativeWindow[];
+	getWindows(role?: WindowRole | WindowRole[] | 'all'): WindowBase[];
+	getWindows(role?: WindowRole | WindowRole[] | 'all'): WindowBase[] {
+		if (role === 'all') {
+			return [...this._windows];
+		}
+		const roles: WindowRole[] = role ? (Array.isArray(role) ? role : [role]) : ['application', 'embedded'];
+		return this._windows.filter((nw) => roles.indexOf(nw.role) !== -1);
+	}
+
+	/**
+	 * Get a registered NativeWindow by its id.
+	 */
+	getWindowById(id: string): NativeWindow | undefined {
+		return this._windows.find((nw) => nw.id === id);
+	}
+
+	/**
+	 * Opens a new window.
+	 *
+	 * @param options Options for the new window, including data to hand to it.
+	 */
+	openWindow(options?: WindowOpenOptions): void {
+		throw new Error('openWindow() is not supported on this platform.');
+	}
+
+	/**
+	 * @internal - Get all registered NativeWindows, whatever their role.
+	 */
+	_getWindows(): NativeWindow[] {
+		return [...this._windows];
+	}
+
+	/**
+	 * @internal - Register a NativeWindow created by the platform lifecycle.
+	 */
+	_registerWindow(nativeWindow: NativeWindow): void {
+		this._windows.push(nativeWindow);
+
+		// A closing window drops its own listeners, so this is never explicitly removed.
+		nativeWindow.on(NativeWindowEvents.activate, this.onWindowActivated, this);
+
+		if (nativeWindow.isPrimary) {
+			this.trackPrimaryWindowTraits(nativeWindow);
+		}
+
+		this._onWindowRegistered(nativeWindow);
+
+		this.notify({
+			eventName: this.windowOpenEvent,
+			object: this,
+			window: nativeWindow,
+		});
+	}
+
+	/**
+	 * @internal - Unregister a NativeWindow when its native surface is gone for good.
+	 */
+	_unregisterWindow(nativeWindow: NativeWindow): void {
+		const idx = this._windows.indexOf(nativeWindow);
+		if (idx >= 0) {
+			this._windows.splice(idx, 1);
+		}
+
+		if (getActiveWindow() === nativeWindow) {
+			setActiveWindow(undefined);
+		}
+
+		this.notify({
+			eventName: this.windowCloseEvent,
+			object: this,
+			window: nativeWindow,
+		});
+
+		// If primary was removed, promote the next window that can actually host content
+		if (nativeWindow.isPrimary) {
+			nativeWindow._setIsPrimary(false);
+
+			const promoted = this.getWindows().find((nw) => nw.state === 'attached');
+			this.trackPrimaryWindowTraits(promoted);
+
+			if (promoted) {
+				promoted._setIsPrimary(true);
+				this._onPrimaryWindowPromoted(promoted);
+				this.notify({
+					eventName: this.primaryWindowChangedEvent,
+					object: this,
+					window: promoted,
+				});
+			}
+		}
+
+		nativeWindow._destroy();
+	}
+
+	/**
+	 * Hook for platform-specific bookkeeping right after a window joins the registry,
+	 * before `windowOpen` is raised.
+	 */
+	protected _onWindowRegistered(nativeWindow: NativeWindow): void {
+		// noop
+	}
+
+	/**
+	 * Hook for platform-specific bookkeeping right after a window takes over the primary
+	 * role, before `primaryWindowChanged` is raised.
+	 */
+	protected _onPrimaryWindowPromoted(nativeWindow: NativeWindow): void {
+		// noop
+	}
+
+	// --- Primary window traits ---
+
+	private _traitsWindow: NativeWindow | null = null;
+
+	/**
+	 * Points the application-level orientation, appearance and layout direction at the
+	 * primary window, which owns those values now that each window has its own.
+	 */
+	private trackPrimaryWindowTraits(nativeWindow: NativeWindow | undefined): void {
+		const target = nativeWindow ?? null;
+		if (this._traitsWindow === target) {
+			return;
+		}
+
+		const previous = this._traitsWindow;
+		if (previous) {
+			previous.off(NativeWindowEvents.orientationChanged, this.onWindowOrientationChanged, this);
+			previous.off(NativeWindowEvents.systemAppearanceChanged, this.onWindowSystemAppearanceChanged, this);
+			previous.off(NativeWindowEvents.layoutDirectionChanged, this.onWindowLayoutDirectionChanged, this);
+		}
+
+		this._traitsWindow = target;
+
+		if (!target) {
+			return;
+		}
+
+		target.on(NativeWindowEvents.orientationChanged, this.onWindowOrientationChanged, this);
+		target.on(NativeWindowEvents.systemAppearanceChanged, this.onWindowSystemAppearanceChanged, this);
+		target.on(NativeWindowEvents.layoutDirectionChanged, this.onWindowLayoutDirectionChanged, this);
+
+		this.syncTraitsFromWindow(target);
+	}
+
+	/**
+	 * Adopts the window's values. The very first window seeds them quietly — there is no
+	 * previous application state for it to differ from — while a later promotion raises
+	 * the change events, because app code observed the outgoing window's values.
+	 */
+	private syncTraitsFromWindow(nativeWindow: NativeWindow): void {
+		const orientation = nativeWindow.orientation();
+		if (orientation) {
+			if (this._orientation === undefined) {
+				this._orientation = orientation;
+			} else {
+				this.setOrientation(orientation);
+			}
+		}
+
+		const systemAppearance = nativeWindow.systemAppearance();
+		if (systemAppearance) {
+			if (this._systemAppearance === undefined) {
+				this._systemAppearance = systemAppearance;
+			} else {
+				this.setSystemAppearance(systemAppearance);
+			}
+		}
+
+		const layoutDirection = nativeWindow.layoutDirection();
+		if (layoutDirection) {
+			if (this._layoutDirection === undefined) {
+				this._layoutDirection = layoutDirection;
+			} else {
+				this.setLayoutDirection(layoutDirection);
+			}
+		}
+	}
+
+	private onWindowActivated(data: NativeWindowEventData): void {
+		setActiveWindow(data.window);
+	}
+
+	private onWindowOrientationChanged(data: WindowOrientationChangedEventData): void {
+		this.setOrientation(data.newValue);
+	}
+
+	private onWindowSystemAppearanceChanged(data: WindowSystemAppearanceChangedEventData): void {
+		this.setSystemAppearance(data.newValue);
+	}
+
+	private onWindowLayoutDirectionChanged(data: WindowLayoutDirectionChangedEventData): void {
+		this.setLayoutDirection(data.newValue);
+	}
+
+	/**
+	 * @internal - raises `ready` at most once per JS context.
+	 */
+	notifyReady(): void {
+		if (this._readyNotified) {
+			return;
+		}
+		this._readyNotified = true;
+		getNativeScriptGlobals().setLaunched();
+
+		this.notify(<ApplicationEventData>{
+			eventName: this.readyEvent,
+			object: this,
+			ios: this.ios,
+			android: this.android,
+		});
+	}
+
+	/**
+	 * @internal - produces the content for a window that has none.
+	 *
+	 * Resolution order: the window content resolver, then the legacy `launch` event
+	 * (offered to the first window that asks for content and to no other), then the
+	 * application main entry. A resolver or a `launch` handler returning `null` takes
+	 * ownership of the content, so nothing else is tried. A missing main entry leaves
+	 * the window empty instead of throwing, because content can still arrive later
+	 * through `run()`/`resetRootView()`.
+	 *
+	 * @param options.install `false` returns the resolved view instead of applying it,
+	 * for platform pipelines that install the root view on the native surface themselves.
+	 * @param options.launchData platform payload merged into the legacy `launch` event args.
+	 * @returns The resolved view, or `null` when no content was produced.
+	 */
+	_resolveWindowContent(window: NativeWindow, request: WindowContentRequest, options?: { install?: boolean; launchData?: any }): View | null {
+		const content = this.resolveWindowContent(request, options?.launchData);
+
+		if (content == null) {
+			return null;
+		}
+
+		if (options?.install === false) {
+			return this.buildContentView(content);
+		}
+
+		window.setContent(content);
+
+		return window.rootView;
+	}
+
+	private resolveWindowContent(request: WindowContentRequest, launchData?: any): View | NavigationEntry | string | null | undefined {
+		const launchBridgeAvailable = !this._launchBridgeConsumed;
+		this._launchBridgeConsumed = true;
+
+		const resolver = this._windowContentResolver;
+		if (resolver) {
+			const resolved = resolver(request);
+
+			// `null` means the resolver supplies the content itself; only `undefined` falls through.
+			if (resolved !== undefined) {
+				this._ensureAppCssLoaded();
+
+				return resolved;
+			}
+		}
+
+		if (launchBridgeAvailable) {
+			const root = this.notifyLaunch(launchData);
+
+			if (root === null) {
+				return null;
+			}
+
+			if (root) {
+				return root;
+			}
+		}
+
+		this._ensureAppCssLoaded();
+
+		const mainEntry = getAppMainEntry();
+
+		return mainEntry ? Builder.createViewFromEntry(mainEntry) : undefined;
+	}
+
+	private buildContentView(content: View | NavigationEntry | string): View {
+		if (typeof content === 'string') {
+			return Builder.createViewFromEntry({ moduleName: content });
+		}
+
+		const entry = content as NavigationEntry;
+
+		return entry.moduleName || entry.create ? Builder.createViewFromEntry(entry) : (content as View);
+	}
+
+	/**
+	 * Loads the app CSS once per JS context. On the legacy `launch` path this has to run
+	 * after the handlers, which are allowed to call `setCssFileName()`.
+	 */
+	private _ensureAppCssLoaded(): void {
+		if (this._appCssLoaded) {
+			return;
+		}
+		this._appCssLoaded = true;
+
+		this.loadAppCss();
+	}
+
 	@profile
 	protected notifyLaunch(additionalLanchEventData?: any): View | null {
+		this._launchBridgeConsumed = true;
+
 		const launchArgs: LaunchEventData = {
 			eventName: this.launchEvent,
 			object: this,
@@ -376,7 +799,7 @@ export class ApplicationCommon {
 			...additionalLanchEventData,
 		};
 		this.notify(launchArgs);
-		this.loadAppCss();
+		this._ensureAppCssLoaded();
 
 		return launchArgs.root;
 	}
@@ -417,10 +840,15 @@ export class ApplicationCommon {
 		// rest of implementation is platform specific
 	}
 
-	initRootView(rootView: View) {
-		this.setRootViewCSSClasses(rootView);
+	/**
+	 * @param window the window the root view belongs to. Supplies the window-scoped CSS
+	 * classes; without it they come from the primary window.
+	 */
+	initRootView(rootView: View, window?: NativeWindow) {
+		this.setRootViewCSSClasses(rootView, window);
 		readyInitAccessibilityCssHelper();
 		readyInitFontScale();
+		applyAccessibilityCssToRoot(rootView);
 		this.notify(<InitRootViewEventData>{ eventName: this.initRootViewEvent, rootView });
 	}
 
@@ -523,8 +951,11 @@ export class ApplicationCommon {
 		});
 	}
 
+	/**
+	 * @deprecated Use Application.primaryWindow?.orientation() - or the NativeWindow of the relevant view - instead. Continues to reflect the primary window.
+	 */
 	orientation(): 'portrait' | 'landscape' | 'unknown' {
-		return (this._orientation ??= this.getOrientation());
+		return this.primaryWindow?.orientation() ?? (this._orientation ??= this.getOrientation());
 	}
 
 	orientationChanged(rootView: View, newOrientation: 'portrait' | 'landscape' | 'unknown'): void {
@@ -533,11 +964,10 @@ export class ApplicationCommon {
 		}
 
 		const newOrientationCssClass = `${CSSUtils.CLASS_PREFIX}${newOrientation}`;
-		this.applyCssClass(rootView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
+		this.applyWindowScopedCssClass(rootView, ORIENTATION_CSS_CLASSES, newOrientationCssClass);
 
-		const rootModalViews = <Array<View>>rootView._getRootModalViews();
-		rootModalViews.forEach((rootModalView) => {
-			this.applyCssClass(rootModalView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
+		this.getOwnedModalViews(rootView).forEach((rootModalView) => {
+			this.applyWindowScopedCssClass(rootModalView, ORIENTATION_CSS_CLASSES, newOrientationCssClass);
 
 			// Trigger state change for root modal view classes and media queries
 			rootModalView._onCssStateChange();
@@ -576,16 +1006,18 @@ export class ApplicationCommon {
 		});
 	}
 
+	/**
+	 * @deprecated Use Application.primaryWindow?.systemAppearance() - or the NativeWindow of the relevant view - instead. Continues to reflect the primary window.
+	 */
 	systemAppearance(): 'dark' | 'light' | null {
-		// return cached value, or get it from the platform specific override
-		return (this._systemAppearance ??= this.getSystemAppearance());
+		return this.primaryWindow?.systemAppearance() ?? (this._systemAppearance ??= this.getSystemAppearance());
 	}
 
 	/**
 	 * enable/disable systemAppearanceChanged
 	 */
 	setAutoSystemAppearanceChanged(value: boolean): void {
-		this.autoSystemAppearanceChanged = value;
+		setAutoSystemAppearanceChanged(value);
 	}
 
 	/**
@@ -599,11 +1031,10 @@ export class ApplicationCommon {
 		}
 
 		const newSystemAppearanceCssClass = `${CSSUtils.CLASS_PREFIX}${newSystemAppearance}`;
-		this.applyCssClass(rootView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
+		this.applyWindowScopedCssClass(rootView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass);
 
-		const rootModalViews = rootView._getRootModalViews();
-		rootModalViews.forEach((rootModalView) => {
-			this.applyCssClass(rootModalView as View, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
+		this.getOwnedModalViews(rootView).forEach((rootModalView) => {
+			this.applyWindowScopedCssClass(rootModalView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass);
 
 			// Trigger state change for root modal view classes and media queries
 			rootModalView._onCssStateChange();
@@ -633,9 +1064,11 @@ export class ApplicationCommon {
 		});
 	}
 
+	/**
+	 * @deprecated Use Application.primaryWindow?.layoutDirection() - or the NativeWindow of the relevant view - instead. Continues to reflect the primary window.
+	 */
 	layoutDirection(): CoreTypes.LayoutDirectionType | null {
-		// return cached value, or get it from the platform specific override
-		return (this._layoutDirection ??= this.getLayoutDirection());
+		return this.primaryWindow?.layoutDirection() ?? (this._layoutDirection ??= this.getLayoutDirection());
 	}
 
 	/**
@@ -649,11 +1082,10 @@ export class ApplicationCommon {
 		}
 
 		const newLayoutDirectionCssClass = `${CSSUtils.CLASS_PREFIX}${newLayoutDirection}`;
-		this.applyCssClass(rootView, LAYOUT_DIRECTION_CSS_CLASSES, newLayoutDirectionCssClass, true);
+		this.applyWindowScopedCssClass(rootView, LAYOUT_DIRECTION_CSS_CLASSES, newLayoutDirectionCssClass);
 
-		const rootModalViews = rootView._getRootModalViews();
-		rootModalViews.forEach((rootModalView) => {
-			this.applyCssClass(rootModalView as View, LAYOUT_DIRECTION_CSS_CLASSES, newLayoutDirectionCssClass, true);
+		this.getOwnedModalViews(rootView).forEach((rootModalView) => {
+			this.applyWindowScopedCssClass(rootModalView, LAYOUT_DIRECTION_CSS_CLASSES, newLayoutDirectionCssClass);
 
 			// Trigger state change for root modal view classes and media queries
 			rootModalView._onCssStateChange();
diff --git a/packages/core/application/application-interfaces.ts b/packages/core/application/application-interfaces.ts
index f597a63bd5..45460adac5 100644
--- a/packages/core/application/application-interfaces.ts
+++ b/packages/core/application/application-interfaces.ts
@@ -1,6 +1,7 @@
 import type { EventData, Observable } from '../data/observable';
 import type { View } from '../ui/core/view';
 import type { CoreTypes } from '../core-types';
+import type { NativeWindow } from '../native-window';
 
 /**
  * An extended JavaScript Error which will have the nativeError property initialized in case the error is caused by executing platform-specific code.
@@ -143,6 +144,11 @@ export interface AndroidActivityEventData {
 	 */
 	activity: androidx.appcompat.app.AppCompatActivity;
 
+	/**
+	 * The NativeWindow the activity belongs to, when one is registered for it.
+	 */
+	window?: NativeWindow;
+
 	/**
 	 * The name of the event.
 	 */
@@ -240,7 +246,12 @@ export interface SceneEventData extends ApplicationEventData {
 	/**
 	 * The UIWindow associated with this scene (if applicable).
 	 */
-	window?: UIWindow;
+	uiWindow?: UIWindow;
+
+	/**
+	 * The NativeWindow the scene belongs to, when one is registered for it.
+	 */
+	window?: NativeWindow;
 
 	/**
 	 * Scene connection options (for sceneWillConnect event).
@@ -252,3 +263,56 @@ export interface SceneEventData extends ApplicationEventData {
 	 */
 	userInfo?: NSDictionary<any, any>;
 }
+
+/**
+ * iOS event data for the `sceneOpenURLContexts` event, raised when a scene is asked to open URLs.
+ *
+ * Replaces the `applicationOpenURLOptions` app delegate callback, which UIKit no longer
+ * calls once the app adopts scenes. Handlers registered through
+ * `Application.ios.addDelegateHandler('applicationOpenURLOptions', ...)` still run, once per context.
+ */
+export interface SceneOpenURLContextsEventData extends SceneEventData {
+	/**
+	 * The URL contexts to open. A single delivery may carry more than one URL.
+	 */
+	urlContexts: NSSet<UIOpenURLContext>;
+}
+
+/**
+ * iOS event data for the `sceneContinueUserActivity` event, raised for Handoff and
+ * universal links directed at a scene.
+ *
+ * Replaces the `applicationContinueUserActivityRestorationHandler` app delegate callback,
+ * which UIKit no longer calls once the app adopts scenes.
+ */
+export interface SceneContinueUserActivityEventData extends SceneEventData {
+	/**
+	 * The activity to continue.
+	 */
+	userActivity: NSUserActivity;
+}
+
+/**
+ * iOS event data for the `scenePerformActionForShortcutItem` event, raised when a home
+ * screen quick action targets a scene.
+ *
+ * Replaces the `applicationPerformActionForShortcutItemCompletionHandler` app delegate
+ * callback, which UIKit no longer calls once the app adopts scenes.
+ */
+export interface ScenePerformActionForShortcutItemEventData extends SceneEventData {
+	/**
+	 * The quick action the user selected.
+	 */
+	shortcutItem: UIApplicationShortcutItem;
+
+	/**
+	 * Reports back to iOS whether the action was handled. Only the first call is delivered;
+	 * later ones are ignored.
+	 *
+	 * Unless a legacy `applicationPerformActionForShortcutItemCompletionHandler` handler is
+	 * registered — in which case that handler owns the result — the action is reported as
+	 * unhandled as soon as the listeners return, so a listener that wants to report otherwise
+	 * must call this before returning.
+	 */
+	completionHandler: (handled: boolean) => void;
+}
diff --git a/packages/core/application/application-registry.spec.ts b/packages/core/application/application-registry.spec.ts
new file mode 100644
index 0000000000..d4ee910c54
--- /dev/null
+++ b/packages/core/application/application-registry.spec.ts
@@ -0,0 +1,323 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { CoreTypes } from '../core-types';
+import { Observable } from '../data/observable';
+import type { View } from '../ui/core/view';
+import { NativeWindow } from '../native-window/native-window-common';
+import { WindowBase } from '../native-window/window-base';
+import type { WindowRole } from '../native-window/window-base';
+import { ApplicationCommon } from './application-common';
+import { NativeWindowEvents } from '../native-window/native-window-interfaces';
+import { setActiveWindow } from './helpers-common';
+
+/**
+ * `vitest.setup.ts` installs a `NativeScriptGlobals` whose event methods are no-ops, and
+ * `ApplicationCommon` binds them per instance. Swapping in a real Observable before each
+ * Application is constructed is what makes its events observable at all.
+ */
+function installApplicationEventBus(): Observable {
+	const events = new Observable();
+	const bus = (global.NativeScriptGlobals as any).events;
+
+	bus.on = events.on.bind(events);
+	bus.once = events.once.bind(events);
+	bus.off = events.off.bind(events);
+	bus.notify = events.notify.bind(events);
+	bus.hasListeners = events.hasListeners.bind(events);
+
+	return events;
+}
+
+class TestApplication extends ApplicationCommon {
+	getRootView(): View {
+		return undefined;
+	}
+
+	getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		return 'portrait';
+	}
+
+	getSystemAppearance(): 'dark' | 'light' | null {
+		return 'light';
+	}
+
+	getLayoutDirection(): CoreTypes.LayoutDirectionType | null {
+		return CoreTypes.LayoutDirection.ltr;
+	}
+}
+
+class TestWindow extends NativeWindow {
+	protected _setNativeContent(view: View): void {
+		// no native surface under test
+	}
+
+	protected _getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		return 'portrait';
+	}
+
+	protected _getSystemAppearance(): 'light' | 'dark' | null {
+		return 'light';
+	}
+
+	protected _getLayoutDirection(): CoreTypes.LayoutDirectionType | null {
+		return CoreTypes.LayoutDirection.ltr;
+	}
+
+	close(): void {
+		// no native surface under test
+	}
+
+	/** Marks the window as carrying content, the way a real attached window would. */
+	withContent(): this {
+		this._adoptRootView({
+			isLoaded: false,
+			cssClasses: new Set<string>(),
+			callUnloaded() {},
+			_tearDownUI() {},
+			_onRootViewReset() {},
+			_getRootModalViews: () => [],
+		} as unknown as View);
+
+		return this;
+	}
+}
+
+/** A surface with no view tree at all - a CarPlay scene is the real-world case. */
+class TemplateWindow extends WindowBase {
+	constructor(id?: string, isPrimary = false, role: WindowRole = 'carplay') {
+		super(id, isPrimary, role);
+	}
+
+	close(): void {
+		// no native surface under test
+	}
+}
+
+function asWindow(window: WindowBase): NativeWindow {
+	return window as unknown as NativeWindow;
+}
+
+describe('ApplicationCommon window registry', () => {
+	let app: TestApplication;
+	let events: string[];
+
+	beforeEach(() => {
+		installApplicationEventBus();
+		app = new TestApplication();
+		events = [];
+		setActiveWindow(undefined);
+	});
+
+	afterEach(() => {
+		installApplicationEventBus();
+		setActiveWindow(undefined);
+	});
+
+	function record(...eventNames: string[]): Array<{ eventName: string; window: WindowBase }> {
+		const recorded: Array<{ eventName: string; window: WindowBase }> = [];
+		for (const eventName of eventNames) {
+			app.on(eventName, (args: any) => {
+				events.push(eventName);
+				recorded.push({ eventName, window: args.window });
+			});
+		}
+
+		return recorded;
+	}
+
+	it('raises windowOpen with the registered window once per registration', () => {
+		const recorded = record('windowOpen');
+		const first = new TestWindow('a', true);
+		const second = new TestWindow('b');
+
+		app._registerWindow(first);
+		app._registerWindow(second);
+
+		expect(recorded.map((entry) => entry.window)).toEqual([first, second]);
+		expect(app.getWindows()).toEqual([first, second]);
+	});
+
+	it('reports the window flagged primary', () => {
+		const first = new TestWindow('a');
+		const primary = new TestWindow('b', true);
+		app._registerWindow(first);
+		app._registerWindow(primary);
+
+		expect(app.primaryWindow).toBe(primary);
+	});
+
+	it('finds a window by id and returns undefined for an unknown one', () => {
+		const window = new TestWindow('scene-7', true);
+		app._registerWindow(window);
+
+		expect(app.getWindowById('scene-7')).toBe(window);
+		expect(app.getWindowById('scene-8')).toBeUndefined();
+	});
+
+	describe('role filtering', () => {
+		let application: TestWindow;
+		let embedded: TestWindow;
+		let carPlay: TemplateWindow;
+
+		beforeEach(() => {
+			application = new TestWindow('app', true, 'application');
+			embedded = new TestWindow('embedded', false, 'embedded');
+			carPlay = new TemplateWindow('carplay');
+
+			app._registerWindow(application);
+			app._registerWindow(embedded);
+			app._registerWindow(asWindow(carPlay));
+		});
+
+		it('returns only the view-carrying roles by default', () => {
+			expect(app.getWindows()).toEqual([application, embedded]);
+		});
+
+		it("includes every surface for 'all'", () => {
+			expect(app.getWindows('all')).toEqual([application, embedded, carPlay]);
+		});
+
+		it('returns the requested roles when asked explicitly', () => {
+			expect(app.getWindows('carplay')).toEqual([carPlay]);
+			expect(app.getWindows(['application', 'carplay'])).toEqual([application, carPlay]);
+		});
+
+		it('exposes every surface through the internal accessor', () => {
+			expect(app._getWindows()).toEqual([application, embedded, carPlay]);
+		});
+	});
+
+	describe('returned arrays are copies', () => {
+		let first: TestWindow;
+		let second: TestWindow;
+
+		beforeEach(() => {
+			first = new TestWindow('a', true);
+			second = new TestWindow('b');
+			app._registerWindow(first);
+			app._registerWindow(second);
+		});
+
+		it('mutating the result of getWindows() leaves the registry untouched', () => {
+			const windows = app.getWindows();
+			windows.pop();
+			windows.push(new TestWindow('intruder'));
+
+			expect(app.getWindows()).toEqual([first, second]);
+		});
+
+		it("mutating the result of getWindows('all') leaves the registry untouched", () => {
+			app.getWindows('all').length = 0;
+
+			expect(app.getWindows('all')).toEqual([first, second]);
+		});
+
+		it('mutating the result of _getWindows() leaves the registry untouched', () => {
+			app._getWindows().length = 0;
+
+			expect(app._getWindows()).toEqual([first, second]);
+		});
+	});
+
+	describe('unregistering', () => {
+		it('raises windowClose, drops the window and ends its session', () => {
+			const window = new TestWindow('a', true);
+			app._registerWindow(window);
+			const recorded = record('windowClose');
+
+			app._unregisterWindow(window);
+
+			expect(recorded.map((entry) => entry.window)).toEqual([window]);
+			expect(app.getWindows()).toEqual([]);
+			expect(window.state).toBe('closed');
+		});
+
+		it('promotes the first attached view-carrying window and announces it', () => {
+			const primary = new TestWindow('primary', true).withContent();
+			const detached = new TestWindow('detached').withContent();
+			const carPlay = new TemplateWindow('carplay');
+			const successor = new TestWindow('successor').withContent();
+
+			app._registerWindow(primary);
+			app._registerWindow(detached);
+			app._registerWindow(asWindow(carPlay));
+			app._registerWindow(successor);
+			detached._detach();
+
+			const recorded = record('windowClose', 'primaryWindowChanged');
+			app._unregisterWindow(primary);
+
+			expect(events).toEqual(['windowClose', 'primaryWindowChanged']);
+			expect(recorded[1].window).toBe(successor);
+			expect(primary.isPrimary).toBe(false);
+			expect(successor.isPrimary).toBe(true);
+			expect(app.primaryWindow).toBe(successor);
+		});
+
+		it('leaves the app without a primary window when nothing can take over', () => {
+			const primary = new TestWindow('primary', true).withContent();
+			const detached = new TestWindow('detached').withContent();
+			app._registerWindow(primary);
+			app._registerWindow(detached);
+			detached._detach();
+
+			record('windowClose', 'primaryWindowChanged');
+			app._unregisterWindow(primary);
+
+			expect(events).toEqual(['windowClose']);
+			expect(primary.isPrimary).toBe(false);
+			expect(app.primaryWindow).toBeUndefined();
+		});
+
+		it('does not promote anything when a non-primary window goes away', () => {
+			const primary = new TestWindow('primary', true).withContent();
+			const secondary = new TestWindow('secondary').withContent();
+			app._registerWindow(primary);
+			app._registerWindow(secondary);
+
+			record('windowClose', 'primaryWindowChanged');
+			app._unregisterWindow(secondary);
+
+			expect(events).toEqual(['windowClose']);
+			expect(app.primaryWindow).toBe(primary);
+		});
+	});
+
+	describe('activeWindow', () => {
+		let primary: TestWindow;
+		let secondary: TestWindow;
+
+		beforeEach(() => {
+			primary = new TestWindow('primary', true).withContent();
+			secondary = new TestWindow('secondary').withContent();
+			app._registerWindow(primary);
+			app._registerWindow(secondary);
+		});
+
+		it('falls back to the primary window before anything activates', () => {
+			expect(app.activeWindow).toBe(primary);
+		});
+
+		it('follows the window that activated most recently', () => {
+			secondary._notifyEvent(NativeWindowEvents.activate);
+			expect(app.activeWindow).toBe(secondary);
+
+			primary._notifyEvent(NativeWindowEvents.activate);
+			expect(app.activeWindow).toBe(primary);
+		});
+
+		it('falls back to the primary window once the active one closes', () => {
+			secondary._notifyEvent(NativeWindowEvents.activate);
+
+			app._unregisterWindow(secondary);
+
+			expect(app.activeWindow).toBe(primary);
+		});
+
+		it('falls back to the primary window while the active one is detached', () => {
+			secondary._notifyEvent(NativeWindowEvents.activate);
+			secondary._detach();
+
+			expect(app.activeWindow).toBe(primary);
+		});
+	});
+});
diff --git a/packages/core/application/application.android.ts b/packages/core/application/application.android.ts
index 126664aa55..01623eaa9f 100644
--- a/packages/core/application/application.android.ts
+++ b/packages/core/application/application.android.ts
@@ -2,12 +2,17 @@ import { CoreTypes } from '../core-types';
 import { profile } from '../profiling';
 import type { View } from '../ui/core/view';
 import { AndroidActivityCallbacks, NavigationEntry } from '../ui/frame/frame-common';
+import { isEmbedded } from '../ui/embedding';
 import { SDK_VERSION } from '../utils/constants';
-import { android as androidUtils } from '../utils';
+import { android as androidUtils, dataSerialize } from '../utils';
 import { ApplicationCommon } from './application-common';
 import type { AndroidActivityBackPressedEventData, AndroidActivityBundleEventData, AndroidActivityEventData, AndroidActivityNewIntentEventData, AndroidActivityRequestPermissionsEventData, AndroidActivityResultEventData, ApplicationEventData } from './application-interfaces';
 import { Observable } from '../data/observable';
 import { Trace } from '../trace';
+import { AndroidNativeWindow } from '../native-window/native-window.android';
+import { NativeWindow } from '../native-window/native-window-common';
+import { NativeWindowEvents } from '../native-window/native-window-interfaces';
+import type { WindowOpenOptions } from '../native-window/native-window-interfaces';
 import {
 	CommonA11YServiceEnabledObservable,
 	SharedA11YObservable,
@@ -50,6 +55,21 @@ import lazy from '../utils/lazy';
 
 declare class NativeScriptLifecycleCallbacks extends android.app.Application.ActivityLifecycleCallbacks {}
 
+const WINDOW_ID_EXTRA = 'com.tns.activity.windowId';
+
+let multiWindowWarned = false;
+
+function warnMultiWindowIsExperimental(): void {
+	if (multiWindowWarned) {
+		return;
+	}
+	multiWindowWarned = true;
+
+	const message = 'Application.android.openWindow() is experimental. The start activity must not use launchMode="singleTask" (the app template default) or "singleInstance" in AndroidManifest.xml, or Android hands the launch intent to the existing activity instead of opening a second one; use "singleInstancePerTask" (API 31+) or "standard".';
+	Trace.write(message, Trace.categories.Debug, Trace.messageType.warn);
+	console.warn(message);
+}
+
 let NativeScriptLifecycleCallbacks_: typeof NativeScriptLifecycleCallbacks;
 function initNativeScriptLifecycleCallbacks() {
 	if (NativeScriptLifecycleCallbacks_) {
@@ -78,7 +98,28 @@ function initNativeScriptLifecycleCallbacks() {
 				this.nativescriptActivity = activity;
 			}
 
-			this.notifyActivityCreated(activity, savedInstanceState);
+			// Create and register NativeWindow for this activity
+			const savedWindowId = savedInstanceState?.getString(WINDOW_ID_EXTRA);
+			const knownWindow = savedWindowId ? (Application.android.getWindowById(savedWindowId) as AndroidNativeWindow) : undefined;
+			let nativeWindow: AndroidNativeWindow;
+
+			if (knownWindow?.state === 'detached') {
+				// The activity was recreated (rotation, theme change): the same window
+				// instance carries on, keeping its listeners and identity.
+				knownWindow._reattach(activity);
+				nativeWindow = knownWindow;
+			} else {
+				const isPrimary = Application.android._getWindows().length === 0;
+				// The role is fixed at creation because it is immutable, and deciding it later would
+				// mean either a second window for this activity or a window with the wrong role.
+				nativeWindow = new AndroidNativeWindow(activity, savedWindowId || AndroidNativeWindow.newWindowId(), isPrimary, isEmbedded() ? 'embedded' : 'application');
+				Application.android._registerWindow(nativeWindow);
+			}
+
+			nativeWindow._registerConfigurationCallbacks();
+			nativeWindow._notifyEvent(NativeWindowEvents.attached);
+
+			this.notifyActivityCreated(activity, savedInstanceState, nativeWindow);
 
 			if (Application.hasListeners(Application.displayedEvent)) {
 				this.subscribeForGlobalLayout(activity);
@@ -105,12 +146,48 @@ function initNativeScriptLifecycleCallbacks() {
 				}
 			}
 
+			const nativeWindow = Application.android._getWindowForActivity(activity);
+			if (nativeWindow) {
+				// A destroyed activity only ends the window session when it is finishing —
+				// otherwise Android is recreating it and the same window is reused.
+				const isClosing = activity.isFinishing();
+
+				if (isClosing) {
+					nativeWindow._notifyEvent(NativeWindowEvents.close);
+				}
+
+				// Emit activityDestroyed on NativeWindow
+				nativeWindow.notify({
+					eventName: NativeWindowEvents.activityDestroyed,
+					object: nativeWindow,
+					window: nativeWindow,
+					activity,
+				} as AndroidActivityEventData);
+
+				if (isClosing) {
+					Application.android._unregisterWindow(nativeWindow);
+				} else {
+					nativeWindow._detach();
+				}
+			}
+
 			Application.android.notify({
 				eventName: Application.android.activityDestroyedEvent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 			} as AndroidActivityEventData);
 
+			// This callback runs for every activity in the process, not just NativeScript ones,
+			// so an empty registry here means the app really has no window left.
+			if (activity.isFinishing() && Application.android._getWindows().length === 0) {
+				Application.android.notify({
+					eventName: Application.exitEvent,
+					object: Application.android,
+					android: activity,
+				});
+			}
+
 			// TODO: This is a temporary workaround to force the V8's Garbage Collector, which will force the related Java Object to be collected.
 			gc();
 		}
@@ -126,9 +203,22 @@ function initNativeScriptLifecycleCallbacks() {
 				});
 			}
 
+			const nativeWindow = Application.android._getWindowForActivity(activity);
+			if (nativeWindow) {
+				nativeWindow._notifyEvent(NativeWindowEvents.deactivate);
+				// Emit activityPaused on NativeWindow
+				nativeWindow.notify({
+					eventName: NativeWindowEvents.activityPaused,
+					object: nativeWindow,
+					window: nativeWindow,
+					activity,
+				} as AndroidActivityEventData);
+			}
+
 			Application.android.notify({
 				eventName: Application.android.activityPausedEvent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 			} as AndroidActivityEventData);
 		}
@@ -138,12 +228,25 @@ function initNativeScriptLifecycleCallbacks() {
 			// console.log('NativeScriptLifecycleCallbacks onActivityResumed');
 			Application.android.setForegroundActivity(activity);
 
+			const nativeWindow = Application.android._getWindowForActivity(activity);
+			if (nativeWindow) {
+				nativeWindow._notifyEvent(NativeWindowEvents.activate);
+				// Emit activityResumed on NativeWindow
+				nativeWindow.notify({
+					eventName: NativeWindowEvents.activityResumed,
+					object: nativeWindow,
+					window: nativeWindow,
+					activity,
+				} as AndroidActivityEventData);
+			}
+
 			// NOTE: setSuspended(false) is called in frame/index.android.ts inside onPostResume
 			// This is done to ensure proper timing for the event to be raised
 
 			Application.android.notify({
 				eventName: Application.android.activityResumedEvent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 			} as AndroidActivityEventData);
 		}
@@ -152,9 +255,25 @@ function initNativeScriptLifecycleCallbacks() {
 		public onActivitySaveInstanceState(activity: androidx.appcompat.app.AppCompatActivity, bundle: android.os.Bundle): void {
 			// console.log('NativeScriptLifecycleCallbacks onActivitySaveInstanceState');
 
+			// Emit on NativeWindow first
+			const nativeWindow = Application.android._getWindowForActivity(activity);
+			if (nativeWindow) {
+				// Carries the window identity across activity recreation.
+				bundle.putString(WINDOW_ID_EXTRA, nativeWindow.id);
+
+				nativeWindow.notify({
+					eventName: NativeWindowEvents.saveActivityState,
+					object: nativeWindow,
+					window: nativeWindow,
+					activity,
+					bundle,
+				} as AndroidActivityBundleEventData);
+			}
+
 			Application.android.notify({
 				eventName: Application.android.saveActivityStateEvent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 				bundle,
 			} as AndroidActivityBundleEventData);
@@ -173,9 +292,22 @@ function initNativeScriptLifecycleCallbacks() {
 				});
 			}
 
+			const nativeWindow = Application.android._getWindowForActivity(activity);
+			if (nativeWindow) {
+				nativeWindow._notifyEvent(NativeWindowEvents.foreground);
+				// Emit activityStarted on NativeWindow
+				nativeWindow.notify({
+					eventName: NativeWindowEvents.activityStarted,
+					object: nativeWindow,
+					window: nativeWindow,
+					activity,
+				} as AndroidActivityEventData);
+			}
+
 			Application.android.notify({
 				eventName: Application.android.activityStartedEvent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 			} as AndroidActivityEventData);
 		}
@@ -192,9 +324,22 @@ function initNativeScriptLifecycleCallbacks() {
 				});
 			}
 
+			const nativeWindow = Application.android._getWindowForActivity(activity);
+			if (nativeWindow) {
+				nativeWindow._notifyEvent(NativeWindowEvents.background);
+				// Emit activityStopped on NativeWindow
+				nativeWindow.notify({
+					eventName: NativeWindowEvents.activityStopped,
+					object: nativeWindow,
+					window: nativeWindow,
+					activity,
+				} as AndroidActivityEventData);
+			}
+
 			Application.android.notify({
 				eventName: Application.android.activityStoppedEvent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 			} as AndroidActivityEventData);
 		}
@@ -212,10 +357,21 @@ function initNativeScriptLifecycleCallbacks() {
 		}
 
 		@profile
-		notifyActivityCreated(activity: androidx.appcompat.app.AppCompatActivity, bundle: android.os.Bundle) {
+		notifyActivityCreated(activity: androidx.appcompat.app.AppCompatActivity, bundle: android.os.Bundle, nativeWindow?: NativeWindow) {
+			// Emit on NativeWindow first
+			if (nativeWindow) {
+				nativeWindow.notify({
+					eventName: NativeWindowEvents.activityCreated,
+					object: nativeWindow,
+					window: nativeWindow,
+					activity,
+					bundle,
+				} as AndroidActivityBundleEventData);
+			}
 			Application.android.notify({
 				eventName: Application.android.activityCreatedEvent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 				bundle,
 			} as AndroidActivityBundleEventData);
@@ -395,9 +551,14 @@ export class AndroidApplication extends ApplicationCommon implements IAndroidApp
 	}
 
 	onConfigurationChanged(configuration: android.content.res.Configuration): void {
-		this.setOrientation(this.getOrientationValue(configuration));
-		this.setSystemAppearance(this.getSystemAppearanceValue(configuration));
-		this.setLayoutDirection(this.getLayoutDirectionValue(configuration));
+		// The application context reports the app-wide configuration, which a window on a
+		// second display or in split-screen does not necessarily share, so the primary
+		// window is asked first. Each window tracks its own through its activity.
+		const primaryWindow = this.primaryWindow;
+
+		this.setOrientation(primaryWindow?.orientation() ?? this.getOrientationValue(configuration));
+		this.setSystemAppearance(primaryWindow?.systemAppearance() ?? this.getSystemAppearanceValue(configuration));
+		this.setLayoutDirection(primaryWindow?.layoutDirection() ?? this.getLayoutDirectionValue(configuration));
 	}
 
 	getNativeApplication() {
@@ -433,6 +594,10 @@ export class AndroidApplication extends ApplicationCommon implements IAndroidApp
 			const nativeApp = this.getNativeApplication();
 			this.init(nativeApp);
 		}
+
+		// The activity lifecycle callbacks are registered but no activity has been created yet,
+		// so this always precedes the first `windowOpen`.
+		this.notifyReady();
 	}
 
 	get startActivity() {
@@ -524,7 +689,7 @@ export class AndroidApplication extends ApplicationCommon implements IAndroidApp
 	}
 
 	public getRegisteredBroadcastReceiver(intentFilter: string): android.content.BroadcastReceiver | undefined {
-		return this._registeredReceivers[intentFilter]?.[0].receiver;
+		return this._registeredReceivers[intentFilter]?.[0]?.receiver;
 	}
 
 	public getRegisteredBroadcastReceivers(intentFilter: string): android.content.BroadcastReceiver[] {
@@ -534,6 +699,67 @@ export class AndroidApplication extends ApplicationCommon implements IAndroidApp
 		}
 		return [];
 	}
+
+	// --- NativeWindow registry ---
+
+	/**
+	 * @internal - Get a NativeWindow by its activity.
+	 */
+	_getWindowForActivity(activity: androidx.appcompat.app.AppCompatActivity): AndroidNativeWindow | undefined {
+		return this._windows.find((nw) => nw.android?.activity === activity) as AndroidNativeWindow | undefined;
+	}
+
+	// --- Multi-window support ---
+
+	/**
+	 * Opens a new window by launching the start activity into its own task.
+	 *
+	 * @param options Options for the new window. `options.data` is put on the launch
+	 * intent as extras and surfaces as the window's `data`.
+	 *
+	 * @experimental The start activity's `launchMode` in AndroidManifest.xml decides whether a
+	 * second instance can exist at all: `singleTask` (the app template default) and
+	 * `singleInstance` route the intent to the existing activity's `onNewIntent` instead of
+	 * creating one. `singleInstancePerTask` (API 31+) keeps single-task behavior for launcher
+	 * and deep-link starts while still allowing the `MULTIPLE_TASK`/`NEW_DOCUMENT` launch used
+	 * here; `standard` also works. When the app is already in split-screen, the new window
+	 * opens in the adjacent pane; otherwise it covers the current one and both show in recents.
+	 */
+	openWindow(options?: WindowOpenOptions): void {
+		warnMultiWindowIsExperimental();
+
+		const context = this.context ?? this.getNativeApplication();
+		const intent = new android.content.Intent();
+		const startActivity = this.startActivity;
+
+		if (startActivity) {
+			intent.setClass(context, startActivity.getClass());
+		} else {
+			intent.setClassName(context, 'org.nativescript.NativeScriptActivity');
+		}
+
+		let flags = android.content.Intent.FLAG_ACTIVITY_NEW_TASK | android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK | android.content.Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+
+		const launcher = this.foregroundActivity ?? startActivity;
+		if (SDK_VERSION >= 24 && launcher?.isInMultiWindowMode()) {
+			flags |= android.content.Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT;
+		}
+		intent.setFlags(flags);
+
+		const data = options?.data;
+		if (data) {
+			for (const key of Object.keys(data)) {
+				intent.putExtra(key, dataSerialize(data[key], true));
+			}
+		}
+
+		if (launcher) {
+			launcher.startActivity(intent);
+		} else {
+			context.startActivity(intent);
+		}
+	}
+
 	getRootView(): View {
 		const activity = this.foregroundActivity || this.startActivity;
 		if (!activity) {
diff --git a/packages/core/application/application.d.ts b/packages/core/application/application.d.ts
index a305a88838..a9144f6519 100644
--- a/packages/core/application/application.d.ts
+++ b/packages/core/application/application.d.ts
@@ -1,68 +1,81 @@
 import { ApplicationCommon } from './application-common';
-import { FontScaleCategory } from '../accessibility/font-scale-common';
+import type { AndroidAccessibilityEvent } from '../accessibility/accessibility-common';
+import type { View } from '../ui/core/view';
+import type { Page } from '../ui/page';
+import type { AndroidActivityEventData, AndroidActivityBundleEventData, AndroidActivityResultEventData, AndroidActivityBackPressedEventData, AndroidActivityNewIntentEventData, AndroidActivityRequestPermissionsEventData, SceneEventData, SceneOpenURLContextsEventData, SceneContinueUserActivityEventData, ScenePerformActionForShortcutItemEventData } from './application-interfaces';
+import type { NativeWindow, WindowOpenOptions } from '../native-window';
 
 export * from './application-common';
 export * from './application-interfaces';
 
 export const Application: ApplicationCommon;
 
+/**
+ * The Application `on` overloads, widened with the Android activity bridges.
+ *
+ * An intersection rather than method overloads: overriding `on` as a method would replace
+ * the inherited {@link ApplicationCommon} overloads instead of adding to them, hiding every
+ * app-level event from `Application.android.on()`.
+ */
+type AndroidApplicationOn = ApplicationCommon['on'] & {
+	(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+};
+
+/**
+ * The Application `on` overloads, widened with the iOS scene bridges.
+ *
+ * An intersection rather than method overloads: overriding `on` as a method would replace
+ * the inherited {@link ApplicationCommon} overloads instead of adding to them, hiding every
+ * app-level event from `Application.ios.on()`.
+ */
+type IOSApplicationOn = ApplicationCommon['on'] & {
+	(event: 'sceneWillConnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	(event: 'sceneDidActivate', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	(event: 'sceneWillResignActive', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	(event: 'sceneWillEnterForeground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	(event: 'sceneDidEnterBackground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	(event: 'sceneDidDisconnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+};
+
 export class AndroidApplication extends ApplicationCommon {
-	/**
-	 * @deprecated Use `Application.android.activityCreatedEvent` instead.
-	 */
 	static readonly activityCreatedEvent = 'activityCreated';
-	/**
-	 * @deprecated Use `Application.android.activityDestroyedEvent` instead.
-	 */
 	static readonly activityDestroyedEvent = 'activityDestroyed';
-	/**
-	 * @deprecated Use `Application.android.activityStartedEvent` instead.
-	 */
 	static readonly activityStartedEvent = 'activityStarted';
-	/**
-	 * @deprecated Use `Application.android.activityPausedEvent` instead.
-	 */
 	static readonly activityPausedEvent = 'activityPaused';
-	/**
-	 * @deprecated Use `Application.android.activityResumedEvent` instead.
-	 */
 	static readonly activityResumedEvent = 'activityResumed';
-	/**
-	 * @deprecated Use `Application.android.activityStoppedEvent` instead.
-	 */
 	static readonly activityStoppedEvent = 'activityStopped';
-	/**
-	 * @deprecated Use `Application.android.saveActivityStateEvent` instead.
-	 */
 	static readonly saveActivityStateEvent = 'saveActivityState';
-	/**
-	 * @deprecated Use `Application.android.activityResultEvent` instead.
-	 */
 	static readonly activityResultEvent = 'activityResult';
-	/**
-	 * @deprecated Use `Application.android.activityBackPressedEvent` instead.
-	 */
 	static readonly activityBackPressedEvent = 'activityBackPressed';
-	/**
-	 * @deprecated Use `Application.android.activityNewIntentEvent` instead.
-	 */
 	static readonly activityNewIntentEvent = 'activityNewIntent';
-	/**
-	 * @deprecated Use `Application.android.activityRequestPermissionsEvent` instead.
-	 */
 	static readonly activityRequestPermissionsEvent = 'activityRequestPermissions';
 
-	readonly activityCreatedEvent = AndroidApplication.activityCreatedEvent;
-	readonly activityDestroyedEvent = AndroidApplication.activityDestroyedEvent;
-	readonly activityStartedEvent = AndroidApplication.activityStartedEvent;
-	readonly activityPausedEvent = AndroidApplication.activityPausedEvent;
-	readonly activityResumedEvent = AndroidApplication.activityResumedEvent;
-	readonly activityStoppedEvent = AndroidApplication.activityStoppedEvent;
-	readonly saveActivityStateEvent = AndroidApplication.saveActivityStateEvent;
-	readonly activityResultEvent = AndroidApplication.activityResultEvent;
-	readonly activityBackPressedEvent = AndroidApplication.activityBackPressedEvent;
-	readonly activityNewIntentEvent = AndroidApplication.activityNewIntentEvent;
-	readonly activityRequestPermissionsEvent = AndroidApplication.activityRequestPermissionsEvent;
+	readonly activityCreatedEvent = 'activityCreated';
+	readonly activityDestroyedEvent = 'activityDestroyed';
+	readonly activityStartedEvent = 'activityStarted';
+	readonly activityPausedEvent = 'activityPaused';
+	readonly activityResumedEvent = 'activityResumed';
+	readonly activityStoppedEvent = 'activityStopped';
+	readonly saveActivityStateEvent = 'saveActivityState';
+	readonly activityResultEvent = 'activityResult';
+	readonly activityBackPressedEvent = 'activityBackPressed';
+	readonly activityNewIntentEvent = 'activityNewIntent';
+	readonly activityRequestPermissionsEvent = 'activityRequestPermissions';
+
+	on: AndroidApplicationOn;
 
 	getNativeApplication(): android.app.Application;
 
@@ -113,9 +126,10 @@ export class AndroidApplication extends ApplicationCommon {
 	 * For more information, please visit 'http://developer.android.com/reference/android/content/Context.html#registerReceiver%28android.content.BroadcastReceiver,%20android.content.IntentFilter%29'
 	 * @param intentFilter A string containing the intent filter.
 	 * @param onReceiveCallback A callback function that will be called each time the receiver receives a broadcast.
+	 * @param flags Any combination of `RECEIVER_VISIBLE_TO_INSTANT_APPS` (1), `RECEIVER_EXPORTED` (2) and `RECEIVER_NOT_EXPORTED` (4). Defaults to `RECEIVER_EXPORTED`. Only honored from API 26 onwards.
 	 * @return A function that can be called to unregister the receiver.
 	 */
-	registerBroadcastReceiver(intentFilter: string, onReceiveCallback: (context: android.content.Context, intent: android.content.Intent) => void): () => void;
+	registerBroadcastReceiver(intentFilter: string, onReceiveCallback: (context: android.content.Context, intent: android.content.Intent) => void, flags?: number): () => void;
 
 	/**
 	 * Unregister a previously registered BroadcastReceiver.
@@ -129,27 +143,38 @@ export class AndroidApplication extends ApplicationCommon {
 	 * @param intentFilter A string containing the intent filter.
 	 * @deprecated Use `getRegisteredBroadcastReceivers` instead.
 	 */
-	getRegisteredBroadcastReceiver(intentFilter: string): android.content.BroadcastReceiver;
+	getRegisteredBroadcastReceiver(intentFilter: string): android.content.BroadcastReceiver | undefined;
 	/**
 	 * Get all registered BroadcastReceivers for a specific intent filter.
 	 * @param intentFilter a string containing the intent filter
 	 */
 	getRegisteredBroadcastReceivers(intentFilter: string): android.content.BroadcastReceiver[];
 
-	on(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
-	on(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
-	on(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
-	on(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
-	on(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
-	on(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
-	on(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
-	on(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
-	on(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
-	on(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
-	on(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	/**
+	 * @internal - Get a NativeWindow by its activity.
+	 */
+	_getWindowForActivity(activity: androidx.appcompat.app.AppCompatActivity): NativeWindow | undefined;
+
+	/**
+	 * Opens a new window by launching the start activity into its own task.
+	 *
+	 * @param options Options for the new window. `options.data` is put on the launch
+	 * intent as extras and surfaces as the window's `data`.
+	 *
+	 * @experimental The start activity's `launchMode` in AndroidManifest.xml decides whether a
+	 * second instance can exist at all: `singleTask` (the app template default) and
+	 * `singleInstance` route the intent to the existing activity's `onNewIntent` instead of
+	 * creating one. Use `singleInstancePerTask` (API 31+) to keep single-task behavior for
+	 * launcher and deep-link starts while allowing additional windows, or `standard`.
+	 * When the app is already in split-screen, the new window opens in the adjacent pane;
+	 * otherwise it covers the current one and both show in recents.
+	 */
+	openWindow(options?: WindowOpenOptions): void;
 }
 
 export class iOSApplication extends ApplicationCommon {
+	on: IOSApplicationOn;
+
 	/**
 	 * The root view controller for the application.
 	 */
@@ -216,42 +241,49 @@ export class iOSApplication extends ApplicationCommon {
 	isUsingSceneLifecycle(): boolean;
 
 	/**
-	 * 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: Record<any, any>): void;
+	openWindow(options?: WindowOpenOptions): void;
 
 	/**
 	 * Closes a secondary window/scene.
 	 * If no target is provided, attempts to close a non-primary active scene.
-	 * @param target Optional target to resolve the scene to close. Can be a View, UIWindow, UIWindowScene, or a string scene identifier.
+	 * @param target Optional target to resolve the window to close. Can be a NativeWindow, a View, a UIWindow, a UIWindowScene, or a string scene identifier.
 	 */
-	closeWindow(target?: View | UIWindow | UIWindowScene | string): void;
+	closeWindow(target?: NativeWindow | View | UIWindow | UIWindowScene | string): void;
 
 	/**
 	 * Gets all windows for the application.
+	 * @deprecated Use `getWindows()` instead.
 	 */
 	getAllWindows(): UIWindow[];
 
 	/**
 	 * Gets all scenes for the application.
+	 * @deprecated Use `getWindows()` instead.
 	 */
 	getAllScenes(): UIScene[];
 
 	/**
 	 * Gets all window scenes for the application.
+	 * @deprecated Use `getWindows()` instead.
 	 */
 	getWindowScenes(): UIWindowScene[];
 
 	/**
 	 * Gets the primary window for the application.
+	 * @deprecated Use `primaryWindow?.ios?.uiWindow` instead.
 	 */
 	getPrimaryWindow(): UIWindow;
 
 	/**
 	 * Gets the primary scene for the application.
+	 * @deprecated Use `primaryWindow?.ios?.scene` instead.
 	 */
-	getPrimaryScene(): UIWindowScene;
+	getPrimaryScene(): UIWindowScene | null;
 
 	/**
 	 * Sets the root view for a specific window.
@@ -267,8 +299,31 @@ export class iOSApplication extends ApplicationCommon {
 	sceneDelegate: UIWindowSceneDelegate;
 
 	/**
-	 * Flag to be set when the launch event should be delayed until the application has become active.
-	 * This is useful when you want to process notifications or data in the background without creating the UI.
+	 * 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;
+	 * };
+	 * ```
+	 */
+	onSceneConfiguration: ((application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions) => UISceneConfiguration | null | undefined) | null;
+
+	/**
+	 * @deprecated Has no effect. Application initialization is signalled by the 'ready' event, which is never deferred.
 	 */
 	shouldDelayLaunchEvent: boolean;
 }
diff --git a/packages/core/application/application.ios.ts b/packages/core/application/application.ios.ts
index b0b94e2d8b..64afa2df57 100644
--- a/packages/core/application/application.ios.ts
+++ b/packages/core/application/application.ios.ts
@@ -5,12 +5,18 @@ import { IOSHelper } from '../ui/core/view/view-helper';
 import type { NavigationEntry } from '../ui/frame/frame-interfaces';
 import { getWindow } from '../utils/native-helper';
 import { SDK_VERSION } from '../utils/constants';
-import { ios as iosUtils, dataSerialize } from '../utils/native-helper';
-import { ApplicationCommon, SceneEvents } from './application-common';
-import { ApplicationEventData, SceneEventData } from './application-interfaces';
+import { ios as iosUtils, dataSerialize, dataDeserialize } from '../utils/native-helper';
+import { ApplicationCommon } from './application-common';
+import { ApplicationEventData, SceneContinueUserActivityEventData, SceneEventData, SceneOpenURLContextsEventData, ScenePerformActionForShortcutItemEventData } from './application-interfaces';
+import { deliverShortcutItem, forwardContinueUserActivity, forwardOpenURLContexts, oneShotCompletion } from './scene-delegate-bridge';
 import { Observable } from '../data/observable';
 import type { iOSApplication as IiOSApplication } from './application';
 import { Trace } from '../trace';
+import { IOSNativeWindow } from '../native-window/native-window.ios';
+import { NativeWindow } from '../native-window/native-window-common';
+import type { WindowRole } from '../native-window/window-base';
+import { NativeWindowEvents } from '../native-window/native-window-interfaces';
+import type { NativeWindowEventData, WindowOpenOptions } from '../native-window/native-window-interfaces';
 import {
 	AccessibilityServiceEnabledPropName,
 	CommonA11YServiceEnabledObservable,
@@ -93,6 +99,7 @@ class CADisplayLinkTarget extends NSObject {
 			object: owner,
 			ios: UIApplication.sharedApplication,
 		});
+		owner.primaryWindow?._notifyEvent(NativeWindowEvents.displayed);
 		owner.displayedLinkTarget = null;
 		owner.displayedLink = null;
 	}
@@ -157,8 +164,30 @@ 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 as UIApplicationDelegate).applicationConfigurationForConnectingSceneSessionOptions = function (application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions): UISceneConfiguration {
+		// 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 as any;
 		config.delegateClass = SceneDelegate;
@@ -167,11 +196,25 @@ if (supportsScenes()) {
 
 	// scene session destruction handling
 	(Responder.prototype as UIApplicationDelegate).applicationDidDiscardSceneSessions = function (application: UIApplication, sceneSessions: NSSet<UISceneSession>): void {
-		// 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: UISceneConnectionOptions): Record<string, any> | undefined {
+	const activities = connectionOptions?.userActivities;
+
+	if (!activities || activities.count === 0) {
+		return undefined;
+	}
+
+	const activity = activities.allObjects.objectAtIndex(0) as NSUserActivity;
+
+	return activity?.userInfo ? (dataDeserialize(activity.userInfo) as Record<string, any>) : undefined;
+}
+
 @NativeClass
 class SceneDelegate extends UIResponder implements UIWindowSceneDelegate {
 	static ObjCProtocols = [UIWindowSceneDelegate];
@@ -197,71 +240,289 @@ class SceneDelegate extends UIResponder implements UIWindowSceneDelegate {
 			return;
 		}
 
-		const isFirstScene = !Application.ios.getPrimaryScene() && !Application.hasLaunched();
+		const windowScene = scene as UIWindowScene;
+		const isFirstScene = Application.ios._getWindows().length === 0;
 
-		this._scene = scene;
+		this._scene = windowScene;
 
 		// Create window for this scene
-		this._window = UIWindow.alloc().initWithWindowScene(scene);
+		this._window = UIWindow.alloc().initWithWindowScene(windowScene);
+
+		// Set up window background
+		if (!__VISIONOS__) {
+			this._window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
+		}
 
-		// Store the window scene for this window
-		Application.ios._setWindowForScene(this._window, scene);
+		const nativeWindowId = IOSNativeWindow.getSceneId(windowScene);
+		const knownWindow = nativeWindowId ? (Application.ios.getWindowById(nativeWindowId) as IOSNativeWindow) : undefined;
+		let nativeWindow: IOSNativeWindow;
 
-		// Set up the window content
-		Application.ios._setupWindowForScene(this._window, scene);
+		if (knownWindow?.state === 'detached') {
+			// iOS reconnected a session we already have a window for: the same window
+			// instance carries on, keeping its listeners and identity.
+			nativeWindow = knownWindow;
+			nativeWindow._reattach(windowScene, this._window);
+		} else {
+			const isPrimary = isFirstScene || !Application.ios.primaryWindow;
+			nativeWindow = new IOSNativeWindow(windowScene, this._window, nativeWindowId, isPrimary);
+			Application.ios._registerWindow(nativeWindow);
+		}
+
+		const isPrimary = nativeWindow.isPrimary;
+
+		nativeWindow._notifyEvent(NativeWindowEvents.attached);
+
+		if (isPrimary) {
+			// For primary, also set the legacy global window reference
+			setiOSWindow(this._window);
+		}
+
+		// Notify on NativeWindow first
+		nativeWindow.notify({
+			eventName: NativeWindowEvents.sceneWillConnect,
+			object: nativeWindow,
+			window: nativeWindow,
+			scene: windowScene,
+			uiWindow: this._window,
+			connectionOptions: connectionOptions,
+		} as SceneEventData);
 
-		// Notify that scene will connect
 		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,
 		} as SceneEventData);
 
-		if (scene === Application.ios.getPrimaryScene()) {
+		if (isPrimary) {
 			// primary scene, activate right away
 			this._window.makeKeyAndVisible();
-		} else {
-			// For secondary scenes, emit an event to allow developers to set up custom content for the window
-			Application.ios.notify({
-				eventName: SceneEvents.sceneContentSetup,
-				object: Application.ios,
-				scene: scene,
-				window: this._window,
-				connectionOptions: connectionOptions,
-			} as SceneEventData);
 		}
 
-		// If this is the first scene, trigger app startup
-		if (isFirstScene) {
-			Application.ios._notifySceneAppStarted();
+		if (nativeWindow.role === 'application') {
+			// A re-attached window carries a torn down root view on a brand new UIWindow,
+			// so it needs its content resolved again just like a fresh one.
+			Application.ios._resolveWindowContent(nativeWindow, {
+				window: nativeWindow,
+				isPrimary,
+				data: getSceneConnectionData(connectionOptions),
+				ios: { connectionOptions },
+			});
 		}
 	}
+
 	sceneDidBecomeActive(scene: UIScene): void {
-		// This will be handled by the notification observer in iOSApplication
-		// The notification system will automatically trigger sceneDidActivate
+		const windowScene = scene as UIWindowScene;
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+		if (nativeWindow) {
+			nativeWindow._notifyEvent(NativeWindowEvents.activate);
+			// Emit sceneDidActivate on NativeWindow
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.sceneDidActivate,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+			} as SceneEventData);
+		}
+
+		Application.ios.notify({
+			eventName: NativeWindowEvents.sceneDidActivate,
+			object: Application.ios,
+			window: nativeWindow,
+			scene: windowScene,
+		} as SceneEventData);
+
+		const rootView = nativeWindow?.rootView;
+		if (rootView && !rootView.isLoaded) {
+			rootView.callLoaded();
+		}
 	}
 
 	sceneWillResignActive(scene: UIScene): void {
-		// Notify that scene will resign active
+		const windowScene = scene as UIWindowScene;
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+		if (nativeWindow) {
+			nativeWindow._notifyEvent(NativeWindowEvents.deactivate);
+			// Emit sceneWillResignActive on NativeWindow
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.sceneWillResignActive,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+			} as SceneEventData);
+		}
+
 		Application.ios.notify({
-			eventName: SceneEvents.sceneWillResignActive,
+			eventName: NativeWindowEvents.sceneWillResignActive,
 			object: Application.ios,
-			scene: scene,
+			window: nativeWindow,
+			scene: windowScene,
 		} as SceneEventData);
 	}
 
 	sceneWillEnterForeground(scene: UIScene): void {
-		// This will be handled by the notification observer in iOSApplication
+		const windowScene = scene as UIWindowScene;
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+		if (nativeWindow) {
+			nativeWindow._notifyEvent(NativeWindowEvents.foreground);
+			// Emit sceneWillEnterForeground on NativeWindow
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.sceneWillEnterForeground,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+			} as SceneEventData);
+		}
+
+		Application.ios.notify({
+			eventName: NativeWindowEvents.sceneWillEnterForeground,
+			object: Application.ios,
+			window: nativeWindow,
+			scene: windowScene,
+		} as SceneEventData);
 	}
 
 	sceneDidEnterBackground(scene: UIScene): void {
-		// This will be handled by the notification observer in iOSApplication
+		const windowScene = scene as UIWindowScene;
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+		if (nativeWindow) {
+			nativeWindow._notifyEvent(NativeWindowEvents.background);
+			// Emit sceneDidEnterBackground on NativeWindow
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.sceneDidEnterBackground,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+			} as SceneEventData);
+		}
+
+		Application.ios.notify({
+			eventName: NativeWindowEvents.sceneDidEnterBackground,
+			object: Application.ios,
+			window: nativeWindow,
+			scene: windowScene,
+		} as SceneEventData);
+
+		const rootView = nativeWindow?.rootView;
+		if (rootView && rootView.isLoaded) {
+			rootView.callUnloaded();
+		}
 	}
 
 	sceneDidDisconnect(scene: UIScene): void {
-		// This will be handled by the notification observer in iOSApplication
+		const windowScene = scene as UIWindowScene;
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+		if (nativeWindow) {
+			// A disconnect only ends the window session when the app asked for it —
+			// otherwise iOS may reconnect the same session later. A window with no session
+			// identity is the exception: a reconnect could never be matched back to it.
+			const isClosing = nativeWindow._closeRequested || !nativeWindow._hasSessionIdentity;
+
+			if (isClosing) {
+				nativeWindow._notifyEvent(NativeWindowEvents.close);
+			}
+
+			// Emit sceneDidDisconnect on NativeWindow
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.sceneDidDisconnect,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+			} as SceneEventData);
+
+			if (isClosing) {
+				Application.ios._unregisterWindow(nativeWindow);
+			} else {
+				nativeWindow._detach();
+			}
+		}
+
+		Application.ios.notify({
+			eventName: NativeWindowEvents.sceneDidDisconnect,
+			object: Application.ios,
+			window: nativeWindow,
+			scene: windowScene,
+		} as SceneEventData);
+	}
+
+	sceneOpenURLContexts(scene: UIScene, URLContexts: NSSet<UIOpenURLContext>): void {
+		const windowScene = scene as UIWindowScene;
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+
+		if (nativeWindow) {
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.sceneOpenURLContexts,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+				urlContexts: URLContexts,
+			} as SceneOpenURLContextsEventData);
+		}
+
+		Application.ios.notify({
+			eventName: NativeWindowEvents.sceneOpenURLContexts,
+			object: Application.ios,
+			window: nativeWindow,
+			scene: windowScene,
+			urlContexts: URLContexts,
+		} as SceneOpenURLContextsEventData);
+
+		forwardOpenURLContexts(Application.ios.delegate, UIApplication.sharedApplication, URLContexts);
+	}
+
+	sceneContinueUserActivity(scene: UIScene, userActivity: NSUserActivity): void {
+		const windowScene = scene as UIWindowScene;
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+
+		if (nativeWindow) {
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.sceneContinueUserActivity,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+				userActivity,
+			} as SceneContinueUserActivityEventData);
+		}
+
+		Application.ios.notify({
+			eventName: NativeWindowEvents.sceneContinueUserActivity,
+			object: Application.ios,
+			window: nativeWindow,
+			scene: windowScene,
+			userActivity,
+		} as SceneContinueUserActivityEventData);
+
+		forwardContinueUserActivity(Application.ios.delegate, UIApplication.sharedApplication, userActivity);
+	}
+
+	windowScenePerformActionForShortcutItemCompletionHandler(windowScene: UIWindowScene, shortcutItem: UIApplicationShortcutItem, completionHandler: (p1: boolean) => void): void {
+		const nativeWindow = Application.ios._getWindowForScene(windowScene);
+		// Shared by the listeners and the legacy handler, so it has to tolerate several callers.
+		const deliver = oneShotCompletion(completionHandler);
+
+		if (nativeWindow) {
+			nativeWindow.notify({
+				eventName: NativeWindowEvents.scenePerformActionForShortcutItem,
+				object: nativeWindow,
+				window: nativeWindow,
+				scene: windowScene,
+				shortcutItem,
+				completionHandler: deliver,
+			} as ScenePerformActionForShortcutItemEventData);
+		}
+
+		Application.ios.notify({
+			eventName: NativeWindowEvents.scenePerformActionForShortcutItem,
+			object: Application.ios,
+			window: nativeWindow,
+			scene: windowScene,
+			shortcutItem,
+			completionHandler: deliver,
+		} as ScenePerformActionForShortcutItemEventData);
+
+		deliverShortcutItem(Application.ios.delegate, UIApplication.sharedApplication, shortcutItem, deliver);
 	}
 }
 // ensure available globally
@@ -271,11 +532,20 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	private _delegate: UIApplicationDelegate;
 	private _delegateHandlers = new Map<string, Array<Function>>();
 	private _rootView: View;
-	private launchEventCalled = false;
+	/** Set when a background launch defers the primary window's content until the app first becomes active. */
+	private _pendingWindowContentResolve: (() => void) | null;
 	private _sceneDelegate: UIWindowSceneDelegate;
-	private _windowSceneMap = new Map<UIScene, UIWindow>();
-	private _primaryScene: UIWindowScene | null = null;
-	private _openedScenesById = new Map<string, UIWindowScene>();
+	/**
+	 * User-provided callback to intercept scene configuration.
+	 * Called for every new scene session. Return a UISceneConfiguration to handle
+	 * the scene yourself, or return null/undefined to let NativeScript handle it
+	 * (only for UIWindowSceneSessionRoleApplication scenes).
+	 * @internal
+	 */
+	_onSceneConfiguration: ((application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions) => UISceneConfiguration | null | undefined) | null;
+
+	// The window whose root view the app-level root view state mirrors.
+	private _mirroredWindow: NativeWindow;
 
 	private _notificationObservers: NotificationObserver[] = [];
 
@@ -290,6 +560,9 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	displayedLinkTarget: CADisplayLinkTarget;
 	displayedLink: CADisplayLink;
 
+	/**
+	 * @deprecated Has no effect. Application initialization is signalled by the 'ready' event, which is never deferred.
+	 */
 	shouldDelayLaunchEvent = false;
 
 	/**
@@ -299,22 +572,11 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 		super();
 
 		this.addNotificationObserver(UIApplicationDidFinishLaunchingNotification, this.didFinishLaunchingWithOptions.bind(this));
+		this.addNotificationObserver(UIApplicationDidBecomeActiveNotification, this.didBecomeActive.bind(this));
+		this.addNotificationObserver(UIApplicationDidEnterBackgroundNotification, this.didEnterBackground.bind(this));
 		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));
-		} else {
-			// For scene-based apps, the below are not needed as they are handled by the scene notifications
-			this.addNotificationObserver(UIApplicationDidBecomeActiveNotification, this.didBecomeActive.bind(this));
-			this.addNotificationObserver(UIApplicationDidEnterBackgroundNotification, this.didEnterBackground.bind(this));
-		}
 	}
 
 	getRootView(): View {
@@ -378,6 +640,8 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	}
 
 	private runAsEmbeddedApp() {
+		this.notifyReady();
+
 		this._reattachNativeDelegatesAfterSoftReboot();
 
 		// TODO: this rootView should be held alive until rootController dismissViewController is called.
@@ -412,8 +676,20 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 			}
 			if (targetScene) {
 				window = UIWindow.alloc().initWithWindowScene(targetScene);
-				this._setWindowForScene(window, targetScene);
-				this._setupWindowForScene?.(window, 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.
@@ -438,35 +714,18 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 			return;
 		}
 
-		const controller = this.getViewController(rootView);
-
-		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) {
-			// Embed into host app.
-			// present over the host's existing root view controller.
-			this.setViewControllerView(rootView);
-			embedderDelegate.presentNativeScriptApp(controller);
-		} else {
-			// No embedder delegate = NativeScript owns the UIApplication.
-			// Attach the root to the window.
-			this.setViewControllerView(rootView);
-			this.setWindowRootView(window, rootView);
+		let hostWindow = this.primaryWindow as IOSNativeWindow;
+		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: WindowRole = 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();
 	}
 
@@ -749,7 +1008,6 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	}
 
 	private notifyAppStarted(notification?: NSNotification) {
-		this.launchEventCalled = true;
 		const root = this.notifyLaunch({
 			ios: notification?.userInfo?.objectForKey('UIApplicationLaunchOptionsLocalNotificationKey') ?? null,
 		});
@@ -763,11 +1021,6 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 		}
 	}
 
-	// Public method for scene-based app startup
-	_notifySceneAppStarted() {
-		this.notifyAppStarted();
-	}
-
 	public _onLivesync(context?: ModuleContext): void {
 		// Handle application root module
 		const isAppRootModuleChanged = context && context.path && context.path.includes(this.getMainEntry().moduleName) && context.type !== 'style';
@@ -784,15 +1037,27 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	}
 
 	private setWindowContent(view?: View): void {
+		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.
+	 */
+	private setWindowContentFallback(rootView: View): void {
 		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);
+		const controller = this.getViewController(rootView);
 
 		// setup view as styleScopeHost
 		rootView._setupAsRootView({});
@@ -800,7 +1065,6 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 		this.setViewControllerView(rootView);
 
 		const win = this.window;
-
 		const haveController = win.rootViewController !== null;
 		win.rootViewController = controller;
 
@@ -808,20 +1072,7 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 			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
@@ -841,6 +1092,10 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 				}
 			}
 		}
+
+		// 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
@@ -858,9 +1113,32 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 				this.window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
 			}
 
-			this.launchEventCalled = false;
-			if (!this.shouldDelayLaunchEvent) {
-				this.notifyAppStarted(notification);
+			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 === UIApplicationState.Background) {
+				// A background launch has no UI to build yet, so content waits for the first activation.
+				this._pendingWindowContentResolve = resolveContent;
+			} else {
+				resolveContent();
 			}
 		} else {
 			// Scene-based app - window creation will happen in scene delegate
@@ -869,18 +1147,24 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 
 	@profile
 	private didBecomeActive(notification: NSNotification) {
-		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();
+			}
 		}
 	}
 
@@ -891,9 +1175,11 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 		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();
+			}
 		}
 	}
 
@@ -919,179 +1205,130 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	}
 
 	private didChangeStatusBarOrientation(notification: NSNotification) {
-		const statusBarOrientation = UIApplication.sharedApplication.statusBarOrientation;
-		const newOrientation = this.getOrientationValue(statusBarOrientation);
-		this.setOrientation(newOrientation);
-	}
+		// 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;
+			}
 
-	// Scene lifecycle notification handlers
-	private sceneWillConnect(notification: NSNotification) {
-		const scene = notification.object as UIWindowScene;
-		if (!scene || !(scene instanceof UIWindowScene)) {
-			return;
+			const orientation = nativeWindow.ios?.scene?.interfaceOrientation ?? UIApplication.sharedApplication.statusBarOrientation;
+			nativeWindow._setOrientation(this.getOrientationValue(orientation));
 		}
+	}
 
-		// Store as primary scene if it's the first one
-		if (!this._primaryScene) {
-			this._primaryScene = scene;
-		}
+	// --- App-level root view mirror ---
 
-		this.notify({
-			eventName: SceneEvents.sceneWillConnect,
-			object: this,
-			scene: scene,
-			userInfo: notification.userInfo,
-		} as SceneEventData);
-	}
+	/**
+	 * Keeps the app-level root view state (`getRootView()`, the global root view and the
+	 * `initRootView` event) following whatever the primary window shows.
+	 */
+	private mirrorPrimaryWindow(nativeWindow: NativeWindow): void {
+		if (this._mirroredWindow === nativeWindow) {
+			return;
+		}
 
-	private sceneDidActivate(notification: NSNotification) {
-		const scene = notification.object as UIScene;
-		this.notify({
-			eventName: SceneEvents.sceneDidActivate,
-			object: this,
-			scene: scene,
-		} as SceneEventData);
+		this._mirroredWindow?.off(NativeWindowEvents.contentLoaded, this.onPrimaryWindowContentLoaded, this);
+		this._mirroredWindow = nativeWindow;
+		nativeWindow.on(NativeWindowEvents.contentLoaded, this.onPrimaryWindowContentLoaded, this);
 
-		// 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();
-			}
+		if (nativeWindow.rootView && nativeWindow.rootView !== this._rootView) {
+			this.adoptRootView(nativeWindow.rootView);
 		}
 	}
 
-	private sceneWillEnterForeground(notification: NSNotification) {
-		const scene = notification.object as UIScene;
-		this.notify({
-			eventName: SceneEvents.sceneWillEnterForeground,
-			object: this,
-			scene: scene,
-		} as SceneEventData);
+	private onPrimaryWindowContentLoaded(data: NativeWindowEventData): void {
+		this.adoptRootView(data.window.rootView);
 	}
 
-	private sceneDidEnterBackground(notification: NSNotification) {
-		const scene = notification.object as UIScene;
-		this.notify({
-			eventName: SceneEvents.sceneDidEnterBackground,
-			object: this,
-			scene: scene,
-		} as SceneEventData);
-
-		// 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();
-			}
+	private adoptRootView(rootView: View): void {
+		if (!rootView) {
+			return;
 		}
+
+		this._rootView = rootView;
+		setRootView(rootView);
+		this.initRootView(rootView, this._mirroredWindow);
 	}
 
-	private sceneDidDisconnect(notification: NSNotification) {
-		const scene = notification.object as UIScene;
-		this._removeWindowForScene(scene);
+	// --- NativeWindow registry ---
 
-		// If primary scene disconnected, clear it
-		if (scene === this._primaryScene) {
-			this._primaryScene = null;
+	/**
+	 * @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: NSSet<UISceneSession>): void {
+		const all = sessions?.allObjects;
+		if (!all) {
+			return;
 		}
 
-		if (this._primaryScene) {
-			if (SDK_VERSION >= 17) {
-				const request = UISceneSessionActivationRequest.requestWithSession(this._primaryScene.session);
-
-				UIApplication.sharedApplication.activateSceneSessionForRequestErrorHandler(request, (err: NSError) => {
-					if (err) {
-						console.log('Failed to activate primary scene:', err.localizedDescription);
-					}
-				});
-			} else {
-				UIApplication.sharedApplication.requestSceneSessionActivationUserActivityOptionsErrorHandler(this._primaryScene.session, null, null, (err: NSError) => {
-					if (err) {
-						console.log('Failed to activate primary scene (legacy):', err.localizedDescription);
-					}
-				});
+		for (let i = 0; i < all.count; i++) {
+			const persistentIdentifier = all.objectAtIndex(i)?.persistentIdentifier;
+			const nativeWindow = persistentIdentifier ? this.getWindowById(`${persistentIdentifier}`) : undefined;
+			if (!nativeWindow) {
+				continue;
 			}
-		}
-
-		this.notify({
-			eventName: SceneEvents.sceneDidDisconnect,
-			object: this,
-			scene: scene,
-		} as SceneEventData);
-	}
-
-	// Scene management helper methods
-	_setWindowForScene(window: UIWindow, scene: UIScene): void {
-		this._windowSceneMap.set(scene, window);
-	}
 
-	_removeWindowForScene(scene: UIScene): void {
-		this._windowSceneMap.delete(scene);
-		// also untrack opened scene id
-		try {
-			const s: any = scene as any;
-			if (s && s.session) {
-				const id = this._getSceneId(s as UIWindowScene);
-				this._openedScenesById.delete(id);
-			}
-		} catch {}
+			nativeWindow._notifyEvent(NativeWindowEvents.close);
+			this._unregisterWindow(nativeWindow);
+		}
 	}
 
-	_getWindowForScene(scene: UIScene): UIWindow | undefined {
-		return this._windowSceneMap.get(scene);
+	/**
+	 * @internal - Get a NativeWindow by its scene.
+	 */
+	_getWindowForScene(scene: UIWindowScene): IOSNativeWindow | undefined {
+		return this._windows.find((nw) => nw.ios?.scene === scene) as IOSNativeWindow | undefined;
 	}
 
-	_setupWindowForScene(window: UIWindow, scene: UIWindowScene): void {
-		if (!window) {
-			return;
+	protected _onWindowRegistered(nativeWindow: NativeWindow): void {
+		if (nativeWindow.isPrimary) {
+			this.mirrorPrimaryWindow(nativeWindow);
 		}
+	}
 
-		// track opened scene
-		try {
-			const id = this._getSceneId(scene);
-			this._openedScenesById.set(id, scene);
-		} catch {}
-
-		// Set up window background
-		if (!__VISIONOS__) {
-			window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
+	protected _onPrimaryWindowPromoted(nativeWindow: NativeWindow): void {
+		const promotedWindow = nativeWindow.ios?.uiWindow;
+		if (promotedWindow) {
+			setiOSWindow(promotedWindow);
 		}
+		this.mirrorPrimaryWindow(nativeWindow);
+	}
 
-		// 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);
-			}
+	/**
+	 * 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: ((application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions) => UISceneConfiguration | null | undefined) | null) {
+		this._onSceneConfiguration = handler;
+	}
 
-			// During initial scene startup we must wait for launch to be notified first.
-			// Some frameworks provide root content from launch handlers.
-			// Guard: skip setWindowContent when no main entry is configured yet.
-			// During Vite HMR dev boot, the placeholder calls Application.run() with
-			// no entry; the real entry is set later when the HTTP-loaded main module
-			// calls Application.run({ moduleName: ... }). Without this guard the
-			// scene handler would throw "Main entry is missing" and leave the window
-			// in a broken state (root view reset but no replacement created).
-			if (this.hasLaunched() && this.getMainEntry()) {
-				this.setWindowContent();
-			}
-		}
+	get onSceneConfiguration(): ((application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions) => UISceneConfiguration | null | undefined) | null {
+		return this._onSceneConfiguration;
 	}
 
+	// Scene management helper methods (kept for backward compat)
+
 	get sceneDelegate(): UIWindowSceneDelegate {
 		if (!this._sceneDelegate) {
 			this._sceneDelegate = SceneDelegate.new() as UIWindowSceneDelegate;
@@ -1108,10 +1345,12 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	 */
 
 	/**
-	 * 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: Record<any, any>) {
+	openWindow(options?: WindowOpenOptions) {
 		if (!supportsMultipleScenes()) {
 			console.log('Cannot create a new scene - not supported on this device.');
 			return;
@@ -1122,41 +1361,22 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 
 			// iOS 17+
 			if (SDK_VERSION >= 17) {
-				// Create a new scene activation request with proper role
 				let request: UISceneSessionActivationRequest;
 
 				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);
+					const activationOptions = UISceneActivationRequestOptions.new();
+					const primary = this.primaryWindow;
+					if (primary?.ios?.scene) {
+						activationOptions.requestingScene = primary.ios.scene;
+					}
 
-					request.options = options;
+					request.options = activationOptions;
 				} catch (roleError) {
 					console.log('Error creating request:', roleError);
 					return;
@@ -1166,35 +1386,24 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 					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) => {
-						if (error) {
-							console.log('Error creating new scene (legacy):', error);
-						}
-					},
-				);
-			}
-			// Fallback for older iOS versions or unsupported configurations
-			else {
+			} else if (SDK_VERSION >= 13 && SDK_VERSION < 17) {
+				app.requestSceneSessionActivationUserActivityOptionsErrorHandler(null, null, null, (error) => {
+					if (error) {
+						console.log('Error creating new scene (legacy):', error);
+					}
+				});
+			} else {
 				console.log('Neither new nor legacy scene activation methods are available');
 			}
 		} catch (error) {
@@ -1204,76 +1413,72 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 
 	/**
 	 * 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.
 	 */
-	public closeWindow(target?: View | UIWindow | UIWindowScene | string): void {
+	public closeWindow(target?: NativeWindow | View | UIWindow | UIWindowScene | string): void {
 		if (!__APPLE__) {
 			return;
 		}
 		try {
-			const scene = this._resolveScene(target);
-			if (!scene) {
-				console.log('closeWindow: No scene resolved for target');
-				return;
-			}
+			let nativeWindow: NativeWindow | undefined;
 
-			// Don't allow closing the primary scene
-			if (scene === this._primaryScene) {
-				console.log('closeWindow: Refusing to close the primary scene');
-				return;
+			if (target instanceof NativeWindow) {
+				nativeWindow = target;
+			} 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: NSError) => {
-					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(): UIWindow[] {
-		return Array.from(this._windowSceneMap.values());
+		return this._windows.map((nw) => nw.ios?.uiWindow).filter(Boolean) as UIWindow[];
 	}
 
+	/**
+	 * @deprecated Use `getWindows()` instead.
+	 */
 	getAllScenes(): UIScene[] {
-		return Array.from(this._windowSceneMap.keys());
+		return this._windows.map((nw) => nw.ios?.scene).filter(Boolean) as UIScene[];
 	}
 
+	/**
+	 * @deprecated Use `getWindows()` instead.
+	 */
 	getWindowScenes(): UIWindowScene[] {
 		return this.getAllScenes().filter((scene) => scene instanceof UIWindowScene) as UIWindowScene[];
 	}
 
+	/**
+	 * @deprecated Use `primaryWindow?.ios?.uiWindow` instead.
+	 */
 	getPrimaryWindow(): UIWindow {
-		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(): UIWindowScene | null {
-		return this._primaryScene;
+		return this.primaryWindow?.ios?.scene || null;
 	}
 
 	// Scene lifecycle management
@@ -1286,7 +1491,7 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	}
 
 	isUsingSceneLifecycle(): boolean {
-		return this.supportsScenes() && this._windowSceneMap.size > 0;
+		return this.supportsScenes() && this._windows.length > 0;
 	}
 
 	// Call this to set up scene-based configuration
@@ -1295,35 +1500,6 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 			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
-	private _getSceneId(scene: UIWindowScene): string {
-		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
@@ -1332,12 +1508,10 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 			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 as UIWindowScene).session && (target as UIWindowScene).activationState !== undefined) {
@@ -1356,22 +1530,22 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 		}
 		// 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;
 				}
 			}
 		}
 		return null;
 	}
 
-	private createSceneWithLegacyAPI(data: Record<any, any>) {
+	private createSceneWithLegacyAPI(data?: Record<string, any>) {
 		const windowScene = this.window?.windowScene;
 
 		if (!windowScene) {
@@ -1380,7 +1554,7 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 
 		// 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();
diff --git a/packages/core/application/helpers-common.ts b/packages/core/application/helpers-common.ts
index eb6209e1bd..8e6949ee5c 100644
--- a/packages/core/application/helpers-common.ts
+++ b/packages/core/application/helpers-common.ts
@@ -5,6 +5,8 @@
  * For example, use `__ANDROID__` or `__APPLE__` to check the platform.
  */
 
+import type { NativeWindow } from '../native-window';
+
 /**
  * Application type. UIApplication on iOS or android.app.Application on Android.
  */
@@ -99,6 +101,30 @@ export function setAppInBackground(value: boolean) {
 	_appInBackground = value;
 }
 
+/**
+ * Backs `Application.autoSystemAppearanceChanged`. Lives here so windows can read it
+ * without importing the application module.
+ */
+let _autoSystemAppearanceChanged: boolean = true;
+export function getAutoSystemAppearanceChanged(): boolean {
+	return _autoSystemAppearanceChanged;
+}
+export function setAutoSystemAppearanceChanged(value: boolean) {
+	_autoSystemAppearanceChanged = value;
+}
+
+/**
+ * Backs `Application.activeWindow`. Lives here so window-scoped lookups - the frame stack
+ * above all - can read it without importing the application module.
+ */
+let _activeWindow: NativeWindow | undefined;
+export function getActiveWindow(): NativeWindow | undefined {
+	return _activeWindow;
+}
+export function setActiveWindow(window: NativeWindow | undefined) {
+	_activeWindow = window;
+}
+
 let _iosWindow: UIWindow;
 export function getiOSWindow(): UIWindow {
 	return _iosWindow;
@@ -107,7 +133,7 @@ export function setiOSWindow(value: UIWindow) {
 	_iosWindow = value;
 }
 
-let _appMainEntry: any /* NavigationEntry */;
+let _appMainEntry: any; /* NavigationEntry */
 
 export function getAppMainEntry(): any /* NavigationEntry */ {
 	return _appMainEntry;
diff --git a/packages/core/application/scene-delegate-bridge.spec.ts b/packages/core/application/scene-delegate-bridge.spec.ts
new file mode 100644
index 0000000000..0f56cd2fe7
--- /dev/null
+++ b/packages/core/application/scene-delegate-bridge.spec.ts
@@ -0,0 +1,286 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { buildOpenURLOptions, deliverShortcutItem, forwardContinueUserActivity, forwardOpenURLContexts, oneShotCompletion } from './scene-delegate-bridge';
+
+const SOURCE_APPLICATION_KEY = 'UIApplicationOpenURLOptionsSourceApplicationKey';
+const ANNOTATION_KEY = 'UIApplicationOpenURLOptionsAnnotationKey';
+const OPEN_IN_PLACE_KEY = 'UIApplicationOpenURLOptionsOpenInPlaceKey';
+
+/** Mirrors the NSMutableDictionary surface the bridge builds the legacy options with. */
+class FakeMutableDictionary {
+	private readonly values = new Map<string, any>();
+
+	static alloc() {
+		return {
+			init: () => new FakeMutableDictionary(),
+		};
+	}
+
+	setObjectForKey(value: any, key: string): void {
+		this.values.set(key, value);
+	}
+
+	objectForKey(key: string): any {
+		return this.values.has(key) ? this.values.get(key) : undefined;
+	}
+
+	get allKeys(): string[] {
+		return [...this.values.keys()];
+	}
+}
+
+/** NSSet as the scene callback delivers it: read through `allObjects`, not by iteration. */
+function createURLContexts(contexts: Array<{ URL: any; options?: any }>) {
+	return {
+		allObjects: {
+			count: contexts.length,
+			objectAtIndex: (index: number) => contexts[index],
+		},
+	} as any;
+}
+
+function createSceneOpenURLOptions(overrides: Record<string, any> = {}) {
+	return {
+		sourceApplication: null,
+		annotation: null,
+		openInPlace: false,
+		...overrides,
+	} as any;
+}
+
+/**
+ * `addDelegateHandler` chains handlers onto the delegate prototype, so a delegate under test is
+ * a class-shaped object with a prototype plus the live instance UIApplication hands back.
+ */
+function createDelegate(prototypeMethods: Record<string, any> = {}) {
+	const prototype = { ...prototypeMethods };
+	const instance = Object.create(prototype);
+
+	return {
+		delegate: { prototype } as any,
+		instance,
+		application: { delegate: instance } as any,
+	};
+}
+
+beforeEach(() => {
+	(global as any).NSMutableDictionary = FakeMutableDictionary;
+	(global as any).UIApplicationOpenURLOptionsSourceApplicationKey = SOURCE_APPLICATION_KEY;
+	(global as any).UIApplicationOpenURLOptionsAnnotationKey = ANNOTATION_KEY;
+	(global as any).UIApplicationOpenURLOptionsOpenInPlaceKey = OPEN_IN_PLACE_KEY;
+});
+
+afterEach(() => {
+	delete (global as any).NSMutableDictionary;
+	delete (global as any).UIApplicationOpenURLOptionsSourceApplicationKey;
+	delete (global as any).UIApplicationOpenURLOptionsAnnotationKey;
+	delete (global as any).UIApplicationOpenURLOptionsOpenInPlaceKey;
+});
+
+describe('buildOpenURLOptions', () => {
+	it('carries every option the scene reported', () => {
+		const annotation = { some: 'annotation' };
+		const options = buildOpenURLOptions(createSceneOpenURLOptions({ sourceApplication: 'com.example.sender', annotation, openInPlace: true })) as unknown as FakeMutableDictionary;
+
+		expect(options.objectForKey(SOURCE_APPLICATION_KEY)).toBe('com.example.sender');
+		expect(options.objectForKey(ANNOTATION_KEY)).toBe(annotation);
+		expect(options.objectForKey(OPEN_IN_PLACE_KEY)).toBe(true);
+	});
+
+	it('leaves out keys the scene had no value for', () => {
+		const options = buildOpenURLOptions(createSceneOpenURLOptions()) as unknown as FakeMutableDictionary;
+
+		expect(options.allKeys).toEqual([OPEN_IN_PLACE_KEY]);
+		expect(options.objectForKey(OPEN_IN_PLACE_KEY)).toBe(false);
+	});
+
+	it('survives a scene that reported no options at all', () => {
+		const options = buildOpenURLOptions(undefined) as unknown as FakeMutableDictionary;
+
+		expect(options.allKeys).toEqual([]);
+	});
+});
+
+describe('forwardOpenURLContexts', () => {
+	it('calls the legacy handler once per URL context', () => {
+		const applicationOpenURLOptions = vi.fn();
+		const { delegate, application } = createDelegate({ applicationOpenURLOptions });
+		const first = { absoluteString: 'myapp://first' };
+		const second = { absoluteString: 'myapp://second' };
+
+		const forwarded = forwardOpenURLContexts(
+			delegate,
+			application,
+			createURLContexts([
+				{ URL: first, options: createSceneOpenURLOptions() },
+				{ URL: second, options: createSceneOpenURLOptions() },
+			]),
+		);
+
+		expect(forwarded).toBe(true);
+		expect(applicationOpenURLOptions).toHaveBeenCalledTimes(2);
+		expect(applicationOpenURLOptions.mock.calls[0][0]).toBe(application);
+		expect(applicationOpenURLOptions.mock.calls[0][1]).toBe(first);
+		expect(applicationOpenURLOptions.mock.calls[1][1]).toBe(second);
+	});
+
+	it('hands the legacy handler the options dictionary of its own context', () => {
+		const applicationOpenURLOptions = vi.fn();
+		const { delegate, application } = createDelegate({ applicationOpenURLOptions });
+
+		forwardOpenURLContexts(
+			delegate,
+			application,
+			createURLContexts([
+				{ URL: {}, options: createSceneOpenURLOptions({ sourceApplication: 'com.example.first' }) },
+				{ URL: {}, options: createSceneOpenURLOptions({ sourceApplication: 'com.example.second' }) },
+			]),
+		);
+
+		expect(applicationOpenURLOptions.mock.calls[0][2].objectForKey(SOURCE_APPLICATION_KEY)).toBe('com.example.first');
+		expect(applicationOpenURLOptions.mock.calls[1][2].objectForKey(SOURCE_APPLICATION_KEY)).toBe('com.example.second');
+	});
+
+	it('runs the legacy handler against the live app delegate instance', () => {
+		let receiver: any;
+		const { delegate, application, instance } = createDelegate({
+			applicationOpenURLOptions() {
+				receiver = this;
+			},
+		});
+
+		forwardOpenURLContexts(delegate, application, createURLContexts([{ URL: {}, options: createSceneOpenURLOptions() }]));
+
+		expect(receiver).toBe(instance);
+	});
+
+	it('reports nothing forwarded when no legacy handler is registered', () => {
+		const { delegate, application } = createDelegate();
+
+		expect(forwardOpenURLContexts(delegate, application, createURLContexts([{ URL: {}, options: createSceneOpenURLOptions() }]))).toBe(false);
+	});
+
+	it('reports nothing forwarded when there is no delegate at all', () => {
+		expect(forwardOpenURLContexts(undefined, undefined, createURLContexts([{ URL: {}, options: createSceneOpenURLOptions() }]))).toBe(false);
+	});
+
+	it('reports nothing forwarded for an empty set of contexts', () => {
+		const applicationOpenURLOptions = vi.fn();
+		const { delegate, application } = createDelegate({ applicationOpenURLOptions });
+
+		expect(forwardOpenURLContexts(delegate, application, createURLContexts([]))).toBe(false);
+		expect(applicationOpenURLOptions).not.toHaveBeenCalled();
+	});
+});
+
+describe('forwardContinueUserActivity', () => {
+	it('forwards the activity with a callable restoration handler', () => {
+		const applicationContinueUserActivityRestorationHandler = vi.fn();
+		const { delegate, application } = createDelegate({ applicationContinueUserActivityRestorationHandler });
+		const userActivity = { activityType: 'com.example.browsing' } as any;
+
+		expect(forwardContinueUserActivity(delegate, application, userActivity)).toBe(true);
+		expect(applicationContinueUserActivityRestorationHandler).toHaveBeenCalledTimes(1);
+
+		const [forwardedApplication, forwardedActivity, restorationHandler] = applicationContinueUserActivityRestorationHandler.mock.calls[0];
+
+		expect(forwardedApplication).toBe(application);
+		expect(forwardedActivity).toBe(userActivity);
+		expect(typeof restorationHandler).toBe('function');
+		expect(() => restorationHandler(undefined)).not.toThrow();
+	});
+
+	it('reports nothing forwarded when no legacy handler is registered', () => {
+		const { delegate, application } = createDelegate();
+
+		expect(forwardContinueUserActivity(delegate, application, { activityType: 'com.example.browsing' } as any)).toBe(false);
+	});
+
+	it('reports nothing forwarded when there is no activity', () => {
+		const applicationContinueUserActivityRestorationHandler = vi.fn();
+		const { delegate, application } = createDelegate({ applicationContinueUserActivityRestorationHandler });
+
+		expect(forwardContinueUserActivity(delegate, application, undefined)).toBe(false);
+		expect(applicationContinueUserActivityRestorationHandler).not.toHaveBeenCalled();
+	});
+});
+
+describe('oneShotCompletion', () => {
+	it('delivers only the first result', () => {
+		const completionHandler = vi.fn();
+		const deliver = oneShotCompletion(completionHandler);
+
+		deliver(true);
+		deliver(false);
+
+		expect(completionHandler).toHaveBeenCalledTimes(1);
+		expect(completionHandler).toHaveBeenCalledWith(true);
+	});
+
+	it('tracks whether a result has been delivered', () => {
+		const deliver = oneShotCompletion(vi.fn());
+
+		expect(deliver.delivered).toBe(false);
+		deliver(true);
+		expect(deliver.delivered).toBe(true);
+	});
+});
+
+describe('deliverShortcutItem', () => {
+	const shortcutItem = { type: 'com.example.compose' } as any;
+
+	it('forwards to the legacy handler and lets it report the result', () => {
+		const applicationPerformActionForShortcutItemCompletionHandler = vi.fn();
+		const { delegate, application } = createDelegate({ applicationPerformActionForShortcutItemCompletionHandler });
+		const completionHandler = vi.fn();
+		const deliver = oneShotCompletion(completionHandler);
+
+		expect(deliverShortcutItem(delegate, application, shortcutItem, deliver)).toBe(true);
+
+		const [forwardedApplication, forwardedItem, forwardedCompletion] = applicationPerformActionForShortcutItemCompletionHandler.mock.calls[0];
+
+		expect(forwardedApplication).toBe(application);
+		expect(forwardedItem).toBe(shortcutItem);
+		expect(completionHandler).not.toHaveBeenCalled();
+
+		forwardedCompletion(true);
+
+		expect(completionHandler).toHaveBeenCalledTimes(1);
+		expect(completionHandler).toHaveBeenCalledWith(true);
+	});
+
+	it('reports the action unhandled when no legacy handler is registered', () => {
+		const { delegate, application } = createDelegate();
+		const completionHandler = vi.fn();
+
+		expect(deliverShortcutItem(delegate, application, shortcutItem, oneShotCompletion(completionHandler))).toBe(false);
+		expect(completionHandler).toHaveBeenCalledTimes(1);
+		expect(completionHandler).toHaveBeenCalledWith(false);
+	});
+
+	it('reports the result once even when a listener already reported it and a legacy handler reports again', () => {
+		const { delegate, application } = createDelegate({
+			applicationPerformActionForShortcutItemCompletionHandler(_app: any, _item: any, completion: (handled: boolean) => void) {
+				completion(false);
+			},
+		});
+		const completionHandler = vi.fn();
+		const deliver = oneShotCompletion(completionHandler);
+
+		deliver(true);
+		deliverShortcutItem(delegate, application, shortcutItem, deliver);
+
+		expect(completionHandler).toHaveBeenCalledTimes(1);
+		expect(completionHandler).toHaveBeenCalledWith(true);
+	});
+
+	it('does not report again after a listener already reported and no legacy handler exists', () => {
+		const { delegate, application } = createDelegate();
+		const completionHandler = vi.fn();
+		const deliver = oneShotCompletion(completionHandler);
+
+		deliver(true);
+		deliverShortcutItem(delegate, application, shortcutItem, deliver);
+
+		expect(completionHandler).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/packages/core/application/scene-delegate-bridge.ts b/packages/core/application/scene-delegate-bridge.ts
new file mode 100644
index 0000000000..f0971f442f
--- /dev/null
+++ b/packages/core/application/scene-delegate-bridge.ts
@@ -0,0 +1,165 @@
+/**
+ * Bridges scene delegate callbacks back onto the `UIApplicationDelegate` methods that UIKit
+ * stops calling once an app adopts scenes, so handlers registered through
+ * `Application.ios.addDelegateHandler()` keep firing.
+ *
+ * `addDelegateHandler` chains handlers onto the delegate *prototype*, so forwarding means
+ * invoking that prototype method — there is no other entry point to the chain.
+ */
+
+/** The app delegate class as `Application.ios.delegate` exposes it. */
+type AppDelegateClass = (UIApplicationDelegate & { prototype: UIApplicationDelegate }) | undefined | null;
+
+/**
+ * Reports a native completion result at most once.
+ */
+export interface OneShotCompletion {
+	(handled: boolean): void;
+	/** Whether the result has already been reported. */
+	readonly delivered: boolean;
+}
+
+function getLegacyMethod(delegate: AppDelegateClass, methodName: keyof UIApplicationDelegate): Function | undefined {
+	const method = (delegate as any)?.prototype?.[methodName];
+
+	return typeof method === 'function' ? method : undefined;
+}
+
+/**
+ * The delegate prototype methods are written to run against the live app delegate instance,
+ * so they are called with it whenever the app has one.
+ */
+function getDelegateInstance(delegate: AppDelegateClass, application: UIApplication): any {
+	return (application as any)?.delegate ?? (delegate as any)?.prototype;
+}
+
+/**
+ * Rebuilds the options dictionary `applicationOpenURLOptions` expects from the scene-side
+ * {@link UISceneOpenURLOptions}. Keys with no value are left out, matching what UIKit passes.
+ */
+export function buildOpenURLOptions(options: UISceneOpenURLOptions): NSDictionary<string, any> {
+	const result = NSMutableDictionary.alloc().init() as NSMutableDictionary<string, any>;
+
+	if (!options) {
+		return result;
+	}
+
+	const set = (key: string, value: any) => {
+		if (key != null && value != null) {
+			result.setObjectForKey(value, key);
+		}
+	};
+
+	set(UIApplicationOpenURLOptionsSourceApplicationKey, options.sourceApplication);
+	set(UIApplicationOpenURLOptionsAnnotationKey, options.annotation);
+	set(UIApplicationOpenURLOptionsOpenInPlaceKey, options.openInPlace);
+
+	return result;
+}
+
+/**
+ * Forwards a scene URL delivery to `applicationOpenURLOptions`.
+ *
+ * @returns whether a legacy handler was found and invoked.
+ */
+export function forwardOpenURLContexts(delegate: AppDelegateClass, application: UIApplication, urlContexts: NSSet<UIOpenURLContext>): boolean {
+	const method = getLegacyMethod(delegate, 'applicationOpenURLOptions');
+
+	if (!method) {
+		return false;
+	}
+
+	const contexts = urlContexts?.allObjects;
+	const count = contexts?.count ?? 0;
+
+	if (!count) {
+		return false;
+	}
+
+	const thisArg = getDelegateInstance(delegate, application);
+
+	// The legacy callback carries a single URL, so a delivery of several contexts becomes
+	// one legacy call per context rather than one call for the set.
+	for (let i = 0; i < count; i++) {
+		const context = contexts.objectAtIndex(i);
+
+		if (!context) {
+			continue;
+		}
+
+		method.call(thisArg, application, context.URL, buildOpenURLOptions(context.options));
+	}
+
+	return true;
+}
+
+/**
+ * Forwards a scene activity continuation to `applicationContinueUserActivityRestorationHandler`.
+ *
+ * @returns whether a legacy handler was found and invoked.
+ */
+export function forwardContinueUserActivity(delegate: AppDelegateClass, application: UIApplication, userActivity: NSUserActivity): boolean {
+	const method = getLegacyMethod(delegate, 'applicationContinueUserActivityRestorationHandler');
+
+	if (!method || !userActivity) {
+		return false;
+	}
+
+	// The scene callback has no restoration handler to bridge — UIKit restores the scene's
+	// responders itself — but the legacy signature requires one to be callable.
+	const restorationHandler = (_restorableObjects: NSArray<UIUserActivityRestoring>) => {
+		/* no restorable objects to hand back in scene mode */
+	};
+
+	method.call(getDelegateInstance(delegate, application), application, userActivity, restorationHandler);
+
+	return true;
+}
+
+/**
+ * Hands a scene quick action to `applicationPerformActionForShortcutItemCompletionHandler`,
+ * or reports it unhandled when no such handler is registered.
+ *
+ * Together with the repeat-call guard in {@link oneShotCompletion} this is what makes `deliver`
+ * run exactly once: a legacy handler owns the result when there is one, and the fallback covers
+ * the case where nothing else would ever report back to iOS.
+ *
+ * @returns whether a legacy handler was found and invoked.
+ */
+export function deliverShortcutItem(delegate: AppDelegateClass, application: UIApplication, shortcutItem: UIApplicationShortcutItem, deliver: OneShotCompletion): boolean {
+	const method = getLegacyMethod(delegate, 'applicationPerformActionForShortcutItemCompletionHandler');
+
+	if (!method) {
+		deliver(false);
+
+		return false;
+	}
+
+	method.call(getDelegateInstance(delegate, application), application, shortcutItem, deliver);
+
+	return true;
+}
+
+/**
+ * Wraps a native completion handler so only the first result reaches it. iOS treats a
+ * completion handler invoked twice as a programming error, and the same handler is exposed
+ * to both event listeners and legacy delegate handlers.
+ */
+export function oneShotCompletion(completionHandler: (handled: boolean) => void): OneShotCompletion {
+	let delivered = false;
+
+	const deliver = ((handled: boolean) => {
+		if (delivered) {
+			return;
+		}
+
+		delivered = true;
+		completionHandler?.(handled);
+	}) as OneShotCompletion;
+
+	Object.defineProperty(deliver, 'delivered', {
+		get: () => delivered,
+	});
+
+	return deliver;
+}
diff --git a/packages/core/application/window-content-resolver.spec.ts b/packages/core/application/window-content-resolver.spec.ts
new file mode 100644
index 0000000000..6219ce75fa
--- /dev/null
+++ b/packages/core/application/window-content-resolver.spec.ts
@@ -0,0 +1,388 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { CoreTypes } from '../core-types';
+import { Observable } from '../data/observable';
+import { Builder } from '../ui/builder';
+import type { View } from '../ui/core/view';
+import type { NavigationEntry } from '../ui/frame/frame-interfaces';
+import { NativeWindow } from '../native-window/native-window-common';
+import type { WindowContentRequest } from '../native-window/native-window-interfaces';
+import { ApplicationCommon } from './application-common';
+import { getAppMainEntry, setAppMainEntry } from './helpers-common';
+
+/**
+ * `vitest.setup.ts` installs a `NativeScriptGlobals` whose event bus methods are no-ops, and
+ * `ApplicationCommon` binds them per instance. Swapping in a real Observable before each
+ * Application is constructed is what makes its events observable at all.
+ */
+function installApplicationEventBus(): Observable {
+	const events = new Observable();
+	const bus = (global.NativeScriptGlobals as any).events;
+
+	bus.on = events.on.bind(events);
+	bus.once = events.once.bind(events);
+	bus.off = events.off.bind(events);
+	bus.notify = events.notify.bind(events);
+	bus.hasListeners = events.hasListeners.bind(events);
+
+	return events;
+}
+
+function createFakeView(name: string) {
+	return {
+		name,
+		cssClasses: new Set<string>(),
+		isLoaded: false,
+		_styleScope: null,
+		_setupAsRootView() {},
+		_onCssStateChange() {},
+		_onRootViewReset() {},
+		_tearDownUI() {},
+		callUnloaded() {},
+		_getRootModalViews() {
+			return [];
+		},
+	} as unknown as View;
+}
+
+class TestApplication extends ApplicationCommon {
+	getRootView(): View {
+		return undefined;
+	}
+
+	getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		return 'portrait';
+	}
+
+	getSystemAppearance(): 'dark' | 'light' | null {
+		return 'light';
+	}
+
+	getLayoutDirection(): CoreTypes.LayoutDirectionType | null {
+		return CoreTypes.LayoutDirection.ltr;
+	}
+}
+
+class TestWindow extends NativeWindow {
+	protected _setNativeContent(view: View): void {
+		// no native surface under test
+	}
+
+	protected _getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		return 'portrait';
+	}
+
+	protected _getSystemAppearance(): 'light' | 'dark' | null {
+		return 'light';
+	}
+
+	protected _getLayoutDirection(): CoreTypes.LayoutDirectionType | null {
+		return CoreTypes.LayoutDirection.ltr;
+	}
+
+	close(): void {
+		// no native surface under test
+	}
+}
+
+describe('window content resolution', () => {
+	let app: TestApplication;
+	let window: TestWindow;
+	let request: WindowContentRequest;
+	let mainEntryView: View;
+	let previousMainEntry: any;
+	let createViewFromEntry: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		previousMainEntry = getAppMainEntry();
+		installApplicationEventBus();
+		app = new TestApplication();
+		window = new TestWindow('window-1', true);
+		request = { window, isPrimary: true };
+		mainEntryView = createFakeView('main-entry');
+
+		setAppMainEntry({ moduleName: 'app-root' });
+		createViewFromEntry = vi.spyOn(Builder, 'createViewFromEntry').mockImplementation(() => mainEntryView);
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		setAppMainEntry(previousMainEntry);
+		installApplicationEventBus();
+	});
+
+	describe('the resolver chain', () => {
+		it('uses the View a resolver returns', () => {
+			const view = createFakeView('resolved');
+			app.setWindowContentResolver(() => view);
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(resolved).toBe(view);
+			expect(window.rootView).toBe(view);
+		});
+
+		it('hands the resolver the request it was given', () => {
+			const resolver = vi.fn(() => createFakeView('resolved'));
+			app.setWindowContentResolver(resolver);
+
+			app._resolveWindowContent(window, request);
+
+			expect(resolver).toHaveBeenCalledTimes(1);
+			expect(resolver).toHaveBeenCalledWith(request);
+		});
+
+		it('builds the NavigationEntry a resolver returns', () => {
+			const entry: NavigationEntry = { moduleName: 'pages/detail' };
+			const built = createFakeView('built');
+			createViewFromEntry.mockReturnValue(built);
+			app.setWindowContentResolver(() => entry);
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(createViewFromEntry).toHaveBeenCalledWith(entry);
+			expect(resolved).toBe(built);
+		});
+
+		it('builds the module name a resolver returns', () => {
+			const built = createFakeView('built');
+			createViewFromEntry.mockReturnValue(built);
+			app.setWindowContentResolver(() => 'pages/detail');
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(createViewFromEntry).toHaveBeenCalledWith({ moduleName: 'pages/detail' });
+			expect(resolved).toBe(built);
+		});
+
+		it('sets no content when a resolver returns null, leaving it to supply one later', () => {
+			const launched = vi.fn();
+			app.on('launch', launched);
+			app.setWindowContentResolver(() => null);
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(resolved).toBeNull();
+			expect(window.rootView).toBeUndefined();
+			expect(launched).not.toHaveBeenCalled();
+			expect(createViewFromEntry).not.toHaveBeenCalled();
+		});
+
+		it('falls through to the main entry when a resolver returns undefined', () => {
+			const resolver = vi.fn(() => undefined);
+			app.setWindowContentResolver(resolver);
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(resolver).toHaveBeenCalledTimes(1);
+			expect(createViewFromEntry).toHaveBeenCalledWith({ moduleName: 'app-root' });
+			expect(resolved).toBe(mainEntryView);
+			expect(window.rootView).toBe(mainEntryView);
+		});
+
+		it('falls back to the main entry when no resolver is set', () => {
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(resolved).toBe(mainEntryView);
+			expect(window.rootView).toBe(mainEntryView);
+		});
+
+		it('leaves the window empty instead of throwing when there is no main entry', () => {
+			setAppMainEntry(undefined);
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(resolved).toBeNull();
+			expect(window.rootView).toBeUndefined();
+		});
+
+		it('returns the built view without installing it when asked not to install', () => {
+			const view = createFakeView('resolved');
+			app.setWindowContentResolver(() => view);
+
+			const resolved = app._resolveWindowContent(window, request, { install: false });
+
+			expect(resolved).toBe(view);
+			expect(window.rootView).toBeUndefined();
+		});
+
+		it('drops a previously set resolver when it is cleared', () => {
+			app.setWindowContentResolver(() => createFakeView('resolved'));
+			app.setWindowContentResolver(null);
+
+			expect(app.getWindowContentResolver()).toBeNull();
+			expect(app._resolveWindowContent(window, request)).toBe(mainEntryView);
+		});
+	});
+
+	describe('the legacy launch bridge', () => {
+		it('uses the View a launch handler puts on args.root', () => {
+			const view = createFakeView('launch-root');
+			app.on('launch', (args: any) => {
+				args.root = view;
+			});
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(resolved).toBe(view);
+			expect(createViewFromEntry).not.toHaveBeenCalled();
+		});
+
+		it('sets no content when a launch handler puts null on args.root', () => {
+			app.on('launch', (args: any) => {
+				args.root = null;
+			});
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(resolved).toBeNull();
+			expect(window.rootView).toBeUndefined();
+			expect(createViewFromEntry).not.toHaveBeenCalled();
+		});
+
+		it('falls through to the main entry when a launch handler leaves args.root alone', () => {
+			const launched = vi.fn();
+			app.on('launch', launched);
+
+			const resolved = app._resolveWindowContent(window, request);
+
+			expect(launched).toHaveBeenCalledTimes(1);
+			expect(resolved).toBe(mainEntryView);
+		});
+
+		it('merges the platform launch data into the launch args', () => {
+			const received: any[] = [];
+			app.on('launch', (args: any) => received.push(args));
+
+			app._resolveWindowContent(window, request, { launchData: { android: 'intent' } });
+
+			expect(received[0].android).toBe('intent');
+			expect(received[0].eventName).toBe('launch');
+		});
+
+		it('fires for the first window only', () => {
+			const launched = vi.fn();
+			app.on('launch', launched);
+			const second = new TestWindow('window-2');
+
+			app._resolveWindowContent(window, request);
+			app._resolveWindowContent(second, { window: second, isPrimary: false });
+
+			expect(launched).toHaveBeenCalledTimes(1);
+		});
+
+		it('never fires once a resolver has answered the first window', () => {
+			const launched = vi.fn();
+			app.on('launch', launched);
+			app.setWindowContentResolver(() => createFakeView('resolved'));
+
+			app._resolveWindowContent(window, request);
+			app.setWindowContentResolver(null);
+			const second = new TestWindow('window-2');
+			app._resolveWindowContent(second, { window: second, isPrimary: false });
+
+			expect(launched).not.toHaveBeenCalled();
+			expect(second.rootView).toBe(mainEntryView);
+		});
+	});
+
+	describe('the ready event', () => {
+		it('is raised once, before any window opens', () => {
+			const order: string[] = [];
+			app.on('ready', () => order.push('ready'));
+			app.on('windowOpen', () => order.push('windowOpen'));
+			app.on('launch', () => order.push('launch'));
+
+			app.notifyReady();
+			app._registerWindow(window);
+			app._resolveWindowContent(window, request);
+
+			expect(order).toEqual(['ready', 'windowOpen', 'launch']);
+		});
+
+		it('is not raised a second time', () => {
+			const ready = vi.fn();
+			app.on('ready', ready);
+
+			app.notifyReady();
+			app.notifyReady();
+
+			expect(ready).toHaveBeenCalledTimes(1);
+		});
+
+		it('precedes windowOpen for every window, however many open', () => {
+			const order: string[] = [];
+			app.on('ready', () => order.push('ready'));
+			app.on('windowOpen', () => order.push('windowOpen'));
+
+			app.notifyReady();
+			app._registerWindow(window);
+			app._registerWindow(new TestWindow('window-2'));
+
+			expect(order).toEqual(['ready', 'windowOpen', 'windowOpen']);
+		});
+	});
+
+	describe('app css loading', () => {
+		let loadAppCss: ReturnType<typeof vi.spyOn>;
+
+		beforeEach(() => {
+			loadAppCss = vi.spyOn(app, 'loadAppCss').mockImplementation(() => {});
+		});
+
+		it('loads once when a resolver supplies the content', () => {
+			app.setWindowContentResolver(() => createFakeView('resolved'));
+
+			app._resolveWindowContent(window, request);
+
+			expect(loadAppCss).toHaveBeenCalledTimes(1);
+		});
+
+		it('loads once when a resolver takes ownership by returning null', () => {
+			app.setWindowContentResolver(() => null);
+
+			app._resolveWindowContent(window, request);
+
+			expect(loadAppCss).toHaveBeenCalledTimes(1);
+		});
+
+		it('loads once on the legacy launch path', () => {
+			app.on('launch', (args: any) => {
+				args.root = createFakeView('launch-root');
+			});
+
+			app._resolveWindowContent(window, request);
+
+			expect(loadAppCss).toHaveBeenCalledTimes(1);
+		});
+
+		it('loads once on the main entry path', () => {
+			app._resolveWindowContent(window, request);
+
+			expect(loadAppCss).toHaveBeenCalledTimes(1);
+		});
+
+		it('loads only once across several windows', () => {
+			app.setWindowContentResolver(() => createFakeView('resolved'));
+			const second = new TestWindow('window-2');
+
+			app._resolveWindowContent(window, request);
+			app._resolveWindowContent(second, { window: second, isPrimary: false });
+
+			expect(loadAppCss).toHaveBeenCalledTimes(1);
+		});
+
+		it('loads after the launch handlers, which may still change the css file', () => {
+			let cssFileAtLoad: string;
+			loadAppCss.mockImplementation(() => {
+				cssFileAtLoad = app.getCssFileName();
+			});
+			app.on('launch', () => {
+				app.setCssFileName('./themed.css');
+			});
+
+			app._resolveWindowContent(window, request);
+
+			expect(cssFileAtLoad).toBe('./themed.css');
+		});
+	});
+});
diff --git a/packages/core/css/system-classes.ts b/packages/core/css/system-classes.ts
index 3c1edadcb9..dc5c35fe32 100644
--- a/packages/core/css/system-classes.ts
+++ b/packages/core/css/system-classes.ts
@@ -1,3 +1,5 @@
+import { CoreTypes } from '../core-types';
+
 const MODAL = 'modal';
 const ROOT = 'root';
 const cssClasses = [];
@@ -7,6 +9,32 @@ export namespace CSSUtils {
 	export const MODAL_ROOT_VIEW_CSS_CLASS = `${CLASS_PREFIX}${MODAL}`;
 	export const ROOT_VIEW_CSS_CLASS = `${CLASS_PREFIX}${ROOT}`;
 
+	// prettier-ignore
+	export const ORIENTATION_CSS_CLASSES = [
+		`${CLASS_PREFIX}${CoreTypes.DeviceOrientation.portrait}`,
+		`${CLASS_PREFIX}${CoreTypes.DeviceOrientation.landscape}`,
+		`${CLASS_PREFIX}${CoreTypes.DeviceOrientation.unknown}`,
+	];
+
+	// prettier-ignore
+	export const SYSTEM_APPEARANCE_CSS_CLASSES = [
+		`${CLASS_PREFIX}${CoreTypes.SystemAppearance.light}`,
+		`${CLASS_PREFIX}${CoreTypes.SystemAppearance.dark}`,
+	];
+
+	// prettier-ignore
+	export const LAYOUT_DIRECTION_CSS_CLASSES = [
+		`${CLASS_PREFIX}${CoreTypes.LayoutDirection.ltr}`,
+		`${CLASS_PREFIX}${CoreTypes.LayoutDirection.rtl}`,
+	];
+
+	/**
+	 * Classes describing the state of a single window. Two windows can legitimately
+	 * disagree on all of them, so they live on each window's root view (and the modals
+	 * presented over it) rather than in the process-wide system class list.
+	 */
+	export const WINDOW_SCOPED_CSS_CLASSES = [...ORIENTATION_CSS_CLASSES, ...SYSTEM_APPEARANCE_CSS_CLASSES, ...LAYOUT_DIRECTION_CSS_CLASSES];
+
 	export function getSystemCssClasses(): string[] {
 		return cssClasses;
 	}
diff --git a/packages/core/data/observable/index.ts b/packages/core/data/observable/index.ts
index 40555644fd..323ce20149 100644
--- a/packages/core/data/observable/index.ts
+++ b/packages/core/data/observable/index.ts
@@ -266,6 +266,16 @@ export class Observable {
 		}
 	}
 
+	/**
+	 * Removes every listener registered on this instance.
+	 * @internal
+	 */
+	public _clearEventListeners(): void {
+		for (const eventName in this._observers) {
+			delete this._observers[eventName];
+		}
+	}
+
 	/**
 	 * Please avoid using the static event-handling APIs as they will be removed
 	 * in future.
diff --git a/packages/core/global-types.d.ts b/packages/core/global-types.d.ts
index 78ca864489..f97ee4bd24 100644
--- a/packages/core/global-types.d.ts
+++ b/packages/core/global-types.d.ts
@@ -45,6 +45,12 @@ declare module globalThis {
 		 * @param callback wire up any global event handling inside the callback
 		 */
 		addEventWiring(callback: () => void): void;
+
+		/**
+		 * Marks the app as launched. Idempotent, and safe to call directly: not every launch
+		 * path raises the legacy `launch` event, so the subscription cannot be relied on.
+		 */
+		setLaunched(): void;
 	};
 	// var android: any;
 	function require(id: string): any;
@@ -165,39 +171,39 @@ interface NodeModule {
 }
 
 declare enum RequestContext {
-	'audio',
-	'beacon',
-	'cspreport',
-	'download',
-	'embed',
-	'eventsource',
-	'favicon',
-	'fetch',
-	'font',
-	'form',
-	'frame',
-	'hyperlink',
-	'iframe',
-	'image',
-	'imageset',
-	'import',
-	'internal',
-	'location',
-	'manifest',
-	'object',
-	'ping',
-	'plugin',
-	'prefetch',
-	'script',
-	'serviceworker',
-	'sharedworker',
-	'subresource',
-	'style',
-	'track',
-	'video',
-	'worker',
-	'xmlhttprequest',
-	'xslt',
+	audio,
+	beacon,
+	cspreport,
+	download,
+	embed,
+	eventsource,
+	favicon,
+	fetch,
+	font,
+	form,
+	frame,
+	hyperlink,
+	iframe,
+	image,
+	imageset,
+	import,
+	internal,
+	location,
+	manifest,
+	object,
+	ping,
+	plugin,
+	prefetch,
+	script,
+	serviceworker,
+	sharedworker,
+	subresource,
+	style,
+	track,
+	video,
+	worker,
+	xmlhttprequest,
+	xslt,
 }
 
 // Extend the lib.dom.d.ts Body interface with `formData`
diff --git a/packages/core/globals/global-utils.ts b/packages/core/globals/global-utils.ts
index d01dd8c7be..c3fb32fa55 100644
--- a/packages/core/globals/global-utils.ts
+++ b/packages/core/globals/global-utils.ts
@@ -15,7 +15,7 @@ export class NativeScriptGlobalState {
 	constructor() {
 		// console.log('creating NativeScriptGlobals...')
 		this.events = new Observable();
-		this._setLaunched = this._setLaunchedFn.bind(this);
+		this._setLaunched = () => this.setLaunched();
 		this.events.on('launch', this._setLaunched);
 		if (profilingLevel() > 0) {
 			this.events.on('displayed', () => {
@@ -58,11 +58,17 @@ export class NativeScriptGlobalState {
 		}
 	}
 
-	private _setLaunchedFn() {
-		// console.log('NativeScriptGlobals launch fired!');
+	/**
+	 * Marks the app as launched. Idempotent, and safe to call directly: not every launch
+	 * path raises the legacy `launch` event, so the subscription cannot be relied on.
+	 */
+	setLaunched() {
 		this.launched = true;
-		this.events.off('launch', this._setLaunched);
-		this._setLaunched = null;
+
+		if (this._setLaunched) {
+			this.events.off('launch', this._setLaunched);
+			this._setLaunched = null;
+		}
 	}
 }
 export function getNativeScriptGlobals() {
diff --git a/packages/core/index.d.ts b/packages/core/index.d.ts
index 93539deb49..d97326afaf 100644
--- a/packages/core/index.d.ts
+++ b/packages/core/index.d.ts
@@ -11,6 +11,7 @@ export type { NativeScriptConfig } from './config';
 export * from './application';
 export { androidRegisterBroadcastReceiver, androidUnregisterBroadcastReceiver, androidRegisteredReceivers, iosAddNotificationObserver, iosRemoveNotificationObserver, iosNotificationObservers } from './application/helpers';
 export { getNativeApp, setNativeApp } from './application/helpers-common';
+export * from './native-window';
 export * as ApplicationSettings from './application-settings';
 export namespace AccessibilityEvents {
 	export const accessibilityBlurEvent: 'accessibilityBlur';
diff --git a/packages/core/index.ts b/packages/core/index.ts
index 4e12c9fe93..f7fe4efefc 100644
--- a/packages/core/index.ts
+++ b/packages/core/index.ts
@@ -4,6 +4,7 @@
 import './globals';
 export * from './application';
 export { getNativeApp, setNativeApp } from './application/helpers-common';
+export * from './native-window';
 export * as ApplicationSettings from './application-settings';
 import * as Accessibility from './accessibility';
 export namespace AccessibilityEvents {
diff --git a/packages/core/native-window/index.d.ts b/packages/core/native-window/index.d.ts
new file mode 100644
index 0000000000..fd6dd30cfc
--- /dev/null
+++ b/packages/core/native-window/index.d.ts
@@ -0,0 +1,426 @@
+import { Observable } from '../data/observable';
+import type { CoreTypes } from '../core-types';
+import type { View } from '../ui/core/view';
+import type { NavigationEntry } from '../ui/frame/frame-interfaces';
+import type { AndroidActivityEventData, AndroidActivityBundleEventData, AndroidActivityResultEventData, AndroidActivityBackPressedEventData, AndroidActivityNewIntentEventData, AndroidActivityRequestPermissionsEventData, SceneEventData, SceneOpenURLContextsEventData, SceneContinueUserActivityEventData, ScenePerformActionForShortcutItemEventData } from '../application/application-interfaces';
+import type { NativeWindowEventData, WindowBaseEventData, WindowLayoutDirectionChangedEventData, WindowOrientationChangedEventData, WindowSystemAppearanceChangedEventData } from './native-window-interfaces';
+
+export * from './native-window-interfaces';
+
+/**
+ * The purpose a window surface serves.
+ *
+ * - `application` – a regular app window (iOS application scene, Android activity).
+ * - `embedded` – a window hosted inside another app or container.
+ * - `carplay` – a CarPlay template scene.
+ * - `externalDisplay` – an external/secondary display scene.
+ */
+export type WindowRole = 'application' | 'embedded' | 'carplay' | 'externalDisplay';
+
+/**
+ * The lifecycle state of a window surface.
+ *
+ * - `attached` – connected to a live native surface.
+ * - `detached` – the native surface went away but the window may be reconnected.
+ * - `closed` – permanently torn down.
+ */
+export type WindowState = 'attached' | 'detached' | 'closed';
+
+/**
+ * Cross-platform base for any window surface.
+ *
+ * Carries identity, role, state, lifecycle events and the native accessors.
+ * Surfaces that host a NativeScript view tree are {@link NativeWindow} instances.
+ */
+export abstract class WindowBase extends Observable {
+	/**
+	 * Stable identifier of this window, unique for the lifetime of the JS context.
+	 * Survives a detach/re-attach, so it can be used to correlate a window across
+	 * an iOS scene reconnect or an Android activity recreation.
+	 */
+	readonly id: string;
+
+	/**
+	 * The purpose this window surface serves.
+	 */
+	readonly role: WindowRole;
+
+	/**
+	 * Where this window currently sits in its lifecycle.
+	 */
+	readonly state: WindowState;
+
+	/**
+	 * Whether this is the application's primary window.
+	 *
+	 * At most one window is primary at a time. When the primary window closes another
+	 * attached window is promoted and `primaryWindowChanged` is raised on the Application.
+	 */
+	readonly isPrimary: boolean;
+
+	/**
+	 * The iOS surface backing this window, or `undefined` when not running on iOS.
+	 * `scene` is absent for apps still on the pre-scene (window-only) lifecycle.
+	 */
+	readonly ios?: { readonly scene?: UIWindowScene; readonly uiWindow: UIWindow };
+
+	/**
+	 * The Android surface backing this window, or `undefined` when not running on Android
+	 * or when the activity is already gone.
+	 */
+	readonly android?: { readonly activity: androidx.appcompat.app.AppCompatActivity };
+
+	/**
+	 * Closes this window.
+	 *
+	 * Ends the window session: the native surface is dismissed, `close` is raised and the
+	 * window is dropped from the Application registry.
+	 */
+	abstract close(): void;
+
+	/**
+	 * Raised when the window becomes the active/focused window.
+	 */
+	on(event: 'activate', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the window loses focus.
+	 */
+	on(event: 'deactivate', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the window enters the background.
+	 */
+	on(event: 'background', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the window enters the foreground.
+	 */
+	on(event: 'foreground', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when a native surface is bound to the window - both on the first connect and
+	 * on every re-attach after a `detached`.
+	 */
+	on(event: 'attached', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the native surface goes away while the window session stays alive
+	 * (iOS scene disconnect, Android activity recreation).
+	 *
+	 * The window stays registered on the Application and keeps its listeners, so the same
+	 * instance is handed back when a surface re-attaches and handlers registered before the
+	 * detach keep working afterwards.
+	 */
+	on(event: 'detached', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the window session ends for good.
+	 *
+	 * Fires exactly once per window. Listeners stay registered for the whole teardown, so a
+	 * handler added at any earlier point still observes it; immediately after it is
+	 * dispatched the framework drops every listener on the instance, so nothing registered
+	 * on a window outlives the window.
+	 */
+	on(event: 'close', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised after the window content has been displayed for the first time.
+	 */
+	on(event: 'displayed', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the orientation of this window changes.
+	 */
+	on(event: 'orientationChanged', callback: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the system appearance of this window changes between light and dark.
+	 */
+	on(event: 'systemAppearanceChanged', callback: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Raised when the layout direction of this window changes between ltr and rtl.
+	 */
+	on(event: 'layoutDirectionChanged', callback: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+
+	on(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	on(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	on(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	on(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillConnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidActivate', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillResignActive', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillEnterForeground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidEnterBackground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidDisconnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	on(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Adds a listener for the specified event name.
+	 *
+	 * @param eventName The name of the event.
+	 * @param callback The event listener to add. Will be called when an event of
+	 * the given name is raised.
+	 * @param thisArg An optional parameter which, when set, will be bound as the
+	 * `this` context when the callback is called. Falsy values will be not be
+	 * bound.
+	 */
+	on(eventName: string, callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	once(event: 'activate', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'deactivate', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'background', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'foreground', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'attached', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'detached', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'close', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'displayed', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	once(event: 'orientationChanged', callback: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+	once(event: 'systemAppearanceChanged', callback: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+	once(event: 'layoutDirectionChanged', callback: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+	once(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	once(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	once(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	once(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	once(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	once(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	once(event: 'sceneWillConnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneDidActivate', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneWillResignActive', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneWillEnterForeground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneDidEnterBackground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneDidDisconnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	once(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	once(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Adds a listener for the specified event name that is removed as soon as it is raised
+	 * once.
+	 */
+	once(eventName: string, callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+
+	off(event: 'activate', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'deactivate', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'background', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'foreground', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'attached', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'detached', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'close', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'displayed', callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	off(event: 'orientationChanged', callback?: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+	off(event: 'systemAppearanceChanged', callback?: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+	off(event: 'layoutDirectionChanged', callback?: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+	off(event: 'activityCreated', callback?: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	off(event: 'activityDestroyed', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityStarted', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityPaused', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityResumed', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityStopped', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'saveActivityState', callback?: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	off(event: 'activityResult', callback?: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	off(event: 'activityBackPressed', callback?: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	off(event: 'activityNewIntent', callback?: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	off(event: 'activityRequestPermissions', callback?: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	off(event: 'sceneWillConnect', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneDidActivate', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneWillResignActive', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneWillEnterForeground', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneDidEnterBackground', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneDidDisconnect', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneOpenURLContexts', callback?: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	off(event: 'sceneContinueUserActivity', callback?: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	off(event: 'scenePerformActionForShortcutItem', callback?: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+
+	/**
+	 * Removes a listener for the specified event name. Omitting the callback removes every
+	 * listener registered for that event on this window.
+	 */
+	off(eventName: string, callback?: (data: WindowBaseEventData) => void, thisArg?: any): void;
+}
+
+/**
+ * A window surface that hosts a NativeScript view tree.
+ *
+ * Wraps a platform window (iOS UIWindowScene + UIWindow, Android Activity) and owns the
+ * per-window root view, its CSS classes and its lifecycle events. Instances are created by
+ * the framework as the platform connects surfaces; reach them through
+ * `Application.activeWindow`, `Application.primaryWindow`, `Application.getWindows()` or
+ * `Application.getWindowById()`, and use `ios` / `android` to get at the native objects.
+ */
+export abstract class NativeWindow extends WindowBase {
+	/**
+	 * The root view currently hosted by this window, if any.
+	 */
+	readonly rootView: View;
+
+	/**
+	 * Sets the content of this window.
+	 *
+	 * Replaces any content set earlier, tears the previous root view down and raises
+	 * `contentLoaded`.
+	 *
+	 * A view that is already the root of another window is released from it first — that
+	 * window's `rootView` becomes null — while the view itself is left intact.
+	 *
+	 * @param content A View, a NavigationEntry, or the name of a module to load.
+	 */
+	setContent(content: View | NavigationEntry | string): void;
+
+	/**
+	 * The current orientation of this window.
+	 *
+	 * Read from the native surface while the window is attached; a detached window reports
+	 * the last value it saw. A read that catches a change the platform has not reported yet
+	 * also raises `orientationChanged`, so a change is never swallowed by the reading.
+	 */
+	orientation(): 'portrait' | 'landscape' | 'unknown';
+
+	/**
+	 * The current system appearance of this window.
+	 *
+	 * Read from the native surface while the window is attached; a detached window reports
+	 * the last value it saw. A read that catches a change the platform has not reported yet
+	 * also raises `systemAppearanceChanged`, so a change is never swallowed by the reading.
+	 */
+	systemAppearance(): 'light' | 'dark' | null;
+
+	/**
+	 * The current layout direction of this window.
+	 *
+	 * Read from the native surface while the window is attached; a detached window reports
+	 * the last value it saw. A read that catches a change the platform has not reported yet
+	 * also raises `layoutDirectionChanged`, so a change is never swallowed by the reading.
+	 */
+	layoutDirection(): CoreTypes.LayoutDirectionType | null;
+
+	/**
+	 * Raised when the root view content of this window is set or changed.
+	 *
+	 * Bringing a window up follows a fixed order that app code can rely on:
+	 * Application `ready` -> Application `windowOpen` -> the raw platform connect/create
+	 * event (`sceneWillConnect` / `activityCreated`) -> content resolution (the window
+	 * content resolver, or the legacy `launch` bridge for the first window) ->
+	 * `contentLoaded` -> `activate` and `displayed`.
+	 */
+	on(event: 'contentLoaded', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+
+	// The whole inherited set is repeated below: an override only covers the overloads it
+	// lists, so declaring `contentLoaded` alone would hide every WindowBase event. See
+	// WindowBase for what each of them means.
+	on(event: 'activate', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'deactivate', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'background', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'foreground', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'attached', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'detached', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'close', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'displayed', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'orientationChanged', callback: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+	on(event: 'systemAppearanceChanged', callback: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+	on(event: 'layoutDirectionChanged', callback: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+	on(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	on(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	on(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	on(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillConnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidActivate', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillResignActive', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillEnterForeground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidEnterBackground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidDisconnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	on(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+	on(eventName: string, callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+
+	once(event: 'contentLoaded', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'activate', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'deactivate', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'background', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'foreground', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'attached', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'detached', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'close', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'displayed', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	once(event: 'orientationChanged', callback: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+	once(event: 'systemAppearanceChanged', callback: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+	once(event: 'layoutDirectionChanged', callback: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+	once(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	once(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	once(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	once(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	once(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	once(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	once(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	once(event: 'sceneWillConnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneDidActivate', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneWillResignActive', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneWillEnterForeground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneDidEnterBackground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneDidDisconnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	once(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	once(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	once(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+	once(eventName: string, callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+
+	off(event: 'contentLoaded', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'activate', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'deactivate', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'background', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'foreground', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'attached', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'detached', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'close', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'displayed', callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	off(event: 'orientationChanged', callback?: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+	off(event: 'systemAppearanceChanged', callback?: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+	off(event: 'layoutDirectionChanged', callback?: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+	off(event: 'activityCreated', callback?: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	off(event: 'activityDestroyed', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityStarted', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityPaused', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityResumed', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'activityStopped', callback?: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	off(event: 'saveActivityState', callback?: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	off(event: 'activityResult', callback?: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	off(event: 'activityBackPressed', callback?: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	off(event: 'activityNewIntent', callback?: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	off(event: 'activityRequestPermissions', callback?: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	off(event: 'sceneWillConnect', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneDidActivate', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneWillResignActive', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneWillEnterForeground', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneDidEnterBackground', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneDidDisconnect', callback?: (args: SceneEventData) => void, thisArg?: any): void;
+	off(event: 'sceneOpenURLContexts', callback?: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	off(event: 'sceneContinueUserActivity', callback?: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	off(event: 'scenePerformActionForShortcutItem', callback?: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+	off(eventName: string, callback?: (data: NativeWindowEventData) => void, thisArg?: any): void;
+}
diff --git a/packages/core/native-window/index.ts b/packages/core/native-window/index.ts
new file mode 100644
index 0000000000..01f226697c
--- /dev/null
+++ b/packages/core/native-window/index.ts
@@ -0,0 +1,3 @@
+export * from './native-window-interfaces';
+export * from './window-base';
+export * from './native-window-common';
diff --git a/packages/core/native-window/native-window-common.ts b/packages/core/native-window/native-window-common.ts
new file mode 100644
index 0000000000..d2dc0338a9
--- /dev/null
+++ b/packages/core/native-window/native-window-common.ts
@@ -0,0 +1,447 @@
+import { CoreTypes } from '../core-types';
+import { CSSUtils } from '../css/system-classes';
+import { Device } from '../platform';
+import { Trace } from '../trace';
+import { Builder } from '../ui/builder';
+import type { View } from '../ui/core/view';
+import type { Frame } from '../ui/frame';
+import type { NavigationEntry } from '../ui/frame/frame-interfaces';
+import type { StyleScope } from '../ui/styling/style-scope';
+import { applyAccessibilityCssToRoot, readyInitAccessibilityCssHelper, readyInitFontScale } from '../accessibility/accessibility-common';
+import { SDK_VERSION } from '../utils/constants';
+import type { NativeWindowEventData, NativeWindowEventName, WindowLayoutDirectionChangedEventData, WindowOrientationChangedEventData, WindowSystemAppearanceChangedEventData } from './native-window-interfaces';
+import type { AndroidActivityEventData, AndroidActivityBundleEventData, AndroidActivityResultEventData, AndroidActivityBackPressedEventData, AndroidActivityNewIntentEventData, AndroidActivityRequestPermissionsEventData, SceneEventData, SceneOpenURLContextsEventData, SceneContinueUserActivityEventData, ScenePerformActionForShortcutItemEventData } from '../application/application-interfaces';
+import { NativeWindowEvents } from './native-window-interfaces';
+import { getAutoSystemAppearanceChanged } from '../application/helpers-common';
+import type { WindowRole } from './window-base';
+import { WindowBase } from './window-base';
+
+const ORIENTATION_CSS_CLASSES = CSSUtils.ORIENTATION_CSS_CLASSES;
+const SYSTEM_APPEARANCE_CSS_CLASSES = CSSUtils.SYSTEM_APPEARANCE_CSS_CLASSES;
+const LAYOUT_DIRECTION_CSS_CLASSES = CSSUtils.LAYOUT_DIRECTION_CSS_CLASSES;
+
+/**
+ * Cross-platform NativeWindow base class.
+ *
+ * Wraps a platform window surface (iOS UIWindowScene+UIWindow, Android Activity)
+ * and manages per-window root view lifecycle, CSS classes, and events.
+ *
+ * Platform-specific subclasses implement the abstract methods.
+ */
+export abstract class NativeWindow extends WindowBase {
+	protected _rootView: View;
+	protected _orientation: 'portrait' | 'landscape' | 'unknown';
+	protected _systemAppearance: 'dark' | 'light' | null;
+	protected _layoutDirection: CoreTypes.LayoutDirectionType | null;
+
+	constructor(id?: string, isPrimary = false, role: WindowRole = 'application') {
+		super(id, isPrimary, role);
+	}
+
+	get rootView(): View {
+		return this._rootView;
+	}
+
+	/**
+	 * Set the content of this window.
+	 * Accepts a View, a NavigationEntry, or a module name string.
+	 */
+	setContent(content: View | NavigationEntry | string): void {
+		let view: View;
+
+		if (typeof content === 'string') {
+			view = Builder.createViewFromEntry({ moduleName: content });
+		} else if (content && typeof content === 'object') {
+			if ((content as NavigationEntry).moduleName || (content as NavigationEntry).create) {
+				view = Builder.createViewFromEntry(content as NavigationEntry);
+			} else {
+				view = content as View;
+			}
+		}
+
+		if (!view) {
+			throw new Error('NativeWindow.setContent: Invalid content provided.');
+		}
+
+		const previousRootView = this._rootView;
+		if (previousRootView) {
+			previousRootView._onRootViewReset();
+		}
+
+		this._takeRootView(view);
+		this._applyRootViewSettings(view);
+		this._setNativeContent(view);
+
+		this._notifyEvent(NativeWindowEvents.contentLoaded);
+	}
+
+	/**
+	 * @internal – take ownership of a root view the platform pipeline built and attached itself.
+	 *
+	 * The pipeline already ran `_setupAsRootView` and `Application.initRootView` on this view and
+	 * installed it on the native surface, so neither `_applyRootViewSettings` nor `_setNativeContent`
+	 * may run here — both would redo that work.
+	 */
+	_adoptRootView(view: View): void {
+		if (!view || this._rootView === view) {
+			return;
+		}
+
+		this._takeRootView(view);
+
+		this._notifyEvent(NativeWindowEvents.contentLoaded);
+	}
+
+	/**
+	 * @internal – give up the root view without tearing it down.
+	 *
+	 * Called when another window takes the view over: the view is being moved, not
+	 * destroyed, so — unlike {@link _onDestroy} — nothing here unloads, resets or tears
+	 * down the view. It stays loaded and usable in its new window.
+	 */
+	_releaseRootView(): void {
+		const rootView = this._rootView;
+		if (!rootView) {
+			return;
+		}
+
+		this._onReleaseRootView(rootView);
+
+		rootView._nativeWindow = null;
+		this._rootView = null;
+	}
+
+	/**
+	 * Platform hook: unhook the released view from the native surface. The view itself
+	 * must survive — it is on its way into another window.
+	 */
+	protected _onReleaseRootView(rootView: View): void {
+		// noop
+	}
+
+	/**
+	 * Becomes the owner of `view`, releasing it from whichever window held it before.
+	 */
+	private _takeRootView(view: View): void {
+		const currentOwner = view._nativeWindow;
+		if (currentOwner && currentOwner !== this) {
+			currentOwner._releaseRootView();
+		}
+
+		if (this._rootView && this._rootView !== view) {
+			this._rootView._nativeWindow = null;
+		}
+
+		this._rootView = view;
+		view._nativeWindow = this;
+	}
+
+	/**
+	 * Platform-specific: apply the view to the native window surface.
+	 */
+	protected abstract _setNativeContent(view: View): void;
+
+	/**
+	 * Get the current orientation of this window.
+	 *
+	 * Read from the native surface while the window is attached; a detached window
+	 * reports the last value it saw.
+	 *
+	 * A read that catches a change the platform has not reported yet goes through
+	 * {@link _setOrientation}, so the change is never swallowed by the reading.
+	 */
+	orientation(): 'portrait' | 'landscape' | 'unknown' {
+		if (this.state === 'attached') {
+			const value = this._getOrientation();
+			if (this._orientation === undefined) {
+				this._orientation = value;
+			} else if (this._orientation !== value) {
+				this._setOrientation(value);
+			}
+		}
+
+		return this._orientation;
+	}
+
+	/**
+	 * Get the current system appearance of this window.
+	 *
+	 * Read from the native surface while the window is attached; a detached window
+	 * reports the last value it saw.
+	 *
+	 * A read that catches a change the platform has not reported yet goes through
+	 * {@link _setSystemAppearance}, so the change is never swallowed by the reading.
+	 */
+	systemAppearance(): 'light' | 'dark' | null {
+		if (this.state === 'attached') {
+			const value = this._getSystemAppearance();
+			if (this._systemAppearance === undefined) {
+				this._systemAppearance = value;
+			} else if (this._systemAppearance !== value && value !== null) {
+				this._setSystemAppearance(value);
+			}
+		}
+
+		return this._systemAppearance;
+	}
+
+	/**
+	 * Get the current layout direction of this window.
+	 *
+	 * Read from the native surface while the window is attached; a detached window
+	 * reports the last value it saw.
+	 *
+	 * A read that catches a change the platform has not reported yet goes through
+	 * {@link _setLayoutDirection}, so the change is never swallowed by the reading.
+	 */
+	layoutDirection(): CoreTypes.LayoutDirectionType | null {
+		if (this.state === 'attached') {
+			const value = this._getLayoutDirection();
+			if (this._layoutDirection === undefined) {
+				this._layoutDirection = value;
+			} else if (this._layoutDirection !== value && value !== null) {
+				this._setLayoutDirection(value);
+			}
+		}
+
+		return this._layoutDirection;
+	}
+
+	// --- Typed event overloads ---
+
+	// The whole set is repeated here: TypeScript only accepts an override whose overloads
+	// cover every overload of the base signature.
+	on(event: 'contentLoaded', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'activate', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'deactivate', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'background', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'foreground', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'close', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'attached', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'detached', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'displayed', callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(event: 'orientationChanged', callback: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+	on(event: 'systemAppearanceChanged', callback: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+	on(event: 'layoutDirectionChanged', callback: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+	on(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	on(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	on(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	on(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillConnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidActivate', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillResignActive', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillEnterForeground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidEnterBackground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidDisconnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	on(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+	on(eventName: string, callback: (data: NativeWindowEventData) => void, thisArg?: any): void;
+	on(eventName: string, callback: (data: any) => void, thisArg?: any): void {
+		super.on(eventName, callback, thisArg);
+	}
+
+	// Platform-specific abstract getters
+	protected abstract _getOrientation(): 'portrait' | 'landscape' | 'unknown';
+	protected abstract _getSystemAppearance(): 'light' | 'dark' | null;
+	protected abstract _getLayoutDirection(): CoreTypes.LayoutDirectionType | null;
+
+	// --- Root view CSS class management ---
+
+	/**
+	 * Applies platform, orientation, appearance, and layout direction CSS classes
+	 * to the root view.
+	 */
+	protected _applyRootViewSettings(rootView: View): void {
+		rootView._setupAsRootView({});
+		this._setRootViewCSSClasses(rootView);
+		readyInitAccessibilityCssHelper();
+		readyInitFontScale();
+		applyAccessibilityCssToRoot(rootView);
+	}
+
+	private _setRootViewCSSClasses(rootView: View): void {
+		const platform = Device.os.toLowerCase();
+		const deviceType = Device.deviceType.toLowerCase();
+
+		if (platform) {
+			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${platform}`);
+
+			// SDK Version CSS classes
+			// Add exact version class (e.g., .ns-ios-26 or .ns-android-36)
+			// this acts like 'gte' for that major version range
+			// e.g., if user wants iOS 27, they can add .ns-ios-27 specifiers
+			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${platform}-${Math.floor(SDK_VERSION)}`);
+		}
+
+		if (deviceType) {
+			CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${deviceType}`);
+		}
+
+		rootView.cssClasses.add(CSSUtils.ROOT_VIEW_CSS_CLASS);
+		const rootViewCssClasses = CSSUtils.getSystemCssClasses();
+		rootViewCssClasses.forEach((c) => rootView.cssClasses.add(c));
+
+		// Two windows can disagree on these, so they never reach the process-wide
+		// system class list — see CSSUtils.WINDOW_SCOPED_CSS_CLASSES.
+		const orientationValue = this.orientation();
+		const appearanceValue = this.systemAppearance();
+		const directionValue = this.layoutDirection();
+
+		if (orientationValue) {
+			rootView.cssClasses.add(`${CSSUtils.CLASS_PREFIX}${orientationValue}`);
+		}
+
+		if (appearanceValue) {
+			rootView.cssClasses.add(`${CSSUtils.CLASS_PREFIX}${appearanceValue}`);
+		}
+
+		if (directionValue) {
+			rootView.cssClasses.add(`${CSSUtils.CLASS_PREFIX}${directionValue}`);
+		}
+
+		this._increaseStyleScopeVersion(rootView);
+		rootView._onCssStateChange();
+
+		if (Trace.isEnabled()) {
+			const rootCssClasses = Array.from(rootView.cssClasses);
+			Trace.write(`NativeWindow [${this.id}] Setting root css classes: ${rootCssClasses.join(' ')}`, Trace.categories.Style);
+		}
+	}
+
+	// --- Orientation / Appearance / Direction change handling ---
+
+	/**
+	 * @internal – called by platform when orientation changes for this window.
+	 */
+	_setOrientation(value: 'portrait' | 'landscape' | 'unknown'): void {
+		if (this._orientation === value) {
+			return;
+		}
+		this._orientation = value;
+		if (this._rootView) {
+			const cssClass = `${CSSUtils.CLASS_PREFIX}${value}`;
+			this._applyCssClass(this._rootView, ORIENTATION_CSS_CLASSES, cssClass);
+		}
+		this._notifyValueChanged(NativeWindowEvents.orientationChanged, value);
+	}
+
+	/**
+	 * @internal – called by platform when system appearance changes for this window.
+	 */
+	_setSystemAppearance(value: 'dark' | 'light'): void {
+		if (this._systemAppearance === value) {
+			return;
+		}
+		this._systemAppearance = value;
+		// `Application.autoSystemAppearanceChanged` opts out of the CSS classes only —
+		// the event still fires so apps driving their own theming can react to it.
+		if (this._rootView && getAutoSystemAppearanceChanged()) {
+			const cssClass = `${CSSUtils.CLASS_PREFIX}${value}`;
+			this._applyCssClass(this._rootView, SYSTEM_APPEARANCE_CSS_CLASSES, cssClass);
+		}
+		this._notifyValueChanged(NativeWindowEvents.systemAppearanceChanged, value);
+	}
+
+	/**
+	 * @internal – called by platform when layout direction changes for this window.
+	 */
+	_setLayoutDirection(value: CoreTypes.LayoutDirectionType): void {
+		if (this._layoutDirection === value) {
+			return;
+		}
+		this._layoutDirection = value;
+		if (this._rootView) {
+			const cssClass = `${CSSUtils.CLASS_PREFIX}${value}`;
+			this._applyCssClass(this._rootView, LAYOUT_DIRECTION_CSS_CLASSES, cssClass);
+		}
+		this._notifyValueChanged(NativeWindowEvents.layoutDirectionChanged, value);
+	}
+
+	// --- Internal helpers ---
+
+	private _notifyValueChanged(eventName: NativeWindowEventName, newValue: unknown): void {
+		this.notify({
+			eventName,
+			object: this,
+			window: this,
+			newValue,
+		});
+	}
+
+	private _applyCssClass(rootView: View, cssClasses: string[], newCssClass: string): void {
+		if (!rootView.cssClasses.has(newCssClass)) {
+			cssClasses.forEach((cssClass) => rootView.cssClasses.delete(cssClass));
+			rootView.cssClasses.add(newCssClass);
+			this._increaseStyleScopeVersion(rootView);
+			rootView._onCssStateChange();
+		}
+
+		// The modal registry is process-wide, so only the modals presented over this
+		// window's root view may follow it.
+		const rootModalViews = <Array<View>>rootView._getRootModalViews();
+		rootModalViews.forEach((modalView) => {
+			if (modalView._getRootModalHost() !== rootView) {
+				return;
+			}
+
+			if (!modalView.cssClasses.has(newCssClass)) {
+				cssClasses.forEach((cssClass) => modalView.cssClasses.delete(cssClass));
+				modalView.cssClasses.add(newCssClass);
+				modalView._onCssStateChange();
+			}
+		});
+	}
+
+	private _increaseStyleScopeVersion(rootView: View): void {
+		const styleScope: StyleScope = rootView._styleScope ?? (rootView as unknown as Frame)?.currentPage?._styleScope;
+		if (styleScope) {
+			styleScope._increaseApplicationCssSelectorVersion();
+		}
+	}
+
+	/**
+	 * @internal – the native surface went away but the window session lives on.
+	 *
+	 * The window stays registered and keeps its listeners, so app code that subscribed
+	 * to it keeps working once a surface re-attaches. The root view keeps pointing back at
+	 * this window for the same reason — it is still this window's content.
+	 */
+	_detach(): void {
+		// Take a final reading while the surface can still answer and the root view is
+		// still up: from here on these are what the window reports.
+		this.orientation();
+		this.systemAppearance();
+		this.layoutDirection();
+
+		if (this._rootView) {
+			if (this._rootView.isLoaded) {
+				this._rootView.callUnloaded();
+			}
+			this._rootView._tearDownUI(true);
+			this._rootView._onRootViewReset();
+		}
+
+		this._setState('detached');
+		this._notifyEvent(NativeWindowEvents.detached);
+	}
+
+	protected _onDestroy(): void {
+		super._onDestroy();
+		if (this._rootView) {
+			if (this._rootView.isLoaded) {
+				this._rootView.callUnloaded();
+			}
+			this._rootView._onRootViewReset();
+			this._rootView._nativeWindow = null;
+			this._rootView = null;
+		}
+	}
+}
diff --git a/packages/core/native-window/native-window-interfaces.ts b/packages/core/native-window/native-window-interfaces.ts
new file mode 100644
index 0000000000..834d157078
--- /dev/null
+++ b/packages/core/native-window/native-window-interfaces.ts
@@ -0,0 +1,204 @@
+import type { CoreTypes } from '../core-types';
+import type { EventData } from '../data/observable';
+import type { View } from '../ui/core/view';
+import type { NavigationEntry } from '../ui/frame/frame-interfaces';
+import type { NativeWindow, WindowBase } from '.';
+
+/**
+ * Events emitted by a NativeWindow instance.
+ */
+export const NativeWindowEvents = {
+	/** Fired when the window becomes the active/focused window. */
+	activate: 'activate',
+	/** Fired when the window loses focus. */
+	deactivate: 'deactivate',
+	/** Fired when the window enters the background. */
+	background: 'background',
+	/** Fired when the window enters the foreground. */
+	foreground: 'foreground',
+	/**
+	 * Fired when the window session ends for good. Fires at most once per window;
+	 * every listener on the window is dropped right after it is dispatched.
+	 */
+	close: 'close',
+	/** Fired when a native surface is bound to the window, both on first connect and on every re-attach. */
+	attached: 'attached',
+	/**
+	 * Fired when the native surface goes away while the window session stays alive
+	 * (iOS scene disconnect, Android activity recreation). The window stays registered
+	 * and keeps its listeners, so the same instance is reused when `attached` fires again.
+	 */
+	detached: 'detached',
+	/** Fired after the window content has been displayed for the first time. */
+	displayed: 'displayed',
+	/** Fired when the root view content is set or changed. */
+	contentLoaded: 'contentLoaded',
+	/** Fired when the orientation of this window changes. */
+	orientationChanged: 'orientationChanged',
+	/** Fired when the system appearance of this window changes between light and dark. */
+	systemAppearanceChanged: 'systemAppearanceChanged',
+	/** Fired when the layout direction of this window changes between ltr and rtl. */
+	layoutDirectionChanged: 'layoutDirectionChanged',
+
+	// iOS scene lifecycle events
+	/** Fired when the scene is about to connect (iOS only). */
+	sceneWillConnect: 'sceneWillConnect',
+	/** Fired when the scene becomes active (iOS only). */
+	sceneDidActivate: 'sceneDidActivate',
+	/** Fired when the scene is about to resign active state (iOS only). */
+	sceneWillResignActive: 'sceneWillResignActive',
+	/** Fired when the scene is about to enter the foreground (iOS only). */
+	sceneWillEnterForeground: 'sceneWillEnterForeground',
+	/** Fired when the scene has entered the background (iOS only). */
+	sceneDidEnterBackground: 'sceneDidEnterBackground',
+	/** Fired when the scene has disconnected (iOS only). */
+	sceneDidDisconnect: 'sceneDidDisconnect',
+	/** Fired when the scene is asked to open one or more URLs (iOS only). */
+	sceneOpenURLContexts: 'sceneOpenURLContexts',
+	/** Fired when the scene is asked to continue a handoff/universal link activity (iOS only). */
+	sceneContinueUserActivity: 'sceneContinueUserActivity',
+	/** Fired when a home screen quick action is directed at the scene (iOS only). */
+	scenePerformActionForShortcutItem: 'scenePerformActionForShortcutItem',
+
+	// Android activity lifecycle events
+	/** Fired when the activity is created (Android only). */
+	activityCreated: 'activityCreated',
+	/** Fired when the activity is destroyed (Android only). */
+	activityDestroyed: 'activityDestroyed',
+	/** Fired when the activity is started (Android only). */
+	activityStarted: 'activityStarted',
+	/** Fired when the activity is paused (Android only). */
+	activityPaused: 'activityPaused',
+	/** Fired when the activity is resumed (Android only). */
+	activityResumed: 'activityResumed',
+	/** Fired when the activity is stopped (Android only). */
+	activityStopped: 'activityStopped',
+	/** Fired when the activity state is being saved (Android only). */
+	saveActivityState: 'saveActivityState',
+	/** Fired when the activity receives a result (Android only). */
+	activityResult: 'activityResult',
+	/** Fired when the back button is pressed (Android only). */
+	activityBackPressed: 'activityBackPressed',
+	/** Fired when the activity receives a new intent (Android only). */
+	activityNewIntent: 'activityNewIntent',
+	/** Fired when permission results are received (Android only). */
+	activityRequestPermissions: 'activityRequestPermissions',
+} as const;
+
+export type NativeWindowEventName = (typeof NativeWindowEvents)[keyof typeof NativeWindowEvents];
+
+/**
+ * Application-level events related to window management.
+ */
+export const WindowEvents = {
+	/** Fired on Application when a new NativeWindow is created. */
+	windowOpen: 'windowOpen',
+	/** Fired on Application when a NativeWindow is closed/destroyed. */
+	windowClose: 'windowClose',
+	/** Fired on Application when another window takes over the primary role. */
+	primaryWindowChanged: 'primaryWindowChanged',
+} as const;
+
+/**
+ * Base event data for window surface events.
+ */
+export interface WindowBaseEventData extends EventData {
+	/** The window that emitted the event. */
+	window: WindowBase;
+}
+
+/**
+ * Base event data for NativeWindow events.
+ */
+export interface NativeWindowEventData extends WindowBaseEventData {
+	/** The NativeWindow that emitted the event. */
+	window: NativeWindow;
+}
+
+/**
+ * Event data for the `orientationChanged` event of a NativeWindow.
+ */
+export interface WindowOrientationChangedEventData extends NativeWindowEventData {
+	/** The orientation the window is now in. */
+	newValue: 'portrait' | 'landscape' | 'unknown';
+}
+
+/**
+ * Event data for the `systemAppearanceChanged` event of a NativeWindow.
+ */
+export interface WindowSystemAppearanceChangedEventData extends NativeWindowEventData {
+	/** The system appearance the window is now showing. */
+	newValue: 'light' | 'dark';
+}
+
+/**
+ * Event data for the `layoutDirectionChanged` event of a NativeWindow.
+ */
+export interface WindowLayoutDirectionChangedEventData extends NativeWindowEventData {
+	/** The layout direction the window is now using. */
+	newValue: CoreTypes.LayoutDirectionType;
+}
+
+/**
+ * Event data fired on Application when a window opens.
+ */
+export interface WindowOpenEventData extends EventData {
+	/** The NativeWindow that was opened. */
+	window: NativeWindow;
+}
+
+/**
+ * Event data fired on Application when a window closes.
+ */
+export interface WindowCloseEventData extends EventData {
+	/** The NativeWindow that was closed. */
+	window: NativeWindow;
+}
+
+/**
+ * Event data fired on Application when the primary window changes.
+ */
+export interface PrimaryWindowChangedEventData extends EventData {
+	/** The NativeWindow that is now primary. */
+	window: NativeWindow;
+}
+
+/**
+ * Options for opening a new window.
+ */
+export interface WindowOpenOptions {
+	/**
+	 * Data to pass to the new window.
+	 * On iOS: serialized into NSUserActivity.userInfo.
+	 * On Android: added as intent extras.
+	 */
+	data?: Record<string, any>;
+}
+
+/**
+ * Supplies the UI for a window that needs content. Called once per window that needs it.
+ *
+ * Return a `View`, a `NavigationEntry` or a module name to set the window content,
+ * `null` to take ownership and set the content asynchronously later, or `undefined`
+ * to fall back to the application main entry.
+ */
+export type WindowContentResolver = (request: WindowContentRequest) => View | NavigationEntry | string | null | undefined;
+
+/**
+ * Describes the window asking for content.
+ */
+export interface WindowContentRequest {
+	/** The window that needs content. */
+	window: NativeWindow;
+	/** Whether the window is the application's primary window. */
+	isPrimary: boolean;
+	/** NSUserActivity.userInfo on iOS, intent extras on Android. */
+	data?: Record<string, any>;
+	ios?: {
+		connectionOptions?: UISceneConnectionOptions;
+	};
+	android?: {
+		intent?: android.content.Intent;
+		savedInstanceState?: android.os.Bundle;
+	};
+}
diff --git a/packages/core/native-window/native-window.android.spec.ts b/packages/core/native-window/native-window.android.spec.ts
new file mode 100644
index 0000000000..668fdc7f85
--- /dev/null
+++ b/packages/core/native-window/native-window.android.spec.ts
@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { CoreTypes } from '../core-types';
+
+import { AndroidNativeWindow } from './native-window.android';
+import { NativeWindowEvents } from './native-window-interfaces';
+
+// Real android.content.res.Configuration / android.view.View constants: the bitmask logic
+// under test is only meaningful against the values the platform actually reports.
+const Configuration = {
+	ORIENTATION_UNDEFINED: 0,
+	ORIENTATION_PORTRAIT: 1,
+	ORIENTATION_LANDSCAPE: 2,
+	UI_MODE_NIGHT_MASK: 0x30,
+	UI_MODE_NIGHT_UNDEFINED: 0x00,
+	UI_MODE_NIGHT_NO: 0x10,
+	UI_MODE_NIGHT_YES: 0x20,
+	UI_MODE_TYPE_NORMAL: 0x01,
+	UI_MODE_TYPE_CAR: 0x03,
+};
+
+const AndroidView = {
+	LAYOUT_DIRECTION_LTR: 0,
+	LAYOUT_DIRECTION_RTL: 1,
+};
+
+class FakeComponentCallbacks2 {
+	constructor(implementation: Record<string, any>) {
+		Object.assign(this, implementation);
+	}
+}
+
+/** Mirrors android.os.Bundle's string slots: a miss reads back as null, not undefined. */
+class FakeBundle {
+	private readonly values = new Map<string, string>();
+
+	putString(key: string, value: string): void {
+		this.values.set(key, value);
+	}
+
+	getString(key: string): string | null {
+		return this.values.has(key) ? this.values.get(key) : null;
+	}
+}
+
+function createConfiguration(overrides: Partial<{ orientation: number; uiMode: number; layoutDirection: number }> = {}) {
+	const state = {
+		orientation: Configuration.ORIENTATION_PORTRAIT,
+		uiMode: Configuration.UI_MODE_TYPE_NORMAL | Configuration.UI_MODE_NIGHT_NO,
+		layoutDirection: AndroidView.LAYOUT_DIRECTION_LTR,
+		...overrides,
+	};
+
+	return Object.assign(state, {
+		getLayoutDirection() {
+			return state.layoutDirection;
+		},
+	});
+}
+
+type FakeConfiguration = ReturnType<typeof createConfiguration>;
+
+function createActivity(configuration: FakeConfiguration) {
+	return {
+		registered: [] as any[],
+		unregistered: [] as any[],
+		finishCalls: 0,
+		getResources() {
+			return { getConfiguration: () => configuration };
+		},
+		registerComponentCallbacks(callbacks: any) {
+			this.registered.push(callbacks);
+		},
+		unregisterComponentCallbacks(callbacks: any) {
+			this.unregistered.push(callbacks);
+		},
+		finish() {
+			this.finishCalls++;
+		},
+	};
+}
+
+type FakeActivity = ReturnType<typeof createActivity>;
+
+function createWindow(activity: FakeActivity, id?: string, isPrimary = false): AndroidNativeWindow {
+	return new AndroidNativeWindow(activity as unknown as androidx.appcompat.app.AppCompatActivity, id, isPrimary);
+}
+
+describe('AndroidNativeWindow', () => {
+	let configuration: FakeConfiguration;
+	let activity: FakeActivity;
+	let window: AndroidNativeWindow;
+	let uuidCounter: number;
+
+	beforeEach(() => {
+		uuidCounter = 0;
+		vi.stubGlobal('android', {
+			content: {
+				res: { Configuration },
+				ComponentCallbacks2: FakeComponentCallbacks2,
+			},
+			view: { View: AndroidView },
+		});
+		vi.stubGlobal('java', {
+			util: {
+				UUID: {
+					randomUUID: () => ({ toString: () => `uuid-${++uuidCounter}` }),
+				},
+			},
+		});
+
+		configuration = createConfiguration();
+		activity = createActivity(configuration);
+		window = createWindow(activity, 'window-under-test');
+	});
+
+	afterEach(() => {
+		vi.unstubAllGlobals();
+	});
+
+	describe('Configuration value converters', () => {
+		it('maps the orientation constants, treating anything else as unknown', () => {
+			expect(window._getOrientationValue(createConfiguration({ orientation: Configuration.ORIENTATION_PORTRAIT }) as any)).toBe('portrait');
+			expect(window._getOrientationValue(createConfiguration({ orientation: Configuration.ORIENTATION_LANDSCAPE }) as any)).toBe('landscape');
+			expect(window._getOrientationValue(createConfiguration({ orientation: Configuration.ORIENTATION_UNDEFINED }) as any)).toBe('unknown');
+		});
+
+		it('reads the night bits out of uiMode rather than comparing the whole field', () => {
+			// uiMode packs the ui type into the low bits; a whole-field comparison would miss this.
+			const carAtNight = createConfiguration({ uiMode: Configuration.UI_MODE_TYPE_CAR | Configuration.UI_MODE_NIGHT_YES });
+
+			expect(window._getSystemAppearanceValue(carAtNight as any)).toBe('dark');
+		});
+
+		it('reports light for night-no, night-undefined and unknown night bits', () => {
+			const dayCases = [Configuration.UI_MODE_NIGHT_NO, Configuration.UI_MODE_NIGHT_UNDEFINED, Configuration.UI_MODE_NIGHT_MASK];
+
+			for (const nightBits of dayCases) {
+				const config = createConfiguration({ uiMode: Configuration.UI_MODE_TYPE_NORMAL | nightBits });
+				expect(window._getSystemAppearanceValue(config as any)).toBe('light');
+			}
+		});
+
+		it('maps the layout direction constants, defaulting to ltr', () => {
+			expect(window._getLayoutDirectionValue(createConfiguration({ layoutDirection: AndroidView.LAYOUT_DIRECTION_RTL }) as any)).toBe(CoreTypes.LayoutDirection.rtl);
+			expect(window._getLayoutDirectionValue(createConfiguration({ layoutDirection: AndroidView.LAYOUT_DIRECTION_LTR }) as any)).toBe(CoreTypes.LayoutDirection.ltr);
+			expect(window._getLayoutDirectionValue(createConfiguration({ layoutDirection: 99 }) as any)).toBe(CoreTypes.LayoutDirection.ltr);
+		});
+
+		it('reads the traits off the activity configuration', () => {
+			configuration.orientation = Configuration.ORIENTATION_LANDSCAPE;
+			configuration.uiMode = Configuration.UI_MODE_TYPE_NORMAL | Configuration.UI_MODE_NIGHT_YES;
+			configuration.layoutDirection = AndroidView.LAYOUT_DIRECTION_RTL;
+
+			expect(window.orientation()).toBe('landscape');
+			expect(window.systemAppearance()).toBe('dark');
+			expect(window.layoutDirection()).toBe(CoreTypes.LayoutDirection.rtl);
+		});
+	});
+
+	describe('per-activity configuration callbacks', () => {
+		it('registers on the activity and announces every trait a configuration change carries', () => {
+			window.orientation();
+			window.systemAppearance();
+			window.layoutDirection();
+			const changes: Array<[string, unknown]> = [];
+			for (const eventName of [NativeWindowEvents.orientationChanged, NativeWindowEvents.systemAppearanceChanged, NativeWindowEvents.layoutDirectionChanged]) {
+				window.on(eventName, (data: any) => changes.push([data.eventName, data.newValue]));
+			}
+
+			window._registerConfigurationCallbacks();
+			expect(activity.registered).toHaveLength(1);
+
+			const changed = createConfiguration({
+				orientation: Configuration.ORIENTATION_LANDSCAPE,
+				uiMode: Configuration.UI_MODE_TYPE_NORMAL | Configuration.UI_MODE_NIGHT_YES,
+				layoutDirection: AndroidView.LAYOUT_DIRECTION_RTL,
+			});
+			(activity.registered[0] as any).onConfigurationChanged(changed);
+
+			expect(changes).toEqual([
+				['orientationChanged', 'landscape'],
+				['systemAppearanceChanged', 'dark'],
+				['layoutDirectionChanged', CoreTypes.LayoutDirection.rtl],
+			]);
+		});
+
+		it('registers at most once for the same activity', () => {
+			window._registerConfigurationCallbacks();
+			window._registerConfigurationCallbacks();
+
+			expect(activity.registered).toHaveLength(1);
+		});
+
+		it('unregisters the callbacks it registered when the surface detaches', () => {
+			window._registerConfigurationCallbacks();
+
+			window._detach();
+
+			expect(activity.unregistered).toEqual(activity.registered);
+			expect(window.state).toBe('detached');
+		});
+	});
+
+	describe('window identity across activity recreation', () => {
+		it('mints a prefixed, unique id', () => {
+			const first = AndroidNativeWindow.newWindowId();
+			const second = AndroidNativeWindow.newWindowId();
+
+			expect(first).toMatch(/^window-uuid-/);
+			expect(second).not.toBe(first);
+		});
+
+		it('carries the minted id through the saved state bundle onto the recreated window', () => {
+			const bundle = new FakeBundle();
+			const original = createWindow(activity, AndroidNativeWindow.newWindowId());
+
+			bundle.putString('com.tns.activity.windowId', original.id);
+			const restored = createWindow(createActivity(createConfiguration()), bundle.getString('com.tns.activity.windowId'));
+
+			expect(restored.id).toBe(original.id);
+		});
+
+		it('mints a fresh id when the bundle carries none', () => {
+			const bundle = new FakeBundle();
+			const savedId = bundle.getString('com.tns.activity.windowId');
+
+			const created = createWindow(activity, savedId || AndroidNativeWindow.newWindowId());
+
+			expect(savedId).toBeNull();
+			expect(created.id).toBe('window-uuid-1');
+		});
+
+		it('binds a recreated activity to the same window session', () => {
+			const events: string[] = [];
+			window.on(NativeWindowEvents.detached, (data) => events.push(data.eventName));
+			window._registerConfigurationCallbacks();
+
+			window._detach();
+			const recreated = createActivity(createConfiguration());
+			window._reattach(recreated as unknown as androidx.appcompat.app.AppCompatActivity);
+
+			expect(events).toEqual(['detached']);
+			expect(window.state).toBe('attached');
+			expect(window.id).toBe('window-under-test');
+			expect(window.android?.activity).toBe(recreated as unknown as androidx.appcompat.app.AppCompatActivity);
+		});
+	});
+
+	describe('close', () => {
+		it('finishes the activity of a secondary window', () => {
+			window.close();
+
+			expect(activity.finishCalls).toBe(1);
+		});
+
+		it('refuses to close the primary window', () => {
+			const primary = createWindow(activity, 'primary', true);
+			const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+			primary.close();
+
+			expect(activity.finishCalls).toBe(0);
+			log.mockRestore();
+		});
+	});
+});
diff --git a/packages/core/native-window/native-window.android.ts b/packages/core/native-window/native-window.android.ts
new file mode 100644
index 0000000000..21a59eff38
--- /dev/null
+++ b/packages/core/native-window/native-window.android.ts
@@ -0,0 +1,206 @@
+import type { View } from '../ui/core/view';
+import { CoreTypes } from '../core-types';
+import { SDK_VERSION } from '../utils/constants';
+import type { AndroidActivityCallbacks } from '../ui/frame/frame-common';
+import { CALLBACKS } from '../ui/frame/frame-constants';
+import { NativeWindow } from './native-window-common';
+import type { WindowRole } from './window-base';
+
+/**
+ * Android implementation of NativeWindow.
+ * Wraps an AppCompatActivity.
+ */
+export class AndroidNativeWindow extends NativeWindow {
+	private _activity: WeakRef<androidx.appcompat.app.AppCompatActivity>;
+	private _componentCallbacks: android.content.ComponentCallbacks2;
+	private _componentCallbacksActivity: WeakRef<androidx.appcompat.app.AppCompatActivity>;
+
+	constructor(activity: androidx.appcompat.app.AppCompatActivity, id?: string, isPrimary = false, role: WindowRole = 'application') {
+		super(id, isPrimary, role);
+		this._activity = new WeakRef(activity);
+	}
+
+	/**
+	 * @internal – bind a recreated activity to this window session after a detach.
+	 */
+	_reattach(activity: androidx.appcompat.app.AppCompatActivity): void {
+		this._activity = new WeakRef(activity);
+		this._setState('attached');
+	}
+
+	/**
+	 * @internal – observe the activity's own configuration.
+	 *
+	 * Registered on the activity rather than the application context: in multi-window
+	 * and multi-display setups each activity gets its own configuration, and only these
+	 * callbacks report the one this window actually renders with.
+	 */
+	_registerConfigurationCallbacks(): void {
+		const activity = this.activity;
+		if (!activity || this._componentCallbacks) {
+			return;
+		}
+
+		const callbacks = new android.content.ComponentCallbacks2({
+			onLowMemory(): void {
+				// Handled application-wide.
+			},
+			onTrimMemory(level: number): void {
+				// Handled application-wide.
+			},
+			onConfigurationChanged: (newConfiguration: android.content.res.Configuration): void => {
+				this._setOrientation(this._getOrientationValue(newConfiguration));
+				this._setSystemAppearance(this._getSystemAppearanceValue(newConfiguration));
+				this._setLayoutDirection(this._getLayoutDirectionValue(newConfiguration));
+			},
+		});
+
+		activity.registerComponentCallbacks(callbacks);
+		this._componentCallbacks = callbacks;
+		this._componentCallbacksActivity = new WeakRef(activity);
+	}
+
+	/**
+	 * @internal – drop the configuration callbacks, so a recreated activity does not
+	 * leave the previous one registered.
+	 */
+	_unregisterConfigurationCallbacks(): void {
+		const callbacks = this._componentCallbacks;
+		if (!callbacks) {
+			return;
+		}
+
+		this._componentCallbacks = null;
+		this._componentCallbacksActivity?.deref()?.unregisterComponentCallbacks(callbacks);
+		this._componentCallbacksActivity = null;
+	}
+
+	_detach(): void {
+		this._unregisterConfigurationCallbacks();
+		super._detach();
+	}
+
+	/**
+	 * The wrapped Android Activity (may be GC'd).
+	 */
+	get activity(): androidx.appcompat.app.AppCompatActivity | undefined {
+		return this._activity?.deref();
+	}
+
+	get android() {
+		const activity = this.activity;
+		if (!activity) {
+			return undefined;
+		}
+		return { activity };
+	}
+
+	/**
+	 * Platform-specific: apply the view as root content of this Activity.
+	 */
+	protected _setNativeContent(view: View): void {
+		const activity = this.activity;
+		if (!activity) {
+			throw new Error('NativeWindow: Activity is no longer available.');
+		}
+
+		const callbacks: AndroidActivityCallbacks = (activity as any)[CALLBACKS];
+		if (!callbacks) {
+			throw new Error('NativeWindow: Cannot find activity callbacks.');
+		}
+		callbacks.resetActivityContent(activity, view);
+	}
+
+	/**
+	 * Close this window by finishing the activity.
+	 */
+	close(): void {
+		if (this.isPrimary) {
+			console.log('NativeWindow: Cannot close the primary window.');
+			return;
+		}
+
+		const activity = this.activity;
+		if (activity) {
+			activity.finish();
+		}
+	}
+
+	// --- Platform getters ---
+
+	protected _getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		const activity = this.activity;
+		if (!activity) {
+			return 'unknown';
+		}
+		const configuration = activity.getResources().getConfiguration();
+		return this._getOrientationValue(configuration);
+	}
+
+	protected _getSystemAppearance(): 'light' | 'dark' | null {
+		const activity = this.activity;
+		if (!activity) {
+			return null;
+		}
+		const configuration = activity.getResources().getConfiguration();
+		return this._getSystemAppearanceValue(configuration);
+	}
+
+	protected _getLayoutDirection(): CoreTypes.LayoutDirectionType | null {
+		const activity = this.activity;
+		if (!activity) {
+			return null;
+		}
+		const configuration = activity.getResources().getConfiguration();
+		return this._getLayoutDirectionValue(configuration);
+	}
+
+	// --- Value converters ---
+
+	_getOrientationValue(configuration: android.content.res.Configuration): 'portrait' | 'landscape' | 'unknown' {
+		switch (configuration.orientation) {
+			case android.content.res.Configuration.ORIENTATION_LANDSCAPE:
+				return 'landscape';
+			case android.content.res.Configuration.ORIENTATION_PORTRAIT:
+				return 'portrait';
+			default:
+				return 'unknown';
+		}
+	}
+
+	_getSystemAppearanceValue(configuration: android.content.res.Configuration): 'dark' | 'light' {
+		const mode = configuration.uiMode & android.content.res.Configuration.UI_MODE_NIGHT_MASK;
+		switch (mode) {
+			case android.content.res.Configuration.UI_MODE_NIGHT_YES:
+				return 'dark';
+			case android.content.res.Configuration.UI_MODE_NIGHT_NO:
+			case android.content.res.Configuration.UI_MODE_NIGHT_UNDEFINED:
+			default:
+				return 'light';
+		}
+	}
+
+	_getLayoutDirectionValue(configuration: android.content.res.Configuration): CoreTypes.LayoutDirectionType {
+		switch (configuration.getLayoutDirection()) {
+			case android.view.View.LAYOUT_DIRECTION_RTL:
+				return CoreTypes.LayoutDirection.rtl;
+			case android.view.View.LAYOUT_DIRECTION_LTR:
+			default:
+				return CoreTypes.LayoutDirection.ltr;
+		}
+	}
+
+	protected _onDestroy(): void {
+		this._unregisterConfigurationCallbacks();
+		super._onDestroy();
+		this._activity = null;
+	}
+
+	/**
+	 * Mints a window identity. Android has no stable activity id, so the value is kept
+	 * in the activity saved state to survive recreation (rotation, theme change).
+	 */
+	static newWindowId(): string {
+		return `window-${java.util.UUID.randomUUID().toString()}`;
+	}
+}
diff --git a/packages/core/native-window/native-window.ios.ts b/packages/core/native-window/native-window.ios.ts
new file mode 100644
index 0000000000..2f5989b6bf
--- /dev/null
+++ b/packages/core/native-window/native-window.ios.ts
@@ -0,0 +1,250 @@
+import type { View } from '../ui/core/view';
+import { IOSHelper } from '../ui/core/view/view-helper';
+import { SDK_VERSION } from '../utils/constants';
+import { CoreTypes } from '../core-types';
+import { Trace } from '../trace';
+import { NativeWindow } from './native-window-common';
+import { NativeWindowEvents } from './native-window-interfaces';
+import type { WindowRole } from './window-base';
+
+/**
+ * iOS implementation of NativeWindow.
+ * Wraps a UIWindow and, when the app is scene-based, the UIWindowScene hosting it.
+ */
+export class IOSNativeWindow extends NativeWindow {
+	private _scene: UIWindowScene | undefined;
+	private _window: UIWindow;
+
+	/**
+	 * @internal – set while a scene session destruction request is in flight, so the
+	 * following scene disconnect is read as a close rather than a detach.
+	 */
+	_closeRequested = false;
+
+	/**
+	 * @internal – whether the id comes from a scene session identity. Without one the
+	 * window cannot be matched to a reconnecting session or to a discarded one.
+	 */
+	_hasSessionIdentity: boolean;
+
+	constructor(scene: UIWindowScene | undefined, window: UIWindow, id?: string, isPrimary = false, role: WindowRole = 'application') {
+		super(id, isPrimary, role);
+		this._hasSessionIdentity = !!id;
+		this._scene = scene;
+		this._window = window;
+	}
+
+	/**
+	 * @internal – bind a new scene/window pair to this window session after a detach.
+	 */
+	_reattach(scene: UIWindowScene, uiWindow: UIWindow): void {
+		this._scene = scene;
+		this._window = uiWindow;
+		this._setState('attached');
+	}
+
+	get ios() {
+		return {
+			scene: this._scene,
+			uiWindow: this._window,
+		};
+	}
+
+	/**
+	 * Platform-specific: set the view as root content of this UIWindow.
+	 */
+	protected _setNativeContent(view: View): void {
+		const controller = this._getViewController(view);
+		this._setViewControllerView(view);
+
+		if (this.role === 'embedded') {
+			// The host app owns this UIWindow: its rootViewController and key/visible state
+			// are not ours to change, so the content is handed over as a view controller.
+			NativeScriptEmbedder.sharedInstance().delegate?.presentNativeScriptApp(controller);
+		} else {
+			const haveController = this._window.rootViewController !== null;
+			this._window.rootViewController = controller;
+
+			if (!haveController) {
+				this._window.makeKeyAndVisible();
+			}
+		}
+
+		// Listen for trait collection changes per-window
+		view.on(IOSHelper.traitCollectionColorAppearanceChangedEvent, () => {
+			const userInterfaceStyle = controller.traitCollection.userInterfaceStyle;
+			this._setSystemAppearance(this._getSystemAppearanceValue(userInterfaceStyle));
+		});
+
+		view.on(IOSHelper.traitCollectionLayoutDirectionChangedEvent, () => {
+			const layoutDirection = controller.traitCollection.layoutDirection;
+			this._setLayoutDirection(this._getLayoutDirectionValue(layoutDirection));
+		});
+	}
+
+	/**
+	 * Close this window/scene.
+	 */
+	close(): void {
+		if (this.isPrimary) {
+			console.log('NativeWindow: Cannot close the primary window.');
+			return;
+		}
+
+		const session = this._scene?.session;
+		if (!session) {
+			console.log('NativeWindow: Scene has no session to destroy.');
+			return;
+		}
+
+		const app = UIApplication.sharedApplication;
+		if (app.requestSceneSessionDestructionOptionsErrorHandler) {
+			this._closeRequested = true;
+			app.requestSceneSessionDestructionOptionsErrorHandler(session, null, (error: NSError) => {
+				if (error) {
+					this._closeRequested = false;
+					console.log('NativeWindow: Error destroying scene session:', error.localizedDescription);
+				}
+			});
+		} else {
+			console.log('NativeWindow: Scene destruction API not available on this iOS version.');
+		}
+	}
+
+	// --- Platform getters ---
+
+	protected _getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		if (__VISIONOS__) {
+			return this._getOrientationValue(NativeScriptEmbedder.sharedInstance().windowScene?.interfaceOrientation);
+		}
+		if (this._scene) {
+			return this._getOrientationValue(this._scene.interfaceOrientation);
+		}
+		return this._getOrientationValue(UIApplication.sharedApplication.statusBarOrientation);
+	}
+
+	protected _getSystemAppearance(): 'light' | 'dark' | null {
+		if (!__VISIONOS__ && SDK_VERSION <= 11) {
+			return null;
+		}
+		const rootVC = this._window?.rootViewController;
+		if (!rootVC) {
+			return null;
+		}
+		return this._getSystemAppearanceValue(rootVC.traitCollection.userInterfaceStyle);
+	}
+
+	protected _getLayoutDirection(): CoreTypes.LayoutDirectionType | null {
+		const rootVC = this._window?.rootViewController;
+		if (!rootVC) {
+			return null;
+		}
+		return this._getLayoutDirectionValue(rootVC.traitCollection.layoutDirection);
+	}
+
+	// --- Value converters ---
+
+	private _getOrientationValue(orientation: number): 'portrait' | 'landscape' | 'unknown' {
+		switch (orientation) {
+			case UIInterfaceOrientation.LandscapeRight:
+			case UIInterfaceOrientation.LandscapeLeft:
+				return 'landscape';
+			case UIInterfaceOrientation.PortraitUpsideDown:
+			case UIInterfaceOrientation.Portrait:
+				return 'portrait';
+			case UIInterfaceOrientation.Unknown:
+			default:
+				return 'unknown';
+		}
+	}
+
+	_getSystemAppearanceValue(userInterfaceStyle: number): 'dark' | 'light' {
+		switch (userInterfaceStyle) {
+			case UIUserInterfaceStyle.Dark:
+				return 'dark';
+			case UIUserInterfaceStyle.Light:
+			case UIUserInterfaceStyle.Unspecified:
+			default:
+				return 'light';
+		}
+	}
+
+	_getLayoutDirectionValue(layoutDirection: number): CoreTypes.LayoutDirectionType {
+		switch (layoutDirection) {
+			case UITraitEnvironmentLayoutDirection.RightToLeft:
+				return CoreTypes.LayoutDirection.rtl;
+			case UITraitEnvironmentLayoutDirection.LeftToRight:
+			default:
+				return CoreTypes.LayoutDirection.ltr;
+		}
+	}
+
+	// --- ViewController helpers ---
+
+	private _getViewController(rootView: View): UIViewController {
+		let viewController: UIViewController = rootView.viewController || rootView.ios;
+
+		if (!(viewController instanceof UIViewController)) {
+			viewController = IOSHelper.UILayoutViewController.initWithOwner(new WeakRef(rootView)) as UIViewController;
+			rootView.viewController = viewController;
+		}
+
+		return viewController;
+	}
+
+	private _setViewControllerView(view: View): void {
+		const viewController: UIViewController = view.viewController || view.ios;
+		const nativeView = view.ios || view.nativeViewProtected;
+
+		if (!nativeView || !viewController) {
+			throw new Error('Root should be either UIViewController or UIView');
+		}
+
+		if (viewController instanceof IOSHelper.UILayoutViewController) {
+			viewController.view.addSubview(nativeView);
+		}
+	}
+
+	protected _onReleaseRootView(rootView: View): void {
+		rootView.off(IOSHelper.traitCollectionColorAppearanceChangedEvent);
+		rootView.off(IOSHelper.traitCollectionLayoutDirectionChangedEvent);
+
+		// An embedded window belongs to the host app, so its rootViewController is not ours
+		// to clear — `_setNativeContent` never set it in the first place.
+		if (this.role !== 'embedded' && this._window?.rootViewController) {
+			// The controller's view is moving into another window's hierarchy; leaving it
+			// installed here has UIKit holding a controller it no longer hosts.
+			this._window.rootViewController = null;
+		}
+	}
+
+	protected _onDestroy(): void {
+		// The trait collection listeners live on the root view, so they have to go
+		// before the base drops the reference to it.
+		if (this._rootView) {
+			this._rootView.off(IOSHelper.traitCollectionColorAppearanceChangedEvent);
+			this._rootView.off(IOSHelper.traitCollectionLayoutDirectionChangedEvent);
+		}
+		super._onDestroy();
+		this._scene = null;
+		this._window = null;
+	}
+
+	/**
+	 * The window identity of a scene: the session persistent identifier, which iOS keeps
+	 * across a disconnect and hands back when it reconnects the same session.
+	 *
+	 * Returns `undefined` when the scene carries no session identity — such a window gets
+	 * a minted id and will not be recognised on reconnect.
+	 */
+	static getSceneId(scene: UIWindowScene): string | undefined {
+		const persistentIdentifier = scene?.session?.persistentIdentifier;
+		if (persistentIdentifier) {
+			return `${persistentIdentifier}`;
+		}
+
+		Trace.write('NativeWindow: scene has no session persistentIdentifier; window identity will not survive a reconnect.', Trace.categories.NativeLifecycle, Trace.messageType.error);
+
+		return undefined;
+	}
+}
diff --git a/packages/core/native-window/window-base.spec.ts b/packages/core/native-window/window-base.spec.ts
new file mode 100644
index 0000000000..fa6a1e06b3
--- /dev/null
+++ b/packages/core/native-window/window-base.spec.ts
@@ -0,0 +1,596 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { CoreTypes } from '../core-types';
+import { Builder } from '../ui/builder';
+import type { View } from '../ui/core/view';
+import type { NavigationEntry } from '../ui/frame/frame-interfaces';
+import { NativeWindow } from './native-window-common';
+import { NativeWindowEvents } from './native-window-interfaces';
+import { WindowBase } from './window-base';
+import type { WindowRole } from './window-base';
+import { LayoutBaseCommon } from '../ui/layouts/layout-base-common';
+
+/**
+ * Stand-in for a root view. A real `View` cannot be used here: `_setupAsRootView()`
+ * reaches straight into UIView/android.view.View, which do not exist under vitest.
+ */
+function createFakeView() {
+	return {
+		cssClasses: new Set<string>(),
+		style: {} as Record<string, unknown>,
+		isLoaded: false,
+		_styleScope: null,
+		unloadedCount: 0,
+		resetCount: 0,
+		tearDownCount: 0,
+		setupCount: 0,
+		_setupAsRootView() {
+			this.setupCount++;
+		},
+		_onCssStateChange() {},
+		_onRootViewReset() {
+			this.resetCount++;
+		},
+		_tearDownUI() {
+			this.tearDownCount++;
+		},
+		callUnloaded() {
+			this.unloadedCount++;
+			this.isLoaded = false;
+		},
+		_getRootModalViews() {
+			return [];
+		},
+		_nativeWindow: null as NativeWindow | null,
+	};
+}
+
+/**
+ * A real view, for anything exercising the view side of the window lookup.
+ * `LayoutBaseCommon` is the lightest concrete `ViewCommon` that can be built under vitest.
+ */
+function createRealView(): LayoutBaseCommon {
+	return new LayoutBaseCommon();
+}
+
+function asChild(view: LayoutBaseCommon): View {
+	return view as unknown as View;
+}
+
+type FakeView = ReturnType<typeof createFakeView>;
+
+function asView(view: FakeView): View {
+	return view as unknown as View;
+}
+
+class TestWindow extends NativeWindow {
+	orientationValue: 'portrait' | 'landscape' | 'unknown' = 'portrait';
+	appearanceValue: 'light' | 'dark' | null = 'light';
+	directionValue: CoreTypes.LayoutDirectionType | null = CoreTypes.LayoutDirection.ltr;
+
+	nativeContent: View[] = [];
+	releasedViews: View[] = [];
+	closeCalls = 0;
+	destroyHookRan = false;
+
+	protected _onReleaseRootView(rootView: View): void {
+		this.releasedViews.push(rootView);
+	}
+
+	protected _setNativeContent(view: View): void {
+		this.nativeContent.push(view);
+	}
+
+	protected _getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		return this.orientationValue;
+	}
+
+	protected _getSystemAppearance(): 'light' | 'dark' | null {
+		return this.appearanceValue;
+	}
+
+	protected _getLayoutDirection(): CoreTypes.LayoutDirectionType | null {
+		return this.directionValue;
+	}
+
+	close(): void {
+		this.closeCalls++;
+	}
+
+	protected _onDestroy(): void {
+		this.destroyHookRan = true;
+		// Runs before the listeners are dropped, so this must still reach subscribers.
+		this._notifyEvent(NativeWindowEvents.deactivate);
+		super._onDestroy();
+	}
+}
+
+class BareWindow extends WindowBase {
+	closeCalls = 0;
+
+	constructor(id?: string, isPrimary = false, role: WindowRole = 'application') {
+		super(id, isPrimary, role);
+	}
+
+	close(): void {
+		this.closeCalls++;
+	}
+}
+
+/** Records every event the window emits, in order. */
+function recordEvents(window: WindowBase, events: string[] = []): string[] {
+	for (const eventName of Object.values(NativeWindowEvents)) {
+		window.on(eventName, (data) => events.push(data.eventName));
+	}
+
+	return events;
+}
+
+describe('WindowBase identity, role and state', () => {
+	it('defaults to an application window that is attached and not primary', () => {
+		const window = new TestWindow();
+
+		expect(window.role).toBe('application');
+		expect(window.state).toBe('attached');
+		expect(window.isPrimary).toBe(false);
+		expect(window.id).toMatch(/^window-\d+$/);
+	});
+
+	it('keeps the id, primary flag and role it was constructed with', () => {
+		const window = new TestWindow('scene-42', true, 'carplay');
+
+		expect(window.id).toBe('scene-42');
+		expect(window.isPrimary).toBe(true);
+		expect(window.role).toBe('carplay');
+	});
+
+	it('mints a distinct id for every window left without one', () => {
+		const ids = [new TestWindow().id, new TestWindow().id, new TestWindow().id];
+
+		expect(new Set(ids).size).toBe(ids.length);
+	});
+
+	it('_setIsPrimary promotes and demotes the window', () => {
+		const window = new TestWindow();
+
+		window._setIsPrimary(true);
+		expect(window.isPrimary).toBe(true);
+
+		window._setIsPrimary(false);
+		expect(window.isPrimary).toBe(false);
+	});
+
+	it('exposes no native accessors on a bare window surface', () => {
+		const window = new BareWindow();
+
+		expect(window.ios).toBeUndefined();
+		expect(window.android).toBeUndefined();
+	});
+});
+
+describe('WindowBase lifecycle', () => {
+	it('walks attach -> detach -> re-attach -> close, emitting one event per transition', () => {
+		const window = new TestWindow();
+		const events = recordEvents(window);
+
+		window._notifyEvent(NativeWindowEvents.attached);
+		expect(window.state).toBe('attached');
+
+		window._detach();
+		expect(window.state).toBe('detached');
+
+		window._setState('attached');
+		window._notifyEvent(NativeWindowEvents.attached);
+		expect(window.state).toBe('attached');
+
+		window._notifyEvent(NativeWindowEvents.close);
+		window._destroy();
+		expect(window.state).toBe('closed');
+
+		expect(events).toEqual(['attached', 'detached', 'attached', 'close', 'deactivate']);
+	});
+
+	it('keeps listeners through a detach so a re-attached window still notifies them', () => {
+		const window = new TestWindow();
+		const events: string[] = [];
+		window.on(NativeWindowEvents.attached, (data) => events.push(data.eventName));
+
+		window._detach();
+		window._setState('attached');
+		window._notifyEvent(NativeWindowEvents.attached);
+
+		expect(events).toEqual(['attached']);
+	});
+
+	it('drops listeners only after the teardown hook has run', () => {
+		const window = new TestWindow();
+		const events = recordEvents(window);
+
+		window._destroy();
+
+		expect(window.destroyHookRan).toBe(true);
+		expect(events).toEqual(['deactivate']);
+	});
+
+	it('delivers close to listeners registered before it and nothing afterwards', () => {
+		const window = new TestWindow();
+		const events = recordEvents(window);
+
+		window._notifyEvent(NativeWindowEvents.close);
+		window._destroy();
+		expect(events).toEqual(['close', 'deactivate']);
+		events.length = 0;
+
+		window._notifyEvent(NativeWindowEvents.close);
+		window._notifyEvent(NativeWindowEvents.activate);
+		window._destroy();
+
+		expect(events).toEqual([]);
+	});
+
+	it('unloads and resets the root view when the window session ends', () => {
+		const window = new TestWindow();
+		const view = createFakeView();
+		window.setContent(asView(view));
+		view.isLoaded = true;
+
+		window._destroy();
+
+		expect(view.unloadedCount).toBe(1);
+		expect(view.resetCount).toBe(1);
+		expect(window.rootView).toBeNull();
+	});
+
+	it('tears the root view down on detach but keeps reporting it', () => {
+		const window = new TestWindow();
+		const view = createFakeView();
+		window.setContent(asView(view));
+		view.isLoaded = true;
+
+		window._detach();
+
+		expect(view.unloadedCount).toBe(1);
+		expect(view.tearDownCount).toBe(1);
+		expect(window.rootView).toBe(asView(view));
+	});
+});
+
+describe('NativeWindow.setContent', () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it('accepts a View, applies the root view settings and installs it natively', () => {
+		const window = new TestWindow();
+		const view = createFakeView();
+		const events: string[] = [];
+		window.on(NativeWindowEvents.contentLoaded, (data) => events.push(data.eventName));
+
+		window.setContent(asView(view));
+
+		expect(window.rootView).toBe(asView(view));
+		expect(view.setupCount).toBe(1);
+		expect(window.nativeContent).toEqual([asView(view)]);
+		expect(events).toEqual(['contentLoaded']);
+	});
+
+	it('gives the root view the window-scoped css classes', () => {
+		const window = new TestWindow();
+		window.orientationValue = 'landscape';
+		window.appearanceValue = 'dark';
+		window.directionValue = CoreTypes.LayoutDirection.rtl;
+		const view = createFakeView();
+
+		window.setContent(asView(view));
+
+		expect(view.cssClasses).toContain('ns-root');
+		expect(view.cssClasses).toContain('ns-landscape');
+		expect(view.cssClasses).toContain('ns-dark');
+		expect(view.cssClasses).toContain('ns-rtl');
+	});
+
+	it('builds the view from a NavigationEntry', () => {
+		const window = new TestWindow();
+		const built = createFakeView();
+		const create = vi.spyOn(Builder, 'createViewFromEntry').mockReturnValue(asView(built));
+		const entry: NavigationEntry = { moduleName: 'pages/second' };
+
+		window.setContent(entry);
+
+		expect(create).toHaveBeenCalledWith(entry);
+		expect(window.rootView).toBe(asView(built));
+		expect(window.nativeContent).toEqual([asView(built)]);
+	});
+
+	it('builds the view from a module name string', () => {
+		const window = new TestWindow();
+		const built = createFakeView();
+		const create = vi.spyOn(Builder, 'createViewFromEntry').mockReturnValue(asView(built));
+
+		window.setContent('pages/second');
+
+		expect(create).toHaveBeenCalledWith({ moduleName: 'pages/second' });
+		expect(window.rootView).toBe(asView(built));
+	});
+
+	it('resets the previous root view when the content is replaced', () => {
+		const window = new TestWindow();
+		const first = createFakeView();
+		const second = createFakeView();
+		const events: string[] = [];
+		window.on(NativeWindowEvents.contentLoaded, (data) => events.push(data.eventName));
+
+		window.setContent(asView(first));
+		window.setContent(asView(second));
+
+		expect(first.resetCount).toBe(1);
+		expect(window.rootView).toBe(asView(second));
+		expect(events).toEqual(['contentLoaded', 'contentLoaded']);
+	});
+
+	it('throws rather than silently leaving the window empty on unusable content', () => {
+		const window = new TestWindow();
+
+		expect(() => window.setContent(undefined as unknown as View)).toThrow(/Invalid content/);
+	});
+});
+
+describe('NativeWindow._adoptRootView', () => {
+	it('records the view and announces it without re-running the platform setup', () => {
+		const window = new TestWindow();
+		const view = createFakeView();
+		const events: string[] = [];
+		window.on(NativeWindowEvents.contentLoaded, (data) => events.push(data.eventName));
+
+		window._adoptRootView(asView(view));
+
+		expect(window.rootView).toBe(asView(view));
+		expect(events).toEqual(['contentLoaded']);
+		// The platform pipeline already did both; redoing them would double-initialize the view.
+		expect(window.nativeContent).toEqual([]);
+		expect(view.setupCount).toBe(0);
+	});
+
+	it('is a no-op when handed the view it already holds', () => {
+		const window = new TestWindow();
+		const view = createFakeView();
+		window._adoptRootView(asView(view));
+		const events: string[] = [];
+		window.on(NativeWindowEvents.contentLoaded, (data) => events.push(data.eventName));
+
+		window._adoptRootView(asView(view));
+
+		expect(events).toEqual([]);
+	});
+
+	it('ignores a missing view', () => {
+		const window = new TestWindow();
+		const events: string[] = [];
+		window.on(NativeWindowEvents.contentLoaded, (data) => events.push(data.eventName));
+
+		window._adoptRootView(undefined as unknown as View);
+
+		expect(window.rootView).toBeUndefined();
+		expect(events).toEqual([]);
+	});
+});
+
+describe('NativeWindow trait readings', () => {
+	let window: TestWindow;
+
+	beforeEach(() => {
+		window = new TestWindow();
+	});
+
+	it('reports a change the platform has not announced yet and raises the event for it', () => {
+		expect(window.orientation()).toBe('portrait');
+		const changes: string[] = [];
+		window.on(NativeWindowEvents.orientationChanged, (data) => changes.push(data.newValue));
+
+		window.orientationValue = 'landscape';
+
+		expect(window.orientation()).toBe('landscape');
+		expect(changes).toEqual(['landscape']);
+	});
+
+	it('freezes the last reading once the native surface is gone', () => {
+		window.appearanceValue = 'dark';
+		window.directionValue = CoreTypes.LayoutDirection.rtl;
+		expect(window.systemAppearance()).toBe('dark');
+		expect(window.layoutDirection()).toBe(CoreTypes.LayoutDirection.rtl);
+
+		window._detach();
+		window.appearanceValue = 'light';
+		window.directionValue = CoreTypes.LayoutDirection.ltr;
+		window.orientationValue = 'landscape';
+
+		expect(window.systemAppearance()).toBe('dark');
+		expect(window.layoutDirection()).toBe(CoreTypes.LayoutDirection.rtl);
+		expect(window.orientation()).toBe('portrait');
+	});
+});
+
+describe('NativeWindow root view hand-off', () => {
+	it('takes the view over from the window that held it, leaving that window empty', () => {
+		const windowA = new TestWindow();
+		const windowB = new TestWindow();
+		const view = createFakeView();
+
+		windowA.setContent(asView(view));
+		windowB.setContent(asView(view));
+
+		expect(windowA.rootView).toBeNull();
+		expect(windowB.rootView).toBe(asView(view));
+		expect(view._nativeWindow).toBe(windowB);
+	});
+
+	it('leaves the moved view loaded and intact - it is being moved, not destroyed', () => {
+		const windowA = new TestWindow();
+		const windowB = new TestWindow();
+		const view = createFakeView();
+
+		windowA.setContent(asView(view));
+		view.isLoaded = true;
+
+		windowB.setContent(asView(view));
+
+		expect(view.isLoaded).toBe(true);
+		expect(view.unloadedCount).toBe(0);
+		expect(view.tearDownCount).toBe(0);
+		expect(view.resetCount).toBe(0);
+	});
+
+	it('runs the platform release hook on the departing window only', () => {
+		const windowA = new TestWindow();
+		const windowB = new TestWindow();
+		const view = createFakeView();
+
+		windowA.setContent(asView(view));
+		windowB.setContent(asView(view));
+
+		expect(windowA.releasedViews).toEqual([asView(view)]);
+		expect(windowB.releasedViews).toEqual([]);
+	});
+
+	it('releases on adoption too', () => {
+		const windowA = new TestWindow();
+		const windowB = new TestWindow();
+		const view = createFakeView();
+
+		windowA._adoptRootView(asView(view));
+		windowB._adoptRootView(asView(view));
+
+		expect(windowA.rootView).toBeNull();
+		expect(windowA.releasedViews).toEqual([asView(view)]);
+		expect(windowB.rootView).toBe(asView(view));
+	});
+
+	it('does not release a window from its own root view when the same view is set again', () => {
+		const window = new TestWindow();
+		const view = createFakeView();
+
+		window.setContent(asView(view));
+		window.setContent(asView(view));
+
+		expect(window.releasedViews).toEqual([]);
+		expect(window.rootView).toBe(asView(view));
+		expect(view._nativeWindow).toBe(window);
+	});
+
+	it('drops the back-reference of the root view it replaces', () => {
+		const window = new TestWindow();
+		const first = createFakeView();
+		const second = createFakeView();
+
+		window.setContent(asView(first));
+		window.setContent(asView(second));
+
+		expect(first._nativeWindow).toBeNull();
+		expect(second._nativeWindow).toBe(window);
+	});
+
+	it('_releaseRootView does nothing on a window with no root view', () => {
+		const window = new TestWindow();
+
+		window._releaseRootView();
+
+		expect(window.rootView).toBeUndefined();
+		expect(window.releasedViews).toEqual([]);
+	});
+});
+
+describe('View.getNativeWindow', () => {
+	it('is undefined for a view that belongs to no tree', () => {
+		expect(createRealView().getNativeWindow()).toBeUndefined();
+	});
+
+	it('resolves the window from any depth of the tree', () => {
+		const window = new TestWindow();
+		const root = createRealView();
+		const child = createRealView();
+		const grandChild = createRealView();
+		root.addChild(asChild(child));
+		child.addChild(asChild(grandChild));
+
+		window._adoptRootView(asChild(root));
+
+		expect(root.getNativeWindow()).toBe(window);
+		expect(child.getNativeWindow()).toBe(window);
+		expect(grandChild.getNativeWindow()).toBe(window);
+	});
+
+	it('resolves through a modal and through a modal nested in it', () => {
+		const window = new TestWindow();
+		const root = createRealView();
+		window._adoptRootView(asChild(root));
+
+		const modal = createRealView();
+		modal._modalParent = root;
+		const modalChild = createRealView();
+		modal.addChild(asChild(modalChild));
+
+		const nestedModal = createRealView();
+		nestedModal._modalParent = modal;
+
+		expect(modal.getNativeWindow()).toBe(window);
+		expect(modalChild.getNativeWindow()).toBe(window);
+		expect(nestedModal.getNativeWindow()).toBe(window);
+	});
+
+	it('follows a view re-parented into another window tree', () => {
+		const windowA = new TestWindow();
+		const windowB = new TestWindow();
+		const rootA = createRealView();
+		const rootB = createRealView();
+		const moved = createRealView();
+		rootA.addChild(asChild(moved));
+		windowA._adoptRootView(asChild(rootA));
+		windowB._adoptRootView(asChild(rootB));
+
+		expect(moved.getNativeWindow()).toBe(windowA);
+
+		rootA.removeChild(asChild(moved));
+		rootB.addChild(asChild(moved));
+
+		expect(moved.getNativeWindow()).toBe(windowB);
+	});
+
+	it('still resolves while the window is detached - the session is alive', () => {
+		const window = new TestWindow();
+		const root = createRealView();
+		const child = createRealView();
+		root.addChild(asChild(child));
+		window._adoptRootView(asChild(root));
+
+		window._detach();
+
+		expect(window.state).toBe('detached');
+		expect(child.getNativeWindow()).toBe(window);
+	});
+
+	it('is undefined once the window is closed', () => {
+		const window = new TestWindow();
+		const root = createRealView();
+		const child = createRealView();
+		root.addChild(asChild(child));
+		window._adoptRootView(asChild(root));
+
+		window._destroy();
+
+		expect(child.getNativeWindow()).toBeUndefined();
+		expect(root.getNativeWindow()).toBeUndefined();
+	});
+
+	it('reports the new owner after another window takes the root view over', () => {
+		const windowA = new TestWindow();
+		const windowB = new TestWindow();
+		const root = createRealView();
+		const child = createRealView();
+		root.addChild(asChild(child));
+
+		windowA._adoptRootView(asChild(root));
+		windowB._adoptRootView(asChild(root));
+
+		expect(windowA.rootView).toBeNull();
+		expect(child.getNativeWindow()).toBe(windowB);
+	});
+});
diff --git a/packages/core/native-window/window-base.ts b/packages/core/native-window/window-base.ts
new file mode 100644
index 0000000000..78c7f9a655
--- /dev/null
+++ b/packages/core/native-window/window-base.ts
@@ -0,0 +1,155 @@
+import { Observable } from '../data/observable';
+import type { NativeWindowEventName, WindowBaseEventData, WindowLayoutDirectionChangedEventData, WindowOrientationChangedEventData, WindowSystemAppearanceChangedEventData } from './native-window-interfaces';
+import type { AndroidActivityEventData, AndroidActivityBundleEventData, AndroidActivityResultEventData, AndroidActivityBackPressedEventData, AndroidActivityNewIntentEventData, AndroidActivityRequestPermissionsEventData, SceneEventData, SceneOpenURLContextsEventData, SceneContinueUserActivityEventData, ScenePerformActionForShortcutItemEventData } from '../application/application-interfaces';
+
+/**
+ * The purpose a window surface serves.
+ *
+ * - `application` – a regular app window (iOS application scene, Android activity).
+ * - `embedded` – a window hosted inside another app or container.
+ * - `carplay` – a CarPlay template scene.
+ * - `externalDisplay` – an external/secondary display scene.
+ */
+export type WindowRole = 'application' | 'embedded' | 'carplay' | 'externalDisplay';
+
+/**
+ * The lifecycle state of a window surface.
+ *
+ * - `attached` – connected to a live native surface.
+ * - `detached` – the native surface went away but the window may be reconnected.
+ * - `closed` – permanently torn down.
+ */
+export type WindowState = 'attached' | 'detached' | 'closed';
+
+let _windowIdCounter = 0;
+
+/**
+ * Cross-platform base for any window surface.
+ *
+ * Carries identity, role, state, lifecycle events and the native accessors.
+ * Surfaces that host a NativeScript view tree extend {@link NativeWindow} instead.
+ */
+export abstract class WindowBase extends Observable {
+	private _id: string;
+	private _role: WindowRole;
+	private _state: WindowState = 'attached';
+	private _isPrimary: boolean;
+
+	constructor(id?: string, isPrimary = false, role: WindowRole = 'application') {
+		super();
+		this._id = id || `window-${++_windowIdCounter}`;
+		this._isPrimary = isPrimary;
+		this._role = role;
+	}
+
+	get id(): string {
+		return this._id;
+	}
+
+	get role(): WindowRole {
+		return this._role;
+	}
+
+	get state(): WindowState {
+		return this._state;
+	}
+
+	get isPrimary(): boolean {
+		return this._isPrimary;
+	}
+
+	/**
+	 * @internal - used by the Application to promote a window to primary.
+	 */
+	_setIsPrimary(value: boolean): void {
+		this._isPrimary = value;
+	}
+
+	/**
+	 * @internal
+	 */
+	_setState(value: WindowState): void {
+		this._state = value;
+	}
+
+	get ios(): { readonly scene?: UIWindowScene; readonly uiWindow: UIWindow } | undefined {
+		return undefined;
+	}
+
+	get android(): { readonly activity: androidx.appcompat.app.AppCompatActivity } | undefined {
+		return undefined;
+	}
+
+	/**
+	 * Close this window.
+	 */
+	abstract close(): void;
+
+	// --- Typed event overloads ---
+
+	on(event: 'activate', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'deactivate', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'background', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'foreground', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'close', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'attached', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'detached', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'displayed', callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(event: 'orientationChanged', callback: (data: WindowOrientationChangedEventData) => void, thisArg?: any): void;
+	on(event: 'systemAppearanceChanged', callback: (data: WindowSystemAppearanceChangedEventData) => void, thisArg?: any): void;
+	on(event: 'layoutDirectionChanged', callback: (data: WindowLayoutDirectionChangedEventData) => void, thisArg?: any): void;
+	on(event: 'activityCreated', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityDestroyed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStarted', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityPaused', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityResumed', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'activityStopped', callback: (args: AndroidActivityEventData) => void, thisArg?: any): void;
+	on(event: 'saveActivityState', callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any): void;
+	on(event: 'activityResult', callback: (args: AndroidActivityResultEventData) => void, thisArg?: any): void;
+	on(event: 'activityBackPressed', callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any): void;
+	on(event: 'activityNewIntent', callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any): void;
+	on(event: 'activityRequestPermissions', callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillConnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidActivate', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillResignActive', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneWillEnterForeground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidEnterBackground', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneDidDisconnect', callback: (args: SceneEventData) => void, thisArg?: any): void;
+	on(event: 'sceneOpenURLContexts', callback: (args: SceneOpenURLContextsEventData) => void, thisArg?: any): void;
+	on(event: 'sceneContinueUserActivity', callback: (args: SceneContinueUserActivityEventData) => void, thisArg?: any): void;
+	on(event: 'scenePerformActionForShortcutItem', callback: (args: ScenePerformActionForShortcutItemEventData) => void, thisArg?: any): void;
+	on(eventName: string, callback: (data: WindowBaseEventData) => void, thisArg?: any): void;
+	on(eventName: string, callback: (data: any) => void, thisArg?: any): void {
+		super.on(eventName, callback, thisArg);
+	}
+
+	/**
+	 * @internal – emit a window lifecycle event.
+	 */
+	_notifyEvent(eventName: NativeWindowEventName): void {
+		this.notify(<WindowBaseEventData>{
+			eventName,
+			window: this,
+			object: this,
+		});
+	}
+
+	/**
+	 * @internal – ends the window session for good.
+	 *
+	 * Listeners stay live through the whole teardown and are dropped last, so handlers
+	 * registered on this instance can still observe `close` yet never outlive the window.
+	 */
+	_destroy(): void {
+		this._setState('closed');
+		this._onDestroy();
+		this._clearEventListeners();
+	}
+
+	/**
+	 * Teardown hook for subclasses. Runs while the listeners are still registered.
+	 */
+	protected _onDestroy(): void {
+		// noop
+	}
+}
diff --git a/packages/core/ui/core/view-base/index.ts b/packages/core/ui/core/view-base/index.ts
index adaa79ac4e..83c9c57fc1 100644
--- a/packages/core/ui/core/view-base/index.ts
+++ b/packages/core/ui/core/view-base/index.ts
@@ -439,7 +439,7 @@ export abstract class ViewBase extends Observable {
 	public defaultVisualState: string = 'normal';
 
 	public _domId: number;
-	public _context: any /* android.content.Context */;
+	public _context: any; /* android.content.Context */
 	public _isAddedToNativeVisualTree: boolean;
 	/* "ui/styling/style-scope" */ public _cssState: CssState = new CssState(new WeakRef(this));
 	public _styleScope: StyleScope;
@@ -1615,6 +1615,9 @@ export const classNameProperty = new Property<ViewBase, string>({
 
 		const shouldAddModalRootViewCssClasses = cssClasses.has(CSSUtils.MODAL_ROOT_VIEW_CSS_CLASS);
 		const shouldAddRootViewCssClasses = cssClasses.has(CSSUtils.ROOT_VIEW_CSS_CLASS);
+		// Window-scoped classes are absent from the system class list, so they have to be
+		// carried over by hand or a root view would lose them on every className change.
+		const windowScopedCssClasses = shouldAddModalRootViewCssClasses || shouldAddRootViewCssClasses ? CSSUtils.WINDOW_SCOPED_CSS_CLASSES.filter((c) => cssClasses.has(c)) : [];
 
 		cssClasses.clear();
 
@@ -1628,6 +1631,10 @@ export const classNameProperty = new Property<ViewBase, string>({
 			cssClasses.add(rootViewsCssClasses[i]);
 		}
 
+		for (let i = 0, length = windowScopedCssClasses.length; i < length; i++) {
+			cssClasses.add(windowScopedCssClasses[i]);
+		}
+
 		if (typeof newValue === 'string' && newValue !== '') {
 			const classes = newValue.split(' ');
 			for (let i = 0, length = classes.length; i < length; i++) {
diff --git a/packages/core/ui/core/view/index.android.ts b/packages/core/ui/core/view/index.android.ts
index d5c2d89d22..79cadf94ae 100644
--- a/packages/core/ui/core/view/index.android.ts
+++ b/packages/core/ui/core/view/index.android.ts
@@ -779,7 +779,9 @@ export class View extends ViewCommon {
 	}
 
 	public onBackPressed(): boolean {
-		const topmostFrame = topmost();
+		// Scoped to this view's own window rather than the active one: a back press can reach a
+		// window that is not the one the user last activated.
+		const topmostFrame = topmost(this.getNativeWindow());
 
 		// Delegate back navigation handling to the topmost Frame
 		// when it's a child of the current View.
diff --git a/packages/core/ui/core/view/index.d.ts b/packages/core/ui/core/view/index.d.ts
index d476659eb6..f5cc0e2837 100644
--- a/packages/core/ui/core/view/index.d.ts
+++ b/packages/core/ui/core/view/index.d.ts
@@ -10,6 +10,7 @@ import { InheritedProperty, Property } from '../properties';
 import { ShowModalOptions, ViewBase } from '../view-base';
 import { GlassEffectType, ViewCommon } from './view-common';
 import type { Point, ShownModallyData, Size } from './view-interfaces';
+import type { NativeWindow } from '../../../native-window';
 
 export * from './view-common';
 // helpers (these are okay re-exported here)
@@ -954,6 +955,30 @@ export abstract class View extends ViewCommon {
 	 */
 	_getRootModalViews(): Array<ViewBase>;
 
+	/**
+	 * Internal method:
+	 * Walks up the view tree — through the presenting view of any modal on the way —
+	 * to the root this view ultimately lives under, which is the root view of its window.
+	 */
+	_getRootModalHost(): ViewBase;
+
+	/**
+	 * Internal property:
+	 * The window this view is the root view of. Only ever set on a window's root view;
+	 * use `getNativeWindow()` to resolve the window of any other view.
+	 */
+	_nativeWindow?: NativeWindow;
+
+	/**
+	 * The window currently hosting this view, or `undefined` when the view is not part of
+	 * any window's view tree — including a view whose window has been closed.
+	 *
+	 * Resolved on every call by walking up to the root view — through the presenting view
+	 * of any modal on the way — so a view re-parented into another window's tree reports
+	 * the window it moved to.
+	 */
+	getNativeWindow(): NativeWindow | undefined;
+
 	_eachLayoutView(callback: (View) => void): void;
 
 	/**
diff --git a/packages/core/ui/core/view/view-common.ts b/packages/core/ui/core/view/view-common.ts
index e10a23b776..88018cf936 100644
--- a/packages/core/ui/core/view/view-common.ts
+++ b/packages/core/ui/core/view/view-common.ts
@@ -31,6 +31,7 @@ import { ShadowCSSValues } from '../../styling/css-shadow';
 import { SharedTransition, SharedTransitionInteractiveOptions } from '../../transition/shared-transition';
 import { Flex, FlexFlow } from '../../layouts/flexbox-layout';
 import { CoreTypes, Trace } from '../../styling/styling-shared';
+import type { NativeWindow } from '../../../native-window';
 
 // helpers (these are okay re-exported here)
 export * from './view-helper';
@@ -141,6 +142,14 @@ export abstract class ViewCommon extends ViewBase {
 	protected _closeModalCallback: Function;
 	public _manager: any;
 	public _modalParent?: ViewCommon;
+	/**
+	 * @internal – the window this view is the root view of. Only ever set on a window's
+	 * root view; every other view resolves its window by walking up to that root.
+	 *
+	 * Kept on the view instead of in a window-side registry so the lookup needs no runtime
+	 * dependency on the native-window module.
+	 */
+	public _nativeWindow?: NativeWindow;
 	/**
 	 * The ShowModalOptions this view is currently presented with (set in
 	 * _showNativeModalView, cleared on close). Lets tooling re-present the
@@ -263,6 +272,34 @@ export abstract class ViewCommon extends ViewBase {
 		return _rootModalViews;
 	}
 
+	public _getRootModalHost(): ViewBase {
+		let view: ViewBase = this;
+
+		while (view) {
+			// A modal root has no parent, so the chain continues through the view it was
+			// presented over; nested modals therefore resolve to the same window root.
+			const next = view.parent ?? (<ViewCommon>view)._modalParent;
+			if (!next) {
+				break;
+			}
+			view = next;
+		}
+
+		return view;
+	}
+
+	/**
+	 * The window currently hosting this view, or `undefined` when the view is not part of
+	 * any window's view tree — including a view whose window has been closed.
+	 *
+	 * Resolved on every call by walking up to the root view — through the presenting view
+	 * of any modal on the way — so a view re-parented into another window's tree reports
+	 * the window it moved to.
+	 */
+	public getNativeWindow(): NativeWindow | undefined {
+		return (<ViewCommon>this._getRootModalHost())?._nativeWindow ?? undefined;
+	}
+
 	public _onLivesync(context?: ModuleContext): boolean {
 		if (Trace.isEnabled()) {
 			Trace.write(`${this}._onLivesync(${JSON.stringify(context)})`, Trace.categories.Livesync);
@@ -485,6 +522,17 @@ export abstract class ViewCommon extends ViewBase {
 		const modalRootViewCssClasses = CSSUtils.getSystemCssClasses();
 		modalRootViewCssClasses.forEach((c) => this.cssClasses.add(c));
 
+		// Orientation/appearance/direction are not in the system class list because they
+		// differ per window, so they are inherited from the root this modal opens over.
+		const host = parent._getRootModalHost();
+		if (host) {
+			CSSUtils.WINDOW_SCOPED_CSS_CLASSES.forEach((c) => {
+				if (host.cssClasses.has(c)) {
+					this.cssClasses.add(c);
+				}
+			});
+		}
+
 		parent._modal = this;
 		this.style.fontScaleInternal = getFontScale();
 		this._modalParent = parent;
diff --git a/packages/core/ui/frame/frame-common.spec.ts b/packages/core/ui/frame/frame-common.spec.ts
new file mode 100644
index 0000000000..a2096eb19b
--- /dev/null
+++ b/packages/core/ui/frame/frame-common.spec.ts
@@ -0,0 +1,253 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { FrameBase } from './frame-common';
+import { frameStack, topmostForWindow, _pushInFrameStack } from './frame-stack';
+import { setActiveWindow } from '../../application/helpers-common';
+import type { NativeWindow } from '../../native-window';
+import type { BackstackEntry } from './frame-interfaces';
+import { NavigationType } from './frame-interfaces';
+
+/**
+ * `FrameBase` is used directly instead of the platform `Frame`: the navigation queue and the
+ * frame stack live in the common layer, while `Frame` only adds native fragment/controller work.
+ */
+function createFrame(canGoBack: boolean): FrameBase {
+	const frame = new FrameBase();
+
+	if (canGoBack) {
+		const entry: BackstackEntry = {
+			entry: {},
+			resolvedPage: undefined,
+			navDepth: undefined,
+			fragmentTag: undefined,
+		};
+		backStackOf(frame).push(entry);
+	}
+
+	return frame;
+}
+
+function backStackOf(frame: FrameBase): Array<BackstackEntry> {
+	return frame['_backStack'];
+}
+
+function navigationQueueOf(frame: FrameBase) {
+	return frame['_navigationQueue'];
+}
+
+function isNavigatingBack(frame: FrameBase): boolean {
+	return navigationQueueOf(frame).some((context) => context.navigationType === NavigationType.back);
+}
+
+describe('FrameBase.goBack', () => {
+	afterEach(() => {
+		frameStack.splice(0).forEach((frame) => (frame._isInFrameStack = false));
+	});
+
+	it('navigates the topmost frame when no frame is given', () => {
+		const first = createFrame(true);
+		const second = createFrame(true);
+		_pushInFrameStack(first);
+		_pushInFrameStack(second);
+
+		expect(FrameBase.goBack()).toBe(true);
+
+		expect(isNavigatingBack(second)).toBe(true);
+		expect(isNavigatingBack(first)).toBe(false);
+	});
+
+	it('navigates the given frame even when another frame is topmost', () => {
+		const first = createFrame(true);
+		const second = createFrame(true);
+		_pushInFrameStack(first);
+		_pushInFrameStack(second);
+
+		expect(FrameBase.goBack(first)).toBe(true);
+
+		expect(isNavigatingBack(first)).toBe(true);
+		expect(isNavigatingBack(second)).toBe(false);
+	});
+
+	it('falls back to an ancestor frame of the given frame', () => {
+		const parent = createFrame(true);
+		const child = createFrame(false);
+		child.parent = parent;
+		const topmost = createFrame(true);
+		_pushInFrameStack(child);
+		_pushInFrameStack(topmost);
+
+		expect(FrameBase.goBack(child)).toBe(true);
+
+		expect(isNavigatingBack(parent)).toBe(true);
+		expect(isNavigatingBack(child)).toBe(false);
+		expect(isNavigatingBack(topmost)).toBe(false);
+	});
+
+	it('falls back to an ancestor frame of the topmost frame when no frame is given', () => {
+		const parent = createFrame(true);
+		const child = createFrame(false);
+		child.parent = parent;
+		_pushInFrameStack(child);
+
+		expect(FrameBase.goBack()).toBe(true);
+
+		expect(isNavigatingBack(parent)).toBe(true);
+		expect(isNavigatingBack(child)).toBe(false);
+	});
+
+	it('reports no navigation and leaves the stack alone when the given frame is not topmost', () => {
+		const first = createFrame(false);
+		const second = createFrame(true);
+		_pushInFrameStack(first);
+		_pushInFrameStack(second);
+
+		expect(FrameBase.goBack(first)).toBe(false);
+
+		expect(frameStack).toEqual([first, second]);
+		expect(isNavigatingBack(second)).toBe(false);
+	});
+
+	it('pops the topmost frame when it cannot navigate back', () => {
+		const first = createFrame(true);
+		const second = createFrame(false);
+		_pushInFrameStack(first);
+		_pushInFrameStack(second);
+
+		expect(FrameBase.goBack()).toBe(false);
+
+		expect(frameStack).toEqual([first]);
+		expect(second._isInFrameStack).toBe(false);
+	});
+
+	it('keeps the last frame in the stack when it cannot navigate back', () => {
+		const only = createFrame(false);
+		_pushInFrameStack(only);
+
+		expect(FrameBase.goBack()).toBe(false);
+		expect(FrameBase.goBack(only)).toBe(false);
+
+		expect(frameStack).toEqual([only]);
+	});
+});
+
+/**
+ * Window doubles: `topmost()` only ever compares window references, so a bare object is
+ * enough and keeps the real window lifecycle out of these tests.
+ */
+function createWindow(id: string): NativeWindow {
+	return { id } as unknown as NativeWindow;
+}
+
+function createFrameInWindow(window: NativeWindow | undefined): FrameBase {
+	const frame = new FrameBase();
+	frame._nativeWindow = window;
+	_pushInFrameStack(frame);
+
+	return frame;
+}
+
+describe('topmostForWindow', () => {
+	afterEach(() => {
+		frameStack.splice(0).forEach((frame) => (frame._isInFrameStack = false));
+	});
+
+	it('returns the frame highest in the stack that belongs to the window', () => {
+		const window = createWindow('a');
+		const other = createWindow('b');
+		const first = createFrameInWindow(window);
+		const second = createFrameInWindow(window);
+		createFrameInWindow(other);
+
+		expect(topmostForWindow(window)).toBe(second);
+		expect(first._isInFrameStack).toBe(true);
+	});
+
+	it('returns undefined when the window hosts no frame in the stack', () => {
+		createFrameInWindow(createWindow('a'));
+
+		expect(topmostForWindow(createWindow('b'))).toBeUndefined();
+	});
+});
+
+describe('FrameBase.topmost', () => {
+	afterEach(() => {
+		frameStack.splice(0).forEach((frame) => (frame._isInFrameStack = false));
+		setActiveWindow(undefined);
+	});
+
+	it("returns the given window's frame while another window sits at the top of the stack", () => {
+		const window = createWindow('a');
+		const scoped = createFrameInWindow(window);
+		const other = createFrameInWindow(createWindow('b'));
+
+		expect(FrameBase.topmost(window)).toBe(scoped);
+		expect(FrameBase.topmost()).toBe(other);
+	});
+
+	it('scopes to the active window when no window is given', () => {
+		const active = createWindow('a');
+		const scoped = createFrameInWindow(active);
+		createFrameInWindow(createWindow('b'));
+		setActiveWindow(active);
+
+		expect(FrameBase.topmost()).toBe(scoped);
+	});
+
+	it('falls back to the topmost frame of the stack when the window hosts none', () => {
+		const other = createFrameInWindow(createWindow('b'));
+
+		expect(FrameBase.topmost(createWindow('a'))).toBe(other);
+	});
+
+	it('returns the frame highest in the stack while it belongs to no window', () => {
+		setActiveWindow(createWindow('a'));
+		createFrameInWindow(undefined);
+		const unattached = createFrameInWindow(undefined);
+
+		expect(FrameBase.topmost()).toBe(unattached);
+	});
+
+	it('returns an unattached top frame in a single-window arrangement', () => {
+		const window = createWindow('a');
+		createFrameInWindow(window);
+		const unattached = createFrameInWindow(undefined);
+		setActiveWindow(window);
+
+		expect(FrameBase.topmost()).toBe(unattached);
+	});
+
+	it('returns an unattached top frame even to a caller scoped to a window that hosts one', () => {
+		const window = createWindow('a');
+		const hosted = createFrameInWindow(window);
+		const unattached = createFrameInWindow(undefined);
+
+		expect(FrameBase.topmost(window)).toBe(unattached);
+		expect(topmostForWindow(window)).toBe(hosted);
+	});
+
+	it('matches the unscoped topmost when every frame belongs to the same window', () => {
+		const window = createWindow('a');
+		createFrameInWindow(window);
+		const last = createFrameInWindow(window);
+		setActiveWindow(window);
+
+		expect(FrameBase.topmost()).toBe(last);
+		expect(FrameBase.topmost()).toBe(frameStack[frameStack.length - 1]);
+	});
+
+	it('returns undefined when the stack is empty', () => {
+		setActiveWindow(createWindow('a'));
+
+		expect(FrameBase.topmost()).toBeUndefined();
+	});
+
+	it("leaves the stack alone when the active window's frame cannot go back and is not the last entry", () => {
+		const active = createWindow('a');
+		const scoped = createFrameInWindow(active);
+		const other = createFrameInWindow(createWindow('b'));
+		setActiveWindow(active);
+
+		expect(FrameBase.goBack()).toBe(false);
+
+		expect(frameStack).toEqual([scoped, other]);
+	});
+});
diff --git a/packages/core/ui/frame/frame-common.ts b/packages/core/ui/frame/frame-common.ts
index 97cb6b080f..b6d090a755 100644
--- a/packages/core/ui/frame/frame-common.ts
+++ b/packages/core/ui/frame/frame-common.ts
@@ -13,6 +13,7 @@ import { profile } from '../../profiling';
 import { FRAME_SYMBOL } from './frame-helpers';
 import { SharedTransition } from '../transition/shared-transition';
 import { Frame as FrameDefinition, NavigationData } from '.';
+import type { WindowBase } from '../../native-window';
 
 export { NavigationType } from './frame-interfaces';
 export type { AndroidActivityCallbacks, AndroidFragmentCallbacks, AndroidFrame, BackstackEntry, NavigationContext, NavigationEntry, NavigationTransition, TransitionState, ViewEntry, iOSFrame, NavigationData } from './frame-interfaces';
@@ -64,12 +65,23 @@ export class FrameBase extends CustomLayoutView implements FrameDefinition {
 		return frameStack.find((frame) => frame.id && frame.id === id);
 	}
 
-	static topmost(): FrameBase {
-		return frameStackTopmost();
+	/**
+	 * Gets the topmost frame of a window.
+	 *
+	 * The frame highest in the navigation stack wins outright while it belongs to no window -
+	 * `navigate()` puts a frame in the stack before it is attached to one, and scoping cannot
+	 * place such a frame. Otherwise the frame highest in the stack that belongs to the resolved
+	 * window is returned, falling back to the frame highest in the stack regardless of window
+	 * when that window hosts none.
+	 *
+	 * @param window The window to scope the lookup to. Defaults to `Application.activeWindow`.
+	 */
+	static topmost(window?: WindowBase): FrameBase {
+		return frameStackTopmost(window);
 	}
 
-	static goBack(): boolean {
-		const top = FrameBase.topmost();
+	static goBack(frame?: FrameBase): boolean {
+		const top = frame ?? FrameBase.topmost();
 		if (top && top.canGoBack()) {
 			top.goBack();
 
@@ -93,7 +105,8 @@ export class FrameBase extends CustomLayoutView implements FrameDefinition {
 			}
 		}
 
-		if (frameStack.length > 1) {
+		// Popping is only valid for the frame at the top of the stack - an explicitly passed frame may sit lower.
+		if (frameStack.length > 1 && frameStack[frameStack.length - 1] === top) {
 			top._popFromFrameStack();
 		}
 
diff --git a/packages/core/ui/frame/frame-constants.ts b/packages/core/ui/frame/frame-constants.ts
new file mode 100644
index 0000000000..be38b046d1
--- /dev/null
+++ b/packages/core/ui/frame/frame-constants.ts
@@ -0,0 +1,9 @@
+/**
+ * Keys under which NativeScript stores its callbacks object and frame id on native
+ * activity and fragment instances.
+ *
+ * They live in a module with no imports of its own so code outside `ui/frame` can read
+ * them without pulling in the frame implementation, which closes a require cycle.
+ */
+export const FRAMEID = '_frameId';
+export const CALLBACKS = '_callbacks';
diff --git a/packages/core/ui/frame/frame-helper-for-android.ts b/packages/core/ui/frame/frame-helper-for-android.ts
index 093dac0163..cbaf866540 100644
--- a/packages/core/ui/frame/frame-helper-for-android.ts
+++ b/packages/core/ui/frame/frame-helper-for-android.ts
@@ -6,8 +6,8 @@ import { getNativeApp } from '../../application/helpers-common';
 import { Color } from '../../color';
 import type { Page } from '../page';
 import type { ExpandedEntry } from './fragment.transitions.android';
-export const FRAMEID = '_frameId';
-export const CALLBACKS = '_callbacks';
+import { CALLBACKS, FRAMEID } from './frame-constants';
+export { CALLBACKS, FRAMEID };
 export const framesCache = new Array<WeakRef<AndroidFrame>>();
 
 export interface AndroidFragmentCallbacks {
diff --git a/packages/core/ui/frame/frame-interfaces.ts b/packages/core/ui/frame/frame-interfaces.ts
index 8e958816a6..78781f61bc 100644
--- a/packages/core/ui/frame/frame-interfaces.ts
+++ b/packages/core/ui/frame/frame-interfaces.ts
@@ -113,7 +113,7 @@ export interface AndroidFrame extends Observable {
 
 export interface AndroidActivityCallbacks {
 	getRootView(): View;
-	resetActivityContent(activity: any): void;
+	resetActivityContent(activity: any, view?: View): void;
 
 	onCreate(activity: any, savedInstanceState: any, intent: any, superFunc: Function): void;
 	onSaveInstanceState(activity: any, outState: any, superFunc: Function): void;
diff --git a/packages/core/ui/frame/frame-stack.ts b/packages/core/ui/frame/frame-stack.ts
index 684a31498f..65910df9ea 100644
--- a/packages/core/ui/frame/frame-stack.ts
+++ b/packages/core/ui/frame/frame-stack.ts
@@ -1,15 +1,47 @@
 import { FrameBase } from './frame-common';
+import { getActiveWindow } from '../../application/helpers-common';
+import type { WindowBase } from '../../native-window';
 
 export const frameStack: Array<FrameBase> = [];
 
-export function topmost(): FrameBase {
-	if (frameStack.length > 0) {
-		return frameStack[frameStack.length - 1];
+/**
+ * Gets the frame highest in the stack that belongs to the given window, or `undefined` when
+ * the window hosts no frame that is currently in the stack.
+ */
+export function topmostForWindow(window: WindowBase): FrameBase | undefined {
+	for (let i = frameStack.length - 1; i >= 0; i--) {
+		const frame = frameStack[i];
+		if (frame.getNativeWindow() === window) {
+			return frame;
+		}
 	}
 
 	return undefined;
 }
 
+/**
+ * Gets the topmost frame of a window: the given one, or the active window when none is given.
+ *
+ * Resolution order:
+ * 1. the frame highest in the stack when it belongs to no window - a frame enters the stack on
+ *    `navigate()`, which can happen before it is attached to any window, and scoping cannot
+ *    place such a frame in one window rather than another, so every caller gets it;
+ * 2. the frame highest in the stack that belongs to the window;
+ * 3. the frame highest in the stack regardless of window, when that window hosts none.
+ */
+export function topmost(window?: WindowBase): FrameBase {
+	const globalTop = frameStack[frameStack.length - 1];
+
+	if (!globalTop?.getNativeWindow()) {
+		return globalTop;
+	}
+
+	const target = window ?? getActiveWindow();
+	const scoped = target ? topmostForWindow(target) : undefined;
+
+	return scoped ?? globalTop;
+}
+
 export function _isFrameStackEmpty(): boolean {
 	return frameStack.length === 0;
 }
@@ -33,8 +65,8 @@ export function _popFromFrameStack(frame: FrameBase): void {
 		return;
 	}
 
-	const top = topmost();
-	if (top !== frame) {
+	// Position, not window: popping removes the last entry, so only that entry may be popped.
+	if (frameStack[frameStack.length - 1] !== frame) {
 		throw new Error('Cannot pop a Frame which is not at the top of the navigation stack.');
 	}
 
diff --git a/packages/core/ui/frame/index.android.ts b/packages/core/ui/frame/index.android.ts
index 11a61e64db..904687027b 100644
--- a/packages/core/ui/frame/index.android.ts
+++ b/packages/core/ui/frame/index.android.ts
@@ -8,13 +8,15 @@ import { View } from '../core/view';
 import { _stack, FrameBase, NavigationType } from './frame-common';
 import { _clearEntry, _clearFragment, _getAnimatedEntries, _getTransitionState, _restoreTransitionState, _reverseTransitions, _setAndroidFragmentTransitions, _updateTransitions } from './fragment.transitions';
 import { profile } from '../../profiling';
-import { android as androidUtils } from '../../utils/native-helper';
+import { android as androidUtils, dataDeserialize } from '../../utils/native-helper';
 import type { ExpandedEntry } from './fragment.transitions.android';
 import { ensureFragmentClass, fragmentClass } from './fragment';
 import { getAppMainEntry } from '../../application/helpers-common';
 
 import { AndroidActivityBackPressedEventData, AndroidActivityNewIntentEventData, AndroidActivityRequestPermissionsEventData, AndroidActivityResultEventData } from '../../application/application-interfaces';
 import { Application } from '../../application/application';
+import { NativeWindowEvents } from '../../native-window/native-window-interfaces';
+import { AndroidNativeWindow } from '../../native-window/native-window.android';
 import { isEmbedded, setEmbeddedView } from '../embedding';
 import { CALLBACKS, FRAMEID, framesCache, setFragmentCallbacks } from './frame-helper-for-android';
 import { SDK_VERSION } from '../../utils';
@@ -735,14 +737,24 @@ if (SDK_VERSION >= 33) {
 				return;
 			}
 
+			const nativeWindow = Application.android._getWindowForActivity(activity);
 			const args = <AndroidActivityBackPressedEventData>{
-				eventName: 'activityBackPressed',
+				eventName: NativeWindowEvents.activityBackPressed,
 				object: Application,
 				android: Application.android,
+				window: nativeWindow,
 				activity: activity,
 				cancel: false,
 			};
 
+			// Emit on NativeWindow first
+			if (nativeWindow) {
+				nativeWindow.notify({
+					...args,
+					object: nativeWindow,
+				} as AndroidActivityBackPressedEventData);
+			}
+
 			Application.android.notify(args);
 
 			if (args.cancel) {
@@ -757,7 +769,7 @@ if (SDK_VERSION >= 33) {
 
 				if (view) {
 					const viewArgs = <AndroidActivityBackPressedEventData>{
-						eventName: 'activityBackPressed',
+						eventName: NativeWindowEvents.activityBackPressed,
 						object: view,
 						activity: activity,
 						cancel: false,
@@ -767,7 +779,7 @@ if (SDK_VERSION >= 33) {
 
 					// In the case of Frame, use this callback only if it was overridden, since the original will cause navigation issues
 					if (!viewArgs.cancel && (view.onBackPressed === Frame.prototype.onBackPressed || !view.onBackPressed())) {
-						callSuper = view instanceof Frame ? !Frame.goBack() : true;
+						callSuper = view instanceof Frame ? !Frame.goBack(view) : true;
 					}
 				}
 			}
@@ -852,12 +864,24 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 		}
 
 		if (intent && intent.getAction()) {
-			Application.android.notify(<AndroidActivityNewIntentEventData>{
-				eventName: Application.AndroidApplication.activityNewIntentEvent,
+			const nativeWindow = Application.android._getWindowForActivity(activity);
+			const newIntentArgs = <AndroidActivityNewIntentEventData>{
+				eventName: NativeWindowEvents.activityNewIntent,
 				object: Application.android,
+				window: nativeWindow,
 				activity,
 				intent,
-			});
+			};
+
+			// Emit on NativeWindow first
+			if (nativeWindow) {
+				nativeWindow.notify({
+					...newIntentArgs,
+					object: nativeWindow,
+				} as AndroidActivityNewIntentEventData);
+			}
+
+			Application.android.notify(newIntentArgs);
 		}
 
 		this.setActivityContent(activity, savedInstanceState, true);
@@ -883,12 +907,24 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 		superFunc.call(activity, intent);
 		superSetIntentFunc.call(activity, intent);
 
-		Application.android.notify(<AndroidActivityNewIntentEventData>{
-			eventName: Application.AndroidApplication.activityNewIntentEvent,
+		const nativeWindow = Application.android._getWindowForActivity(activity);
+		const newIntentArgs = <AndroidActivityNewIntentEventData>{
+			eventName: NativeWindowEvents.activityNewIntent,
 			object: Application.android,
+			window: nativeWindow,
 			activity,
 			intent,
-		});
+		};
+
+		// Emit on NativeWindow first
+		if (nativeWindow) {
+			nativeWindow.notify({
+				...newIntentArgs,
+				object: nativeWindow,
+			} as AndroidActivityNewIntentEventData);
+		}
+
+		Application.android.notify(newIntentArgs);
 	}
 
 	@profile
@@ -952,19 +988,6 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 			if (rootView) {
 				rootView._tearDownUI(true);
 			}
-
-			// this may happen when the user changes the system theme
-			// In such case, isFinishing() is false (and isChangingConfigurations is true), and the app will start again (onCreate) with a savedInstanceState
-			// as a result, launchEvent will never be called
-			// possible alternative: always fire launchEvent and exitEvent, but pass extra flags to make it clear what kind of launch/destroy is happening
-			if (activity.isFinishing()) {
-				const exitArgs = {
-					eventName: Application.exitEvent,
-					object: Application.android,
-					android: activity,
-				};
-				Application.notify(exitArgs);
-			}
 		} finally {
 			superFunc.call(activity);
 		}
@@ -976,13 +999,24 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 			Trace.write('NativeScriptActivity.onBackPressed;', Trace.categories.NativeLifecycle);
 		}
 
+		const nativeWindow = Application.android._getWindowForActivity(activity);
 		const args = <AndroidActivityBackPressedEventData>{
-			eventName: 'activityBackPressed',
+			eventName: NativeWindowEvents.activityBackPressed,
 			object: Application,
 			android: Application.android,
+			window: nativeWindow,
 			activity: activity,
 			cancel: false,
 		};
+
+		// Emit on NativeWindow first
+		if (nativeWindow) {
+			nativeWindow.notify({
+				...args,
+				object: nativeWindow,
+			} as AndroidActivityBackPressedEventData);
+		}
+
 		Application.android.notify(args);
 		if (args.cancel) {
 			return;
@@ -992,7 +1026,7 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 		let callSuper = false;
 
 		const viewArgs = <AndroidActivityBackPressedEventData>{
-			eventName: 'activityBackPressed',
+			eventName: NativeWindowEvents.activityBackPressed,
 			object: view,
 			activity: activity,
 			cancel: false,
@@ -1001,7 +1035,7 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 
 		// In the case of Frame, use this callback only if it was overridden, since the original will cause navigation issues
 		if (!viewArgs.cancel && (view.onBackPressed === Frame.prototype.onBackPressed || !view.onBackPressed())) {
-			callSuper = view instanceof Frame ? !Frame.goBack() : true;
+			callSuper = view instanceof Frame ? !Frame.goBack(view) : true;
 		}
 
 		if (callSuper) {
@@ -1015,15 +1049,27 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 			Trace.write('NativeScriptActivity.onRequestPermissionsResult;', Trace.categories.NativeLifecycle);
 		}
 
-		Application.android.notify(<AndroidActivityRequestPermissionsEventData>{
-			eventName: 'activityRequestPermissions',
+		const nativeWindow = Application.android._getWindowForActivity(activity);
+		const permArgs = <AndroidActivityRequestPermissionsEventData>{
+			eventName: NativeWindowEvents.activityRequestPermissions,
 			object: Application,
 			android: Application.android,
+			window: nativeWindow,
 			activity: activity,
 			requestCode: requestCode,
 			permissions: permissions,
 			grantResults: grantResults,
-		});
+		};
+
+		// Emit on NativeWindow first
+		if (nativeWindow) {
+			nativeWindow.notify({
+				...permArgs,
+				object: nativeWindow,
+			} as AndroidActivityRequestPermissionsEventData);
+		}
+
+		Application.android.notify(permArgs);
 	}
 
 	@profile
@@ -1033,18 +1079,30 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 			Trace.write(`NativeScriptActivity.onActivityResult(${requestCode}, ${resultCode}, ${data})`, Trace.categories.NativeLifecycle);
 		}
 
-		Application.android.notify(<AndroidActivityResultEventData>{
-			eventName: 'activityResult',
+		const nativeWindow = Application.android._getWindowForActivity(activity);
+		const resultArgs = <AndroidActivityResultEventData>{
+			eventName: NativeWindowEvents.activityResult,
 			object: Application,
 			android: Application.android,
+			window: nativeWindow,
 			activity: activity,
 			requestCode: requestCode,
 			resultCode: resultCode,
 			intent: data,
-		});
+		};
+
+		// Emit on NativeWindow first
+		if (nativeWindow) {
+			nativeWindow.notify({
+				...resultArgs,
+				object: nativeWindow,
+			} as AndroidActivityResultEventData);
+		}
+
+		Application.android.notify(resultArgs);
 	}
 
-	public resetActivityContent(activity: androidx.appcompat.app.AppCompatActivity): void {
+	public resetActivityContent(activity: androidx.appcompat.app.AppCompatActivity, view?: View): void {
 		if (this._rootView) {
 			const manager = this._rootView._getFragmentManager();
 			manager.executePendingTransactions();
@@ -1055,7 +1113,7 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 		}
 		// Delete previously cached root view in order to recreate it.
 		this._rootView = null;
-		this.setActivityContent(activity, null, false);
+		this.setActivityContent(activity, null, false, view);
 		this._rootView.callLoaded();
 	}
 
@@ -1064,20 +1122,50 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 	// 2. Application revived after Activity is destroyed. this._rootView should have been restored by id in onCreate.
 	// 3. Livesync if rootView has no custom _onLivesync. this._rootView should have been cleared upfront. Launch event should not fired
 	// 4. resetRootView method. this._rootView should have been cleared upfront. Launch event should not fired
-	private setActivityContent(activity: androidx.appcompat.app.AppCompatActivity, savedInstanceState: android.os.Bundle, fireLaunchEvent: boolean): void {
-		let rootView = this._rootView;
+	// 5. NativeWindow.setContent - the caller supplies the view, so nothing is resolved from the main entry.
+	private setActivityContent(activity: androidx.appcompat.app.AppCompatActivity, savedInstanceState: android.os.Bundle, fireLaunchEvent: boolean, view?: View): void {
+		let rootView = view ?? this._rootView;
 
 		if (Trace.isEnabled()) {
 			Trace.write(`Frame.setActivityContent rootView: ${rootView} shouldCreateRootFrame: false fireLaunchEvent: ${fireLaunchEvent}`, Trace.categories.NativeLifecycle);
 		}
 
 		const intent = activity.getIntent();
-		rootView = Application.createRootView(rootView, fireLaunchEvent, {
+		const launchData = {
 			// todo: deprecate in favor of args.intent?
 			android: intent,
 			intent,
 			savedInstanceState,
-		});
+		};
+
+		let nativeWindow = Application.android._getWindowForActivity(activity);
+
+		if (!nativeWindow && isEmbedded()) {
+			// When embedded, the host owns the activity and may never install our lifecycle
+			// callbacks, so this is the only place the window can come into existence.
+			const embeddedWindow = new AndroidNativeWindow(activity, AndroidNativeWindow.newWindowId(), Application.android._getWindows().length === 0, 'embedded');
+			Application.android._registerWindow(embeddedWindow);
+			embeddedWindow._registerConfigurationCallbacks();
+			nativeWindow = embeddedWindow;
+		}
+
+		if (!rootView && fireLaunchEvent && nativeWindow) {
+			// This method installs the root view on the activity itself, so the resolved view is
+			// handed back rather than applied through NativeWindow.setContent(), which would
+			// re-enter here through resetActivityContent().
+			rootView = Application._resolveWindowContent(
+				nativeWindow,
+				{
+					window: nativeWindow,
+					isPrimary: nativeWindow.isPrimary,
+					data: dataDeserialize(intent?.getExtras()) ?? undefined,
+					android: { intent, savedInstanceState },
+				},
+				{ install: false, launchData },
+			);
+		} else {
+			rootView = Application.createRootView(rootView, fireLaunchEvent, launchData);
+		}
 
 		if (!rootView) {
 			// no root view created
@@ -1098,7 +1186,9 @@ export class ActivityCallbacksImplementation implements AndroidActivityCallbacks
 		this._rootView = rootView;
 
 		// sets root classes once rootView is ready...
-		Application.initRootView(rootView);
+		Application.initRootView(rootView, nativeWindow);
+
+		nativeWindow?._adoptRootView(rootView);
 	}
 }
 
diff --git a/packages/core/ui/frame/index.d.ts b/packages/core/ui/frame/index.d.ts
index 41796031f2..f5f6b918ea 100644
--- a/packages/core/ui/frame/index.d.ts
+++ b/packages/core/ui/frame/index.d.ts
@@ -4,6 +4,7 @@ import type { Observable, EventData } from '../../data/observable';
 import type { Property, View } from '../core/view';
 import type { Transition } from '../transition';
 import type { BackstackEntry, NavigationData } from './frame-interfaces';
+import type { WindowBase } from '../../native-window';
 
 export * from './frame-interfaces';
 
@@ -52,15 +53,24 @@ export class Frame extends FrameBase {
 	static getFrameById(id: string): Frame;
 
 	/**
-	 * Gets the topmost frame in the frames stack. An application will typically has one frame instance. Multiple frames handle nested (hierarchical) navigation scenarios.
+	 * Gets the topmost frame of a window. An application will typically has one frame instance. Multiple frames handle nested (hierarchical) navigation scenarios.
+	 *
+	 * The frame highest in the navigation stack wins outright while it belongs to no window -
+	 * `navigate()` puts a frame in the stack before it is attached to one, and scoping cannot
+	 * place such a frame. Otherwise the frame highest in the stack that belongs to the resolved
+	 * window is returned, falling back to the frame highest in the stack regardless of window
+	 * when that window hosts none.
+	 *
+	 * @param window The window to scope the lookup to. Defaults to `Application.activeWindow`.
 	 */
-	static topmost(): Frame;
+	static topmost(window?: WindowBase): Frame;
 
 	/**
 	 * Navigates back using the navigation hierarchy (if any). Updates the Frame stack as needed.
-	 * This method will start from the topmost Frame and will recursively search for an instance that has the canGoBack operation available.
+	 * This method will start from the given Frame and will recursively search its ancestors for an instance that has the canGoBack operation available.
+	 * @param frame The Frame to navigate back. Defaults to the topmost Frame; pass one to scope the back navigation to that Frame's hierarchy.
 	 */
-	static goBack();
+	static goBack(frame?: Frame);
 
 	/**
 	 * @private
@@ -496,7 +506,7 @@ export interface AndroidFrame extends Observable {
 
 export interface AndroidActivityCallbacks {
 	getRootView(): View;
-	resetActivityContent(activity: any): void;
+	resetActivityContent(activity: any, view?: View): void;
 
 	onCreate(activity: any, savedInstanceState: any, intent: any, superFunc: Function): void;
 	onSaveInstanceState(activity: any, outState: any, superFunc: Function): void;
diff --git a/packages/core/utils/native-helper.d.ts b/packages/core/utils/native-helper.d.ts
index 02caa01595..ef3a803a82 100644
--- a/packages/core/utils/native-helper.d.ts
+++ b/packages/core/utils/native-helper.d.ts
@@ -14,11 +14,11 @@ export function dataDeserialize(nativeData?: any): any;
  */
 export function isRealDevice(): boolean;
 
-type NativeWindow = android.view.Window | UIWindow;
+type PlatformWindow = android.view.Window | UIWindow;
 /**
  * Get the UIWindow or android.view.Window of the app
  */
-export function getWindow<T extends NativeWindow>(): T;
+export function getWindow<T extends PlatformWindow>(): T;
 
 /**
  * Utilities related to Android.
diff --git a/packages/core/vitest.setup.ts b/packages/core/vitest.setup.ts
index e116da77a9..4295583282 100644
--- a/packages/core/vitest.setup.ts
+++ b/packages/core/vitest.setup.ts
@@ -157,6 +157,7 @@ global.NativeScriptGlobals = {
 		notify: (args) => {},
 		hasListeners: (args) => {},
 	},
+	setLaunched: () => {},
 };
 
 global.CADisplayLink = function () {};
@@ -185,6 +186,9 @@ global.UIGestureRecognizer = function () {};
 global.UIGestureRecognizerDelegate = function () {};
 global.UIAdaptivePresentationControllerDelegate = function () {};
 global.UIPopoverPresentationControllerDelegate = function () {};
+global.UIAccessibilityIsVoiceOverRunning = () => false;
+global.UIContentSizeCategoryDidChangeNotification = 'UIContentSizeCategoryDidChangeNotification';
+global.UIContentSizeCategoryNewValueKey = 'UIContentSizeCategoryNewValueKey';
 global.UIContentSizeCategoryExtraSmall = 0.5;
 global.UIContentSizeCategorySmall = 0.7;
 global.UIContentSizeCategoryMedium = 0.85;
diff --git a/tools/assets/App_Resources/Android/src/main/AndroidManifest.xml b/tools/assets/App_Resources/Android/src/main/AndroidManifest.xml
index cee69e4994..f37bf218b2 100644
--- a/tools/assets/App_Resources/Android/src/main/AndroidManifest.xml
+++ b/tools/assets/App_Resources/Android/src/main/AndroidManifest.xml
@@ -30,7 +30,7 @@
 			android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize|screenLayout|locale|uiMode"
 			android:theme="@style/LaunchScreenTheme"
 			android:hardwareAccelerated="true"
-			android:launchMode="singleTask"
+			android:launchMode="singleInstancePerTask"
 			android:exported="true">
 
 			<meta-data android:name="SET_THEME_ON_LAUNCH" android:resource="@style/AppTheme" />
diff --git a/tools/assets/App_Resources/iOS/Info.plist b/tools/assets/App_Resources/iOS/Info.plist
index 78642afa97..86d724c392 100644
--- a/tools/assets/App_Resources/iOS/Info.plist
+++ b/tools/assets/App_Resources/iOS/Info.plist
@@ -60,18 +60,6 @@
 			<string>UIWindowSceneSessionRoleApplication</string>
 			<key>UIApplicationSupportsMultipleScenes</key>
 			<true/>
-			<key>UISceneConfigurations</key>
-			<dict>
-				<key>UIWindowSceneSessionRoleApplication</key>
-				<array>
-					<dict>
-						<key>UISceneConfigurationName</key>
-						<string>Default Configuration</string>
-						<key>UISceneDelegateClassName</key>
-						<string>SceneDelegate</string>
-					</dict>
-				</array>
-			</dict>
 		</dict>
 	</dict>
 </plist>