Support state-preserving same-parent reordering in StackLayout #11545

--- a/packages/core/ui/layouts/layout-base-common.ts
+++ b/packages/core/ui/layouts/layout-base-common.ts
@@ -74,6 +74,33 @@
 		}
 	}
 
+	// Internal bookkeeping for layouts with a state-preserving native reorder.
+	// Run native validation before mutating the logical collection.
+	public _moveChild(child: View, atIndex: number, moveNative: (children: ReadonlyArray<View>) => void): boolean {
+		const fromIndex = this._subViews.indexOf(child);
+		if (fromIndex < 0 || child.parent !== this) {
+			throw new Error('Cannot move a view that is not a child of this layout.');
+		}
+		if (!Number.isInteger(atIndex) || atIndex < 0 || atIndex >= this._subViews.length) {
+			throw new RangeError('The destination must be a valid final child index.');
+		}
+		if (fromIndex === atIndex) {
+			return false;
+		}
+		const children = this._subViews.slice();
+		children.splice(fromIndex, 1);
+		children.splice(atIndex, 0, child);
+		moveNative(children);
+		// Inspector notifications only: keep the same DOM node/native view alive.
+		this.domNode?.onChildRemoved(child);
+		this._subViews.splice(fromIndex, 1);
+		this._subViews.splice(atIndex, 0, child);
+		this.domNode?.onChildAdded(child);
+		this._invalidateSiblingCssState(Math.min(fromIndex, atIndex), Math.max(fromIndex, atIndex) + 2);
+		this.requestLayout();
+		return true;
+	}
+
 	// Sibling combinator matches are cached and never re-queried on tree changes.
 	// Appending changes no predecessor, so addChild skips invalidation.
 	private _invalidateSiblingCssState(fromIndex: number, adjacentEndIndex: number): void {
--- a/packages/core/ui/layouts/layout-base.d.ts
+++ b/packages/core/ui/layouts/layout-base.d.ts
@@ -41,6 +41,9 @@
 	 * @param view The view to remove from the children array.
 	 */
 	removeChild(view: View): void;
+
+	/** INTERNAL. Commit child order after the layout validates and reorders its native views. */
+	_moveChild(child: View, atIndex: number, moveNative: (children: ReadonlyArray<View>) => void): boolean;
 
 	/**
 	 * Removes all views in this layout.
--- a/packages/core/ui/layouts/stack-layout/index.d.ts
+++ b/packages/core/ui/layouts/stack-layout/index.d.ts
@@ -1,6 +1,7 @@
 import { LayoutBase } from '../layout-base';
 import { Property } from '../../core/properties';
 import { CoreTypes } from '../../../core-types';
+import { View } from '../../core/view';
 
 /**
  * A Layout that arranges its children horizontally or vertically. The direction can be set by orientation property.
@@ -8,6 +9,12 @@
  * @nsView StackLayout
  */
 export class StackLayout extends LayoutBase {
+	/**
+	 * Move an existing direct child to its final index without unloading it.
+	 * Returns false for a no-op. Throws for a foreign child or invalid index.
+	 * Proxy children are not supported by the native reorder implementation.
+	 */
+	moveChild(child: View, atIndex: number): boolean;
 	/**
 	 * Gets or sets if layout should be horizontal or vertical.
 	 * The default value is vertical.
--- a/packages/core/ui/layouts/stack-layout/stack-layout-common.ts
+++ b/packages/core/ui/layouts/stack-layout/stack-layout-common.ts
@@ -1,12 +1,54 @@
 import { StackLayout as StackLayoutDefinition } from '.';
 import { LayoutBase } from '../layout-base';
-import { CSSType } from '../../core/view';
+import { CSSType, View } from '../../core/view';
 import { Property, makeParser, makeValidator } from '../../core/properties';
 import { CoreTypes } from '../../../core-types';
 
 @CSSType('StackLayout')
 export class StackLayoutBase extends LayoutBase implements StackLayoutDefinition {
 	public orientation: CoreTypes.OrientationType;
+
+	public moveChild(child: View, atIndex: number): boolean {
+		return this._moveChild(child, atIndex, (children) => {
+			const nativeParent = this.nativeViewProtected;
+			if (!nativeParent) {
+				return; // Before UI setup, only the logical order exists.
+			}
+			const subviews = __APPLE__ ? nativeParent.subviews : null;
+			const count = __APPLE__ ? subviews.count : nativeParent.getChildCount();
+			const currentNative: any[] = [];
+			for (let i = 0; i < count; i++) {
+				currentNative.push(__APPLE__ ? subviews.objectAtIndex(i) : nativeParent.getChildAt(i));
+			}
+			const orderedNative = children.map((view) => {
+				const nativeView = view.nativeViewProtected;
+				if (!nativeView || !currentNative.includes(nativeView)) {
+					throw new Error('StackLayout.moveChild requires direct native children; proxy children are not supported.');
+				}
+				return nativeView;
+			});
+			const ownedNative = new Set(orderedNative);
+			if (ownedNative.size !== orderedNative.length) {
+				throw new Error('StackLayout.moveChild requires distinct native children.');
+			}
+			// Keep host-owned subviews (such as glass effects) in their slots.
+			let next = 0;
+			const finalNative = currentNative.map((view) => ownedNative.has(view) ? orderedNative[next++] : view);
+			// Public platform APIs reorder existing children without detaching them.
+			// This is O(n) native calls; no remove/add or focus restoration is used.
+			for (const view of finalNative) {
+				if (__APPLE__) {
+					nativeParent.bringSubviewToFront(view);
+					const shadow = view.outerShadowContainerLayer;
+					if (shadow && shadow.superlayer === nativeParent.layer) {
+						nativeParent.layer.insertSublayerBelow(shadow, view.layer);
+					}
+				} else {
+					nativeParent.bringChildToFront(view);
+				}
+			}
+		});
+	}
 }
 
 StackLayoutBase.prototype.recycleNativeView = 'auto';