NativeScript
diff --git a/‎packages/core/application/application-common.ts‎
Lines changed: 34 additions & 0 deletions b/‎packages/core/application/application-common.ts‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎packages/core/application/application-registry.spec.ts‎
Lines changed: 90 additions & 5 deletions b/‎packages/core/application/application-registry.spec.ts‎
Lines changed: 90 additions & 5 deletions
diff --git a/‎packages/core/application/application.android.ts‎
Lines changed: 2 additions & 0 deletions b/‎packages/core/application/application.android.ts‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎packages/core/application/application.ios.ts‎
Lines changed: 11 additions & 8 deletions b/‎packages/core/application/application.ios.ts‎
Lines changed: 11 additions & 8 deletions
diff --git a/‎packages/core/native-window/native-window-common.ts‎
Lines changed: 2 additions & 0 deletions b/‎packages/core/native-window/native-window-common.ts‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎packages/core/native-window/native-window.ios.spec.ts‎
Lines changed: 39 additions & 0 deletions b/‎packages/core/native-window/native-window.ios.spec.ts‎
Lines changed: 39 additions & 0 deletions
diff --git a/‎packages/core/native-window/native-window.ios.ts‎
Lines changed: 6 additions & 1 deletion b/‎packages/core/native-window/native-window.ios.ts‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎packages/core/native-window/window-base.spec.ts‎
Lines changed: 11 additions & 0 deletions b/‎packages/core/native-window/window-base.spec.ts‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎packages/core/native-window/window-base.ts‎
Lines changed: 15 additions & 0 deletions b/‎packages/core/native-window/window-base.ts‎
Lines changed: 15 additions & 0 deletions
@@ -540,10 +540,44 @@ export class ApplicationCommon {
 		});
 	}
 
+	/**
+	 * @internal - retire the windows behind discarded window-session ids.
+	 *
+	 * A session id can only stand in for a window whose native surface is already gone.
+	 * iOS reports sessions discarded while the app was not running on the next launch,
+	 * and such an id can name the session driving the app now, so an id match alone is
+	 * no evidence that the window is finished with. Retiring an attached window tears
+	 * down the UI in use - its root view unloads and nothing ever reloads it - so only
+	 * detached windows are retired. Ids matching no window are ignored: they routinely
+	 * belong to windows this JS context has never seen.
+	 */
+	_retireDiscardedWindows(ids: string[]): void {
+		for (const id of ids) {
+			const nativeWindow = id ? this.getWindowById(id) : undefined;
+
+			if (!nativeWindow) {
+				continue;
+			}
+
+			if (nativeWindow.state === 'attached') {
+				Trace.write(`Ignoring a discarded session for window '${id}': its surface is still attached.`, Trace.categories.NativeLifecycle, Trace.messageType.warn);
+
+				continue;
+			}
+
+			nativeWindow._notifyEvent(NativeWindowEvents.close);
+			this._unregisterWindow(nativeWindow);
+		}
+	}
+
 	/**
 	 * @internal - Unregister a NativeWindow when its native surface is gone for good.
 	 */
 	_unregisterWindow(nativeWindow: NativeWindow): void {
+		if (!nativeWindow._surfaceGone) {
+			Trace.write(`Unregistering window '${nativeWindow.id}' while its native surface is still live. A window may only be retired once the platform has reported the surface gone.`, Trace.categories.NativeLifecycle, Trace.messageType.error);
+		}
+
 		const idx = this._windows.indexOf(nativeWindow);
 		if (idx >= 0) {
 			this._windows.splice(idx, 1);
 
@@ -112,6 +112,15 @@ describe('ApplicationCommon window registry', () => {
 		setActiveWindow(undefined);
 	});
 
+	/**
+	 * Retires a window the way a platform does: the disconnect callback records that the
+	 * surface is gone, and only then is the window unregistered.
+	 */
+	function retire(window: WindowBase): void {
+		window._surfaceGone = true;
+		app._unregisterWindow(asWindow(window));
+	}
+
 	function record(...eventNames: string[]): Array<{ eventName: string; window: WindowBase }> {
 		const recorded: Array<{ eventName: string; window: WindowBase }> = [];
 		for (const eventName of eventNames) {
@@ -224,7 +233,7 @@ describe('ApplicationCommon window registry', () => {
 			app._registerWindow(window);
 			const recorded = record('windowClose');
 
-			app._unregisterWindow(window);
+			retire(window);
 
 			expect(recorded.map((entry) => entry.window)).toEqual([window]);
 			expect(app.getWindows()).toEqual([]);
@@ -244,7 +253,7 @@ describe('ApplicationCommon window registry', () => {
 			detached._detach();
 
 			const recorded = record('windowClose', 'primaryWindowChanged');
-			app._unregisterWindow(primary);
+			retire(primary);
 
 			expect(events).toEqual(['windowClose', 'primaryWindowChanged']);
 			expect(recorded[1].window).toBe(successor);
@@ -261,7 +270,7 @@ describe('ApplicationCommon window registry', () => {
 			detached._detach();
 
 			record('windowClose', 'primaryWindowChanged');
-			app._unregisterWindow(primary);
+			retire(primary);
 
 			expect(events).toEqual(['windowClose']);
 			expect(primary.isPrimary).toBe(false);
@@ -275,7 +284,7 @@ describe('ApplicationCommon window registry', () => {
 			app._registerWindow(secondary);
 
 			record('windowClose', 'primaryWindowChanged');
-			app._unregisterWindow(secondary);
+			retire(secondary);
 
 			expect(events).toEqual(['windowClose']);
 			expect(app.primaryWindow).toBe(primary);
@@ -308,7 +317,7 @@ describe('ApplicationCommon window registry', () => {
 		it('falls back to the primary window once the active one closes', () => {
 			secondary._notifyEvent(NativeWindowEvents.activate);
 
-			app._unregisterWindow(secondary);
+			retire(secondary);
 
 			expect(app.activeWindow).toBe(primary);
 		});
@@ -320,4 +329,80 @@ describe('ApplicationCommon window registry', () => {
 			expect(app.activeWindow).toBe(primary);
 		});
 	});
+
+	describe('discarded window sessions', () => {
+		let attached: TestWindow;
+		let detached: TestWindow;
+
+		beforeEach(() => {
+			attached = new TestWindow('scene-live', true).withContent();
+			detached = new TestWindow('scene-gone').withContent();
+
+			app._registerWindow(attached);
+			app._registerWindow(detached);
+
+			detached._detach();
+		});
+
+		it('retires a window whose surface is already gone', () => {
+			record('windowClose');
+
+			// The window drops its listeners in `_destroy`, so a listener only sees `close`
+			// if it is raised before the window is unregistered.
+			let closed = false;
+			detached.on(NativeWindowEvents.close, () => {
+				closed = true;
+			});
+
+			app._retireDiscardedWindows(['scene-gone']);
+
+			expect(app.getWindowById('scene-gone')).toBeUndefined();
+			expect(closed).toBe(true);
+			expect(events).toEqual(['windowClose']);
+		});
+
+		/**
+		 * iOS reports sessions discarded in an earlier run on the next launch, and such an
+		 * id can name the session driving the app now. Retiring on the id alone would unload
+		 * the live root view and every frame under it, and nothing reloads a root view whose
+		 * window has left the registry - navigation then queues forever behind `Frame.isLoaded`.
+		 */
+		it('leaves an attached window alone when a discarded id names it', () => {
+			const rootView = attached.rootView as any;
+			let unloaded = false;
+
+			rootView.isLoaded = true;
+			rootView.callUnloaded = () => {
+				unloaded = true;
+			};
+
+			app._retireDiscardedWindows(['scene-live']);
+
+			expect(app.getWindowById('scene-live')).toBe(attached);
+			expect(attached.state).toBe('attached');
+			expect(unloaded).toBe(false);
+			expect(events).toEqual([]);
+		});
+
+		it('ignores ids that match no window', () => {
+			record('windowClose');
+
+			app._retireDiscardedWindows(['scene-never-seen']);
+
+			expect(app.getWindows()).toEqual([attached, detached]);
+			expect(events).toEqual([]);
+		});
+
+		it('retires every detached window named in one discard', () => {
+			const alsoDetached = new TestWindow('scene-gone-too').withContent();
+			app._registerWindow(alsoDetached);
+			alsoDetached._detach();
+
+			app._retireDiscardedWindows(['scene-gone', 'scene-live', 'scene-gone-too']);
+
+			expect(app.getWindowById('scene-gone')).toBeUndefined();
+			expect(app.getWindowById('scene-gone-too')).toBeUndefined();
+			expect(app.getWindowById('scene-live')).toBe(attached);
+		});
+	});
 });
@@ -153,6 +153,8 @@ function initNativeScriptLifecycleCallbacks() {
 				// there and wedging the app as never-suspended.
 				Application.android._setWindowActive(nativeWindow, false, activity);
 
+				nativeWindow._surfaceGone = true;
+
 				// 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();
 
@@ -469,6 +469,8 @@ class SceneDelegate extends UIResponder implements UIWindowSceneDelegate {
 		Application.ios._setWindowInForeground(nativeWindow, false, windowScene);
 
 		if (nativeWindow) {
+			nativeWindow._surfaceGone = true;
+
 			// 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.
@@ -1386,25 +1388,26 @@ export class iOSApplication extends ApplicationCommon implements IiOSApplication
 	// --- NativeWindow registry ---
 
 	/**
-	 * @internal - iOS reports discarded sessions for windows this JS context may never
-	 * have seen (they can arrive on a later launch), so unknown ids are ignored.
+	 * @internal - hands the discarded sessions' ids to the window registry, which decides
+	 * which of them name a window that is actually finished with.
 	 */
 	_onSceneSessionsDiscarded(sessions: NSSet<UISceneSession>): void {
 		const all = sessions?.allObjects;
 		if (!all) {
 			return;
 		}
 
+		const ids: string[] = [];
+
 		for (let i = 0; i < all.count; i++) {
 			const persistentIdentifier = all.objectAtIndex(i)?.persistentIdentifier;
-			const nativeWindow = persistentIdentifier ? this.getWindowById(`${persistentIdentifier}`) : undefined;
-			if (!nativeWindow) {
-				continue;
-			}
 
-			nativeWindow._notifyEvent(NativeWindowEvents.close);
-			this._unregisterWindow(nativeWindow);
+			if (persistentIdentifier) {
+				ids.push(`${persistentIdentifier}`);
+			}
 		}
+
+		this._retireDiscardedWindows(ids);
 	}
 
 	/**
 
@@ -415,6 +415,8 @@ export abstract class NativeWindow extends WindowBase {
 	 * this window for the same reason — it is still this window's content.
 	 */
 	_detach(): void {
+		this._surfaceGone = true;
+
 		// 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();
 
@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { IOSNativeWindow } from './native-window.ios';
+
+function sceneWithSession(persistentIdentifier?: string): any {
+	return persistentIdentifier ? { session: { persistentIdentifier } } : { session: {} };
+}
+
+const uiWindow: any = {};
+
+/**
+ * The flag decides whether a disconnect detaches the window for a later reconnect or ends
+ * it outright, so it has to mean "this id came from the scene's session" and nothing looser.
+ */
+describe('IOSNativeWindow session identity', () => {
+	it('recognises an id taken from the scene session', () => {
+		const window = new IOSNativeWindow(sceneWithSession('ABC-123'), uiWindow, 'ABC-123');
+
+		expect(window._hasSessionIdentity).toBe(true);
+	});
+
+	it('rejects a hand-minted id even when the window has a scene', () => {
+		const window = new IOSNativeWindow(sceneWithSession('ABC-123'), uiWindow, 'embedded-main');
+
+		expect(window._hasSessionIdentity).toBe(false);
+	});
+
+	it('rejects a hand-minted id on a window with no scene', () => {
+		const window = new IOSNativeWindow(undefined, uiWindow, 'main');
+
+		expect(window._hasSessionIdentity).toBe(false);
+	});
+
+	it('rejects a scene whose session carries no persistent identifier', () => {
+		const window = new IOSNativeWindow(sceneWithSession(), uiWindow);
+
+		expect(window._hasSessionIdentity).toBe(false);
+		expect(window.id).toMatch(/^window-\d+$/);
+	});
+});
@@ -29,7 +29,12 @@ export class IOSNativeWindow extends NativeWindow {
 
 	constructor(scene: UIWindowScene | undefined, window: UIWindow, id?: string, isPrimary = false, role: WindowRole = 'application') {
 		super(id, isPrimary, role);
-		this._hasSessionIdentity = !!id;
+
+		// Only an id taken from the scene's session can be matched back to that session.
+		// Hand-minted ids ('main', 'embedded-main') are ids all the same, so their mere
+		// presence says nothing.
+		const sessionId = scene?.session?.persistentIdentifier;
+		this._hasSessionIdentity = !!sessionId && id === `${sessionId}`;
 		this._scene = scene;
 		this._window = window;
 	}
 
@@ -189,6 +189,17 @@ describe('WindowBase lifecycle', () => {
 		expect(events).toEqual(['attached', 'detached', 'attached', 'close', 'deactivate']);
 	});
 
+	it('records the surface as gone on detach and clears it on re-attach', () => {
+		const window = new TestWindow();
+		expect(window._surfaceGone).toBe(false);
+
+		window._detach();
+		expect(window._surfaceGone).toBe(true);
+
+		window._setState('attached');
+		expect(window._surfaceGone).toBe(false);
+	});
+
 	it('keeps listeners through a detach so a re-attached window still notifies them', () => {
 		const window = new TestWindow();
 		const events: string[] = [];
 
@@ -35,6 +35,15 @@ export abstract class WindowBase extends Observable {
 	private _state: WindowState = 'attached';
 	private _isPrimary: boolean;
 
+	/**
+	 * @internal – whether the native surface behind this window is known to be gone.
+	 *
+	 * Only the platform's disconnect callback can establish this, and {@link state} cannot
+	 * stand in for it: a disconnect that ends the session unregisters the window while it is
+	 * still `attached`, so an attached window is not necessarily a live one.
+	 */
+	_surfaceGone = false;
+
 	constructor(id?: string, isPrimary = false, role: WindowRole = 'application') {
 		super();
 		this._id = id || `window-${++_windowIdCounter}`;
@@ -69,6 +78,12 @@ export abstract class WindowBase extends Observable {
 	 * @internal
 	 */
 	_setState(value: WindowState): void {
+		// A window only ever attaches to a surface that exists, so attaching is what clears
+		// the record of the previous one going away.
+		if (value === 'attached') {
+			this._surfaceGone = false;
+		}
+
 		this._state = value;
 	}