diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainer.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainer.kt
index 1a96320231..3d2913f325 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainer.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainer.kt
@@ -361,6 +361,12 @@ internal class TabsContainer(
 
         val isRepeated = nextSelectedFragment === currSelectedFragment
 
+        // If this is user action we test whether it should be prevented before we progress the state.
+        if (!isRepeated && !isInExternalOperationContext && nextSelectedFragment.isPreventNativeSelectionEnabled) {
+            delegate.onNavStateUpdatePrevented(navState, nextSelectedFragment.requireScreenKey)
+            return false
+        }
+
         val stateChanged = updateSelectedFragment(nextSelectedFragment)
 
         val hasTriggeredSpecialEffect =
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainerDelegate.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainerDelegate.kt
index ef8e617a6b..a1974440e1 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainerDelegate.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/container/TabsContainerDelegate.kt
@@ -32,4 +32,17 @@ internal interface TabsContainerDelegate {
         rejectedNavState: TabsNavState,
         reason: TabsNavStateUpdateRejectionReason,
     )
+
+    /**
+     * Called when a native user action (tap) attempts to select a tab that has
+     * [com.swmansion.rnscreens.gamma.tabs.screen.TabsScreen.preventNativeSelection] enabled.
+     * The navigation state remains unchanged.
+     *
+     * @param currentNavState The currently active navigation state that was kept.
+     * @param preventedScreenKey The screen key of the tab whose selection was prevented.
+     */
+    fun onNavStateUpdatePrevented(
+        currentNavState: TabsNavState,
+        preventedScreenKey: String,
+    )
 }
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHost.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHost.kt
index ad3b6a2f22..c7f3dc545f 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHost.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHost.kt
@@ -182,6 +182,13 @@ class TabsHost(
         )
     }
 
+    override fun onNavStateUpdatePrevented(
+        currentNavState: TabsNavState,
+        preventedScreenKey: String,
+    ) {
+        eventEmitter.emitOnTabSelectionPreventedEvent(currentNavState, preventedScreenKey)
+    }
+
     override fun didMountItems(uiManager: UIManager) {
         container.performContainerUpdateIfNeeded()
     }
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostEventEmitter.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostEventEmitter.kt
index 229df14bba..e971268e8e 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostEventEmitter.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostEventEmitter.kt
@@ -5,6 +5,7 @@ import com.swmansion.rnscreens.gamma.common.event.BaseEventEmitter
 import com.swmansion.rnscreens.gamma.tabs.container.TabsNavState
 import com.swmansion.rnscreens.gamma.tabs.container.TabsNavStateUpdateRejectionReason
 import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectedEvent
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionPreventedEvent
 import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionRejectedEvent
 
 internal class TabsHostEventEmitter(
@@ -53,4 +54,22 @@ internal class TabsHostEventEmitter(
             ),
         )
     }
+
+    /**
+     * Emits `onTabSelectionPrevented` event to JS when a tab selection is prevented
+     * because the target screen has `preventNativeSelection` enabled.
+     */
+    fun emitOnTabSelectionPreventedEvent(
+        currentNavState: TabsNavState,
+        preventedScreenKey: String,
+    ) {
+        reactEventDispatcher.dispatchEvent(
+            TabsHostTabSelectionPreventedEvent(
+                surfaceId,
+                viewTag,
+                currentNavState,
+                preventedScreenKey,
+            ),
+        )
+    }
 }
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostViewManager.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostViewManager.kt
index 59a5701ddb..5b81f7ee8c 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostViewManager.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/TabsHostViewManager.kt
@@ -13,6 +13,7 @@ import com.swmansion.rnscreens.gamma.common.colorscheme.ColorScheme
 import com.swmansion.rnscreens.gamma.helpers.makeEventRegistrationInfo
 import com.swmansion.rnscreens.gamma.tabs.container.TabsNavState
 import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectedEvent
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionPreventedEvent
 import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionRejectedEvent
 import com.swmansion.rnscreens.gamma.tabs.screen.TabsScreen
 
@@ -59,6 +60,7 @@ class TabsHostViewManager :
     override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
         mutableMapOf(
             makeEventRegistrationInfo(TabsHostTabSelectedEvent),
+            makeEventRegistrationInfo(TabsHostTabSelectionPreventedEvent),
             makeEventRegistrationInfo(TabsHostTabSelectionRejectedEvent),
         )
 
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/event/TabsHostTabSelectionPreventedEvent.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/event/TabsHostTabSelectionPreventedEvent.kt
new file mode 100644
index 0000000000..b65ac57136
--- /dev/null
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/host/event/TabsHostTabSelectionPreventedEvent.kt
@@ -0,0 +1,47 @@
+package com.swmansion.rnscreens.gamma.tabs.host.event
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.swmansion.rnscreens.gamma.common.event.NamingAwareEventType
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavState
+
+/**
+ * React Native event dispatched to JS when a tab selection is prevented because the target
+ * screen has `preventNativeSelection` enabled.
+ *
+ * This event is never coalesced — every prevention is delivered individually.
+ */
+class TabsHostTabSelectionPreventedEvent(
+    surfaceId: Int,
+    viewId: Int,
+    val currentNavState: TabsNavState,
+    val preventedScreenKey: String,
+) : Event<TabsHostTabSelectionPreventedEvent>(surfaceId, viewId),
+    NamingAwareEventType {
+    override fun getEventName() = EVENT_NAME
+
+    override fun getEventRegistrationName() = EVENT_REGISTRATION_NAME
+
+    override fun canCoalesce(): Boolean = false
+
+    override fun getEventData(): WritableMap? =
+        Arguments.createMap().apply {
+            putString(EK_SELECTED_KEY, currentNavState.selectedKey)
+            putInt(EK_PROVENANCE, currentNavState.provenance)
+            putString(EK_PREVENTED_KEY, preventedScreenKey)
+        }
+
+    companion object : NamingAwareEventType {
+        const val EVENT_NAME = "topTabSelectionPrevented"
+        const val EVENT_REGISTRATION_NAME = "onTabSelectionPrevented"
+
+        private const val EK_SELECTED_KEY = "selectedScreenKey"
+        private const val EK_PROVENANCE = "provenance"
+        private const val EK_PREVENTED_KEY = "preventedScreenKey"
+
+        override fun getEventName() = EVENT_NAME
+
+        override fun getEventRegistrationName() = EVENT_REGISTRATION_NAME
+    }
+}
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreen.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreen.kt
index 646c1fa34d..24d107f6fe 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreen.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreen.kt
@@ -94,6 +94,8 @@ class TabsScreen(
     var shouldUseRepeatedTabSelectionScrollToTopSpecialEffect: Boolean = true
     var shouldUseRepeatedTabSelectionPopToRootSpecialEffect: Boolean = true
 
+    var preventNativeSelection: Boolean = false
+
     private fun <T> updateMenuItemAttributesIfNeeded(
         oldValue: T,
         newValue: T,
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenFragment.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenFragment.kt
index 6d70800492..ee0a07ce85 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenFragment.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenFragment.kt
@@ -11,6 +11,7 @@ class TabsScreenFragment(
     internal val tabsScreen: TabsScreen,
 ) : Fragment() {
     internal val requireScreenKey: String by tabsScreen::requireScreenKey
+    internal val isPreventNativeSelectionEnabled: Boolean by tabsScreen::preventNativeSelection
 
     override fun onCreateView(
         inflater: LayoutInflater,
diff --git a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenViewManager.kt b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenViewManager.kt
index 02fd4788e2..73ea07790a 100644
--- a/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenViewManager.kt
+++ b/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/screen/TabsScreenViewManager.kt
@@ -97,6 +97,13 @@ class TabsScreenViewManager :
         view.shouldUseRepeatedTabSelectionScrollToTopSpecialEffect = scrollToTop
     }
 
+    override fun setPreventNativeSelection(
+        view: TabsScreen,
+        value: Boolean,
+    ) {
+        view.preventNativeSelection = value
+    }
+
     override fun setTabBarItemTestID(
         view: TabsScreen,
         value: String?,
diff --git a/apps/src/tests/single-feature-tests/tabs/index.ts b/apps/src/tests/single-feature-tests/tabs/index.ts
index 75419931cc..aedc34ad7d 100644
--- a/apps/src/tests/single-feature-tests/tabs/index.ts
+++ b/apps/src/tests/single-feature-tests/tabs/index.ts
@@ -10,6 +10,7 @@ import TestTabsLayoutDirection from './test-tabs-layout-direction';
 import TestTabsIMEInsets from './test-tabs-ime-insets';
 import TestTabsSimpleNav from './test-tabs-simple-nav';
 import TestTabsMoreNavigationController from './test-tabs-more-navigation-controller';
+import TestTabsPreventNativeSelection from './test-tabs-prevent-native-selection';
 import TestTabsStaleStateUpdateRejection from './test-tabs-stale-update-rejection';
 
 const scenarios = {
@@ -23,6 +24,7 @@ const scenarios = {
   TestTabsIMEInsets,
   TestTabsSimpleNav,
   TestTabsMoreNavigationController,
+  TestTabsPreventNativeSelection,
   TestTabsStaleStateUpdateRejection,
 };
 
diff --git a/apps/src/tests/single-feature-tests/tabs/test-tabs-prevent-native-selection.tsx b/apps/src/tests/single-feature-tests/tabs/test-tabs-prevent-native-selection.tsx
new file mode 100644
index 0000000000..846487779d
--- /dev/null
+++ b/apps/src/tests/single-feature-tests/tabs/test-tabs-prevent-native-selection.tsx
@@ -0,0 +1,124 @@
+import React from 'react';
+import type { Scenario } from '../../shared/helpers';
+import { Button, Text, View } from 'react-native';
+import {
+  type TabRouteConfig,
+  DEFAULT_TAB_ROUTE_OPTIONS,
+  useTabsNavigationContext,
+  TabsContainerWithHostConfigContext,
+} from '../../../shared/gamma/containers/tabs';
+import { CenteredLayoutView } from '../../../shared/CenteredLayoutView';
+import { ToastProvider, useToast } from '../../../shared/';
+import Colors from '../../../shared/styling/Colors';
+
+const SCENARIO: Scenario = {
+  name: 'Prevent native selection',
+  key: 'test-tabs-prevent-native-selection',
+  details: 'Test preventNativeSelection prop on TabsScreen',
+  platforms: ['android', 'ios'],
+  AppComponent: App,
+};
+
+export default SCENARIO;
+
+function ContentView() {
+  const nav = useTabsNavigationContext();
+
+  const preventNativeSelection =
+    nav.routeOptions.preventNativeSelection ?? false;
+
+  return (
+    <CenteredLayoutView>
+      <Text style={{ fontWeight: 'bold', textAlign: 'center' }}>
+        {nav.routeKey}
+      </Text>
+      <Text style={{ textAlign: 'center' }}>
+        preventNativeSelection: {JSON.stringify(preventNativeSelection)}
+      </Text>
+      <Button
+        title="Toggle preventNativeSelection"
+        onPress={() =>
+          nav.setRouteOptions(nav.routeKey, {
+            preventNativeSelection: !preventNativeSelection,
+          })
+        }
+      />
+      <TabsNavigationButtons />
+    </CenteredLayoutView>
+  );
+}
+
+function TabsNavigationButtons() {
+  const nav = useTabsNavigationContext();
+
+  return (
+    <View>
+      <Button title="Select First" onPress={() => nav.selectTab('First')} />
+      <Button title="Select Second" onPress={() => nav.selectTab('Second')} />
+      <Button title="Select Third" onPress={() => nav.selectTab('Third')} />
+      <Button title="Select Fourth" onPress={() => nav.selectTab('Fourth')} />
+      <Button title="Select Fifth" onPress={() => nav.selectTab('Fifth')} />
+      <Button title="Select Sixth" onPress={() => nav.selectTab('Sixth')} />
+    </View>
+  );
+}
+
+const ROUTE_CONFIGS: TabRouteConfig[] = [
+  {
+    name: 'First',
+    Component: ContentView,
+    options: { ...DEFAULT_TAB_ROUTE_OPTIONS, title: 'First' },
+  },
+  {
+    name: 'Second',
+    Component: ContentView,
+    options: { ...DEFAULT_TAB_ROUTE_OPTIONS, title: 'Second' },
+  },
+  {
+    name: 'Third',
+    Component: ContentView,
+    options: { ...DEFAULT_TAB_ROUTE_OPTIONS, title: 'Third' },
+  },
+  {
+    name: 'Fourth',
+    Component: ContentView,
+    options: { ...DEFAULT_TAB_ROUTE_OPTIONS, title: 'Fourth' },
+  },
+  {
+    name: 'Fifth',
+    Component: ContentView,
+    options: { ...DEFAULT_TAB_ROUTE_OPTIONS, title: 'Fifth' },
+  },
+  {
+    name: 'Sixth',
+    Component: ContentView,
+    options: { ...DEFAULT_TAB_ROUTE_OPTIONS, title: 'Sixth' },
+  },
+];
+
+export function App() {
+  return (
+    <ToastProvider>
+      <AppContents />
+    </ToastProvider>
+  );
+}
+
+function AppContents() {
+  const toast = useToast();
+
+  return (
+    <TabsContainerWithHostConfigContext
+      routeConfigs={ROUTE_CONFIGS}
+      onTabSelectionPrevented={event => {
+        const message = `onTabSelectionPrevented: ${event.nativeEvent.preventedScreenKey}`;
+        console.warn(message);
+        toast.push({
+          message: message,
+          backgroundColor: Colors.GreenLight60,
+        });
+      }}
+    />
+  );
+}
+
diff --git a/ios/tabs/host/RNSTabBarController.mm b/ios/tabs/host/RNSTabBarController.mm
index 0eb1c5b050..b582494fa3 100644
--- a/ios/tabs/host/RNSTabBarController.mm
+++ b/ios/tabs/host/RNSTabBarController.mm
@@ -1,6 +1,8 @@
 #import "RNSTabBarController.h"
 #import <React/RCTAssert.h>
 #import <React/RCTLog.h>
+#import <objc/message.h>
+#import <objc/runtime.h>
 #import "NSString+RNSUtility.h"
 #import "RNSLog.h"
 #import "RNSScreenWindowTraits.h"
@@ -12,13 +14,52 @@
  */
 static NSString *const kMoreNavigationControllerScreenKey = @"rnscreens_moreNavigationController";
 
-@interface RNSTabBarController () <UITabBarControllerDelegate>
+// We need UINavigationControllerDelegate to handle navigation within `moreNavigationController`
+@interface RNSTabBarController () <UITabBarControllerDelegate, UINavigationControllerDelegate>
 @end
 
-// We need this to handle navigation within `moreNavigationController`
-@interface RNSTabBarController () <UINavigationControllerDelegate>
+@interface RNSTabBarController ()
+
+/// Consulted by the ISA-swizzled `pushViewController:animated:` on `moreNavigationController`
+/// to decide whether a push should proceed.
+- (BOOL)moreNavigationController:(UINavigationController *)navigationController
+        shouldPushViewController:(UIViewController *)viewController;
+
 @end
 
+#if RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+/**
+ * Replacement implementation for `pushViewController:animated:` injected into
+ * a dynamic subclass of `UIMoreNavigationController` via ISA-swizzle.
+ *
+ * Before allowing the push, this function consults the owning `RNSTabBarController`
+ * (reached via UIKit's `tabBarController` property on the parent chain)
+ * to check whether the push should be prevented (e.g. due to `preventNativeSelection`).
+ */
+static void
+rns_pushViewController(__unsafe_unretained id self, SEL _cmd, UIViewController *viewController, BOOL animated)
+{
+  UITabBarController *rawTabBarController = static_cast<UIViewController *>(self).tabBarController;
+
+  RCTAssert(
+      [rawTabBarController isKindOfClass:RNSTabBarController.class],
+      @"[RNScreens] Expected tabBarController to be of class %@, got: %@",
+      RNSTabBarController.class,
+      rawTabBarController.class);
+  RNSTabBarController *tabBarController = static_cast<RNSTabBarController *>(rawTabBarController);
+
+  if ([tabBarController moreNavigationController:self shouldPushViewController:viewController]) {
+    struct objc_super superInfo = {
+        .receiver = self,
+        .super_class = class_getSuperclass(object_getClass(self)),
+    };
+    const auto msgSendSuperPushViewController =
+        reinterpret_cast<void (*)(struct objc_super *, SEL, UIViewController *, BOOL)>(objc_msgSendSuper);
+    msgSendSuperPushViewController(&superInfo, _cmd, viewController, animated);
+  }
+}
+#endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+
 @implementation RNSTabBarController {
   NSArray<RNSTabsScreenViewController *> *_Nullable _tabScreenControllers;
 
@@ -223,7 +264,8 @@ - (void)userDidSelectViewController:(nonnull UIViewController *)viewController
   [self updateNavigationStateOnModelUpdate];
 
   if ([self isSelectedViewControllerTheMoreNavigationController]) {
-    [self setupMoreNavigationControllerDelegateIfNeeded];
+    [self disableNavigationBarInMoreNavigationController];
+    [self prepareForMoreNavigationControllerHandlingIfNeeded];
   }
 
   auto *updateContext = [[RNSTabsNavigationStateUpdateContext alloc] initWithNavState:_navigationState
@@ -233,6 +275,22 @@ - (void)userDidSelectViewController:(nonnull UIViewController *)viewController
   [self.tabsHostComponentView tabBarController:self didUpdateStateTo:_navigationState withContext:updateContext];
 }
 
+- (void)onDidPreventUserFromSelectingViewControllerWithKey:(nonnull NSString *)screenKey
+{
+  [self.tabsHostComponentView tabBarController:self preventedSelectionOf:screenKey currentState:_navigationState];
+}
+
+- (BOOL)shouldPreventNativeTabSelection:(nonnull UIViewController *)nextViewController
+{
+  if (![nextViewController isKindOfClass:RNSTabsScreenViewController.class]) {
+    // Allow for more view controller selection
+    return NO;
+  }
+
+  auto *screenViewController = static_cast<RNSTabsScreenViewController *>(nextViewController);
+  return screenViewController.isPreventNativeSelectionEnabled;
+}
+
 #pragma mark - UITabBarControllerDelegate
 
 // These methods are not called on programatic selection!
@@ -265,7 +323,36 @@ - (BOOL)tabBarController:(UITabBarController *)tabBarController
     return NO;
   }
 
-  return ![self shouldPreventNativeTabSelection];
+  // This handles the tabsHostComponentView nullability
+  // TODO: This if is likely to be removed, since we want to roll back the support
+  // for "controlled mode", at least initially.
+  if ([self.tabsHostComponentView experimental_controlNavigationStateInJS]) {
+    return NO;
+  }
+
+  BOOL shouldPreventTabSelection = [self shouldPreventNativeTabSelection:viewController];
+
+  if (shouldPreventTabSelection) {
+    // Ideally we'd call this AFTER we prevent, but there is no appropriate callback.
+    // As long as we emit the event asynchronously this is rather fine.
+    [self onDidPreventUserFromSelectingViewControllerWithKey:[self screenKeyForViewController:viewController]];
+    return NO;
+  }
+
+  // If we're gonna allow navigation to `moreNavigationController`, then we need to ensure
+  // that on top of its stack there is no controller with preventNativeSelection enabled.
+  // In such case, we want to pop to root.
+  // We do it here, because in `tabBarController:didSelectViewController:` we won't receive
+  // `moreNavigationController` in case there is already a tab pushed on the stack.
+  if ([self isViewControllerTheMoreNavigationController:viewController]) {
+    auto *poppedViewController = [self popToRootInMoreNavigationControllerRespectSelectionPrevention:YES animated:NO];
+    if (poppedViewController != nil) {
+      // We actually popped something -> let's notify JS realm of this fact.
+      [self onDidPreventUserFromSelectingViewControllerWithKey:[self screenKeyForViewController:poppedViewController]];
+    }
+  }
+
+  return YES;
 }
 
 - (void)tabBarController:(UITabBarController *)tabBarController
@@ -281,10 +368,6 @@ - (void)tabBarController:(UITabBarController *)tabBarController
       @"[RNScreens] Unexpected type of controller: %@",
       viewController.class);
 
-  if (isNextViewControllerMoreNavigationController) {
-    [self disableNavigationBarInMoreNavigationController];
-  }
-
   [self userDidSelectViewController:viewController];
 }
 
@@ -307,12 +390,6 @@ - (void)navigationController:(UINavigationController *)navigationController
 #endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
 }
 
-- (BOOL)shouldPreventNativeTabSelection
-{
-  // This handles the tabsHostComponentView nullability
-  return [self.tabsHostComponentView experimental_controlNavigationStateInJS] ?: NO;
-}
-
 #pragma mark - Signals related
 
 - (void)updateChildViewControllersIfNeeded
@@ -434,13 +511,13 @@ - (void)updateSelectedViewControllerInner
 
     // Animate only if we're currently in context of more view controller.
     BOOL shouldAnimate = [self isMoreNavigationControllerTabBarItemSelected];
-    [self popToRootInMoreNavigationControllerIfNeededAnimated:shouldAnimate];
+    [self popToRootInMoreNavigationControllerRespectSelectionPrevention:NO animated:shouldAnimate];
 
     // Also disable the header - we don't control it, but it impacts the layout
     // in ways Yoga is not aware of. The simplest option here is to disable it.
     [self disableNavigationBarInMoreNavigationController];
 
-    [self setupMoreNavigationControllerDelegateIfNeeded];
+    [self prepareForMoreNavigationControllerHandlingIfNeeded];
   }
 
   RNSLog(@"Change selected view controller to: %@", nextSelectedViewControllerKey);
@@ -540,23 +617,28 @@ - (RNSTabsScreenViewController *)selectedScreenViewController
   return static_cast<RNSTabsScreenViewController *>(self.selectedViewController);
 }
 
-- (nonnull NSString *)screenKeyForSelectedViewController
+- (nonnull NSString *)screenKeyForViewController:(nonnull UIViewController *)viewController
 {
-  if ([self isSelectedViewControllerTheMoreNavigationController]) {
+  if ([self isViewControllerTheMoreNavigationController:viewController]) {
     return kMoreNavigationControllerScreenKey;
   }
 
   RCTAssert(
-      [self.selectedViewController isKindOfClass:RNSTabsScreenViewController.class],
+      [viewController isKindOfClass:RNSTabsScreenViewController.class],
       @"[RNScreens] Expected selected view controller to be of class %@, got: %@",
       RNSTabsScreenViewController.class,
-      self.selectedViewController.class);
+      viewController.class);
 
-  auto *screenKey = static_cast<RNSTabsScreenViewController *>(self.selectedViewController).getScreenKeyOrNull;
+  auto *screenKey = static_cast<RNSTabsScreenViewController *>(viewController).getScreenKeyOrNull;
   RCTAssert(screenKey != nil, @"[RNScreens] screenKey MUST NOT be nil");
   return screenKey;
 }
 
+- (nonnull NSString *)screenKeyForSelectedViewController
+{
+  return [self screenKeyForViewController:self.selectedViewController];
+}
+
 /**
  * This function assumes that the source of the state is NOT user. In current model, user update is never stale.
  */
@@ -593,15 +675,20 @@ - (BOOL)isMoreNavigationControllerScreenKey:(nullable NSString *)screenKey
   return [screenKey isEqualToString:kMoreNavigationControllerScreenKey];
 }
 
-- (BOOL)isSelectedViewControllerTheMoreNavigationController
+- (BOOL)isViewControllerTheMoreNavigationController:(nonnull UIViewController *)viewController
 {
 #if RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
-  return [self canHaveMoreNavigationController] && self.selectedViewController == self.moreNavigationController;
+  return [self canHaveMoreNavigationController] && viewController == self.moreNavigationController;
 #else
   return NO;
 #endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
 }
 
+- (BOOL)isSelectedViewControllerTheMoreNavigationController
+{
+  return [self isViewControllerTheMoreNavigationController:self.selectedViewController];
+}
+
 - (BOOL)isMoreNavigationControllerRequestedByOperation:(nullable RNSTabsNavigationState *)navState
 {
   if (navState == nil) {
@@ -633,29 +720,174 @@ - (BOOL)isMoreNavigationControllerTabBarItemSelected
 - (void)disableNavigationBarInMoreNavigationController
 {
 #if RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
-  [self.moreNavigationController setNavigationBarHidden:YES animated:NO];
+  if (!self.moreNavigationController.navigationBar.isHidden) {
+    [self.moreNavigationController setNavigationBarHidden:YES animated:NO];
+  }
 #endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
 }
 
-- (void)popToRootInMoreNavigationControllerIfNeededAnimated:(BOOL)isAnimated
+- (nullable UIViewController *)popToRootInMoreNavigationControllerRespectSelectionPrevention:
+                                   (BOOL)shouldRespectSelectionPrevention
+                                                                                    animated:(BOOL)shouldAnimate
 {
 #if RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
   if ([self isMoreNavigationControllerPresentInTabBar] && self.moreNavigationController.viewControllers.count > 1) {
     // We quietly assume here, that the root view controller is the `UIMoreListViewController`.
-    [self.moreNavigationController popToRootViewControllerAnimated:isAnimated];
+    if (shouldRespectSelectionPrevention) {
+      UIViewController *topViewController = self.moreNavigationController.topViewController;
+      RCTAssert(
+          [topViewController isKindOfClass:RNSTabsScreenViewController.class],
+          @"[RNScreens] Unexpected type of view controller on moreNavigationControllerStack: %@",
+          topViewController.class);
+      RNSTabsScreenViewController *screenController = static_cast<RNSTabsScreenViewController *>(topViewController);
+      if (screenController.isPreventNativeSelectionEnabled) {
+        return [self popToRootMoreNavigationController:self.moreNavigationController animated:shouldAnimate];
+      }
+    } else {
+      return [self popToRootMoreNavigationController:self.moreNavigationController animated:shouldAnimate];
+    }
   }
 #endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+  return nil;
 }
 
-- (void)setupMoreNavigationControllerDelegateIfNeeded
+/**
+ * Pops the top view controller from more navigation controller. We expect at most two controllers on the stack of more
+ * navigation controller. If this assumption ever becomes invalid, this method needs to be updated.
+ *
+ * @returns nil if there was nothing to pop, the topViewController otherwise.
+ */
+- (nullable UIViewController *)popToRootMoreNavigationController:
+                                   (nonnull UINavigationController *)moreNavigationController
+                                                        animated:(BOOL)animated
+{
+  if (moreNavigationController.viewControllers.count < 2) {
+    return nil;
+  }
+
+  auto *poppedViewControllers = [moreNavigationController popToRootViewControllerAnimated:animated];
+  RCTAssert(
+      poppedViewControllers != nil && poppedViewControllers.count == 1,
+      @"[RNScreens] Expected exactly one view controller to be popped");
+  return [poppedViewControllers firstObject];
+}
+
+- (void)prepareForMoreNavigationControllerHandlingIfNeeded
 {
 #if RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+  // This can be called multiple times in lifetime of `RNSTabBarController`.
+  // UIKit reuses the same `UIMoreNavigationController` instance, but resets both
+  // the delegate and the isa pointer when the More controller disappears from the
+  // tab bar (e.g. user resizing the app on iPad). We re-apply both unconditionally.
   if (self.moreNavigationController.delegate == nil) {
     self.moreNavigationController.delegate = self;
   }
+  [self ensurePushInterceptorOnMoreNavigationController];
+#endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+}
+
+/// Creates a dynamic subclass of the runtime class of `moreNavigationController`
+/// (which is the private `UIMoreNavigationController`) and overrides `pushViewController:animated:`
+/// with our gating implementation.
+///
+/// The subclass name is derived from the actual runtime class of `moreNavigationController`
+/// (e.g. `RNS_UIMoreNavigationController`), so if another library ISA-swizzles it first or Apple
+/// changes the private class, each distinct original class gets its own correct dynamic subclass.
+///
+/// This method is idempotent — safe to call multiple times regardless of whether UIKit has
+/// reset the ISA between calls. When the ISA already carries our `RNS_` prefix, we return
+/// early. When UIKit has reset the ISA (e.g. iPad app resize crossing the >5 tab threshold),
+/// the dynamic subclass is looked up (or created) and re-applied.
+- (void)ensurePushInterceptorOnMoreNavigationController
+{
+#if RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+  Class currentClass = object_getClass(self.moreNavigationController);
+  const char *currentClassName = class_getName(currentClass);
+
+  // If the ISA already points to our dynamic subclass, the interceptor is in place.
+  // Without this guard, repeated calls when UIKit has NOT reset the ISA would stack
+  // `RNS_RNS_...` subclasses, causing infinite recursion in rns_pushViewController's
+  // objc_msgSendSuper call.
+  if (strncmp(currentClassName, "RNS_", 4) == 0) {
+    return;
+  }
+
+  // Build a unique subclass name per original runtime class: "RNS_<originalClassName>"
+  char dynamicSubclassName[256];
+  snprintf(dynamicSubclassName, sizeof(dynamicSubclassName), "RNS_%s", currentClassName);
+
+  Class dynamicSubclass = objc_getClass(dynamicSubclassName);
+
+  if (dynamicSubclass == nil) {
+    dynamicSubclass = objc_allocateClassPair(currentClass, dynamicSubclassName, 0);
+    RCTAssert(dynamicSubclass != nil, @"[RNScreens] Failed to allocate dynamic subclass of %s", currentClassName);
+
+    Method pushMethod = class_getInstanceMethod(currentClass, @selector(pushViewController:animated:));
+    class_addMethod(
+        dynamicSubclass,
+        @selector(pushViewController:animated:),
+        (IMP)rns_pushViewController,
+        method_getTypeEncoding(pushMethod));
+
+    objc_registerClassPair(dynamicSubclass);
+  }
+
+  object_setClass(self.moreNavigationController, dynamicSubclass);
 #endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
 }
 
+/// Decides whether `moreNavigationController` should be allowed to push `viewController`.
+/// This mirrors the logic in `shouldPreventNativeTabSelection:` for the More list context.
+- (BOOL)moreNavigationController:(UINavigationController *)navigationController
+        shouldPushViewController:(UIViewController *)viewController
+{
+  BOOL shouldPrevent = [self shouldPreventNativeTabSelection:viewController];
+
+  if (shouldPrevent) {
+    [self onDidPreventUserFromSelectingViewControllerWithKey:[self screenKeyForViewController:viewController]];
+    [self deselectMoreListSelectionInNavigationController:navigationController];
+  }
+
+  return !shouldPrevent;
+}
+
+/// When we prevent a push from the More list, the tapped table view cell stays highlighted
+/// because UIKit expects the push to handle deselection on return. We deselect it manually.
+- (void)deselectMoreListSelectionInNavigationController:(UINavigationController *)navigationController
+{
+#if RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+  UIViewController *topVC = navigationController.topViewController;
+  UITableView *tableView = [self findTableViewInView:topVC.view];
+
+  if (tableView != nil) {
+    NSIndexPath *selectedIndexPath = tableView.indexPathForSelectedRow;
+    if (selectedIndexPath != nil) {
+      [tableView deselectRowAtIndexPath:selectedIndexPath animated:YES];
+    }
+  } else {
+    RCTLogWarn(@"[RNScreens] Failed to find a table view to clear focus!");
+  }
+#endif // RNS_MORE_NAVIGATION_CONTROLLER_AVAILABLE
+}
+
+/**
+ * Unbounded DFS looking for ANY `UITableView` in the subtree rooted at view.
+ * The `view` parameter is included in the search.
+ */
+- (nullable UITableView *)findTableViewInView:(UIView *)view
+{
+  if ([view isKindOfClass:UITableView.class]) {
+    return (UITableView *)view;
+  }
+  for (UIView *subview in view.subviews) {
+    UITableView *result = [self findTableViewInView:subview];
+    if (result != nil) {
+      return result;
+    }
+  }
+  return nil;
+}
+
 /**
  * This method allows getting the `moreNavigationController` instance under a couple of conditions.
  *
diff --git a/ios/tabs/host/RNSTabsHostComponentView.h b/ios/tabs/host/RNSTabsHostComponentView.h
index a03adfb0aa..624d5895c5 100644
--- a/ios/tabs/host/RNSTabsHostComponentView.h
+++ b/ios/tabs/host/RNSTabsHostComponentView.h
@@ -112,6 +112,10 @@ NS_ASSUME_NONNULL_BEGIN
              currentState:(nonnull RNSTabsNavigationState *)currentNavState
                withReason:(RNSTabsNavigationStateRejectionReason)reasonCode;
 
+- (void)tabBarController:(nonnull RNSTabBarController *)tabBarController
+    preventedSelectionOf:(nonnull NSString *)screenKey
+            currentState:(nonnull RNSTabsNavigationState *)currentNavState;
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/ios/tabs/host/RNSTabsHostComponentView.mm b/ios/tabs/host/RNSTabsHostComponentView.mm
index 53e06d1e6e..4efe6baf4e 100644
--- a/ios/tabs/host/RNSTabsHostComponentView.mm
+++ b/ios/tabs/host/RNSTabsHostComponentView.mm
@@ -628,6 +628,22 @@ - (void)tabBarController:(nonnull RNSTabBarController *)tabBarController
                                                       .rejectionReason = reasonCode}];
 }
 
+- (void)tabBarController:(nonnull RNSTabBarController *)tabBarController
+    preventedSelectionOf:(nonnull NSString *)screenKey
+            currentState:(nonnull RNSTabsNavigationState *)currentNavState
+{
+  RCTAssert(tabBarController != nil, @"[RNScreens] Expected NON NIL tabBarController");
+  RCTAssert(screenKey != nil, @"[RNScreens] Expected NON NIL screenKey");
+  RCTAssert(
+      currentNavState != nil && currentNavState.selectedScreenKey != nil,
+      @"[RNScreens] Expected NON NIL nav state & selectedScreenKey");
+
+  [self.reactEventEmitter emitOnTabSelectionPrevented:{
+                                                          .currentNavState = currentNavState,
+                                                          .preventedScreenKey = screenKey,
+  }];
+}
+
 @end
 
 #pragma mark - Modified React Subviews implementation
diff --git a/ios/tabs/host/RNSTabsHostEventEmitter.h b/ios/tabs/host/RNSTabsHostEventEmitter.h
index 69eb4feeff..76393b0684 100644
--- a/ios/tabs/host/RNSTabsHostEventEmitter.h
+++ b/ios/tabs/host/RNSTabsHostEventEmitter.h
@@ -40,6 +40,14 @@ typedef struct {
   RNSTabsNavigationStateRejectionReason rejectionReason;
 } OnTabSelectionRejectedPayload;
 
+/** Payload for the `onTabSelectionPrevented` event emitted when a tab selection is prevented. */
+typedef struct {
+  /** The currently active navigation state that was kept. */
+  RNSTabsNavigationState *_Nonnull currentNavState;
+  /** Screen key of the tab whose selection was prevented. */
+  NSString *_Nonnull preventedScreenKey;
+} OnTabSelectionPreventedPayload;
+
 @interface RNSTabsHostEventEmitter : NSObject
 
 /** Emits `onTabSelected` event to JS. Returns YES if the event was dispatched successfully. */
@@ -48,6 +56,9 @@ typedef struct {
 /** Emits `onTabSelectionRejected` event to JS. Returns YES if the event was dispatched successfully. */
 - (BOOL)emitOnTabSelectionRejected:(OnTabSelectionRejectedPayload)payload;
 
+/** Emits `onTabSelectionPrevented` event to JS. Returns YES if the event was dispatched successfully. */
+- (BOOL)emitOnTabSelectionPrevented:(OnTabSelectionPreventedPayload)payload;
+
 @end
 
 #pragma mark - Hidden from Swift
diff --git a/ios/tabs/host/RNSTabsHostEventEmitter.mm b/ios/tabs/host/RNSTabsHostEventEmitter.mm
index 1c5b2e9a00..812f6de161 100644
--- a/ios/tabs/host/RNSTabsHostEventEmitter.mm
+++ b/ios/tabs/host/RNSTabsHostEventEmitter.mm
@@ -69,4 +69,18 @@ - (BOOL)emitOnTabSelectionRejected:(OnTabSelectionRejectedPayload)payload
   }
 }
 
+- (BOOL)emitOnTabSelectionPrevented:(OnTabSelectionPreventedPayload)payload
+{
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onTabSelectionPrevented(
+        {.selectedScreenKey = RCTStringFromNSString(payload.currentNavState.selectedScreenKey),
+         .provenance = payload.currentNavState.provenance,
+         .preventedScreenKey = RCTStringFromNSString(payload.preventedScreenKey)});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnTabSelectionPrevented event emission due to nullish emitter");
+    return NO;
+  }
+}
+
 @end
diff --git a/ios/tabs/screen/RNSTabsScreenComponentView.h b/ios/tabs/screen/RNSTabsScreenComponentView.h
index 04b9d0a345..695d8d368c 100644
--- a/ios/tabs/screen/RNSTabsScreenComponentView.h
+++ b/ios/tabs/screen/RNSTabsScreenComponentView.h
@@ -81,6 +81,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic) BOOL shouldUseRepeatedTabSelectionPopToRootSpecialEffect;
 @property (nonatomic) BOOL shouldUseRepeatedTabSelectionScrollToTopSpecialEffect;
 
+@property (nonatomic) BOOL preventNativeSelection;
+
 @property (nonatomic, readonly) BOOL overrideScrollViewContentInsetAdjustmentBehavior;
 
 @property (nonatomic, nullable) NSString *tabItemTestID;
diff --git a/ios/tabs/screen/RNSTabsScreenComponentView.mm b/ios/tabs/screen/RNSTabsScreenComponentView.mm
index 973fe05890..7abe5fc8fc 100644
--- a/ios/tabs/screen/RNSTabsScreenComponentView.mm
+++ b/ios/tabs/screen/RNSTabsScreenComponentView.mm
@@ -348,6 +348,10 @@ - (void)updateProps:(const facebook::react::Props::Shared &)props
         newComponentProps.specialEffects.repeatedTabSelection.scrollToTop;
   }
 
+  if (newComponentProps.preventNativeSelection != oldComponentProps.preventNativeSelection) {
+    _preventNativeSelection = newComponentProps.preventNativeSelection;
+  }
+
   if (newComponentProps.overrideScrollViewContentInsetAdjustmentBehavior !=
       oldComponentProps.overrideScrollViewContentInsetAdjustmentBehavior) {
     _overrideScrollViewContentInsetAdjustmentBehavior =
diff --git a/ios/tabs/screen/RNSTabsScreenViewController.h b/ios/tabs/screen/RNSTabsScreenViewController.h
index 27bd22b300..40d0985960 100644
--- a/ios/tabs/screen/RNSTabsScreenViewController.h
+++ b/ios/tabs/screen/RNSTabsScreenViewController.h
@@ -18,8 +18,6 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, strong, readonly, nullable) RNSTabsScreenComponentView *tabScreenComponentView;
 @property (nonatomic, weak, readonly, nullable) id<RNSTabsSpecialEffectsSupporting> tabsSpecialEffectsDelegate;
 
-- (nullable NSString *)getScreenKeyOrNull;
-
 /**
  * Tell the controller that the tab screen it owns has got its react-props related to appearance changed.
  */
@@ -50,4 +48,12 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
+@interface RNSTabsScreenViewController (TabsScreenPropsForwarding)
+
+- (nullable NSString *)getScreenKeyOrNull;
+
+- (BOOL)isPreventNativeSelectionEnabled;
+
+@end
+
 NS_ASSUME_NONNULL_END
diff --git a/ios/tabs/screen/RNSTabsScreenViewController.mm b/ios/tabs/screen/RNSTabsScreenViewController.mm
index 0b6ef9282d..b2737706a0 100644
--- a/ios/tabs/screen/RNSTabsScreenViewController.mm
+++ b/ios/tabs/screen/RNSTabsScreenViewController.mm
@@ -6,11 +6,6 @@
 
 @implementation RNSTabsScreenViewController
 
-- (nullable NSString *)getScreenKeyOrNull
-{
-  return self.tabScreenComponentView.screenKey;
-}
-
 - (nullable RNSTabBarController *)findTabBarController
 {
   return static_cast<RNSTabBarController *_Nullable>(self.tabBarController);
@@ -33,21 +28,25 @@ - (void)tabScreenOrientationHasChanged
 
 - (void)viewWillAppear:(BOOL)animated
 {
+  [super viewWillAppear:animated];
   [self.tabScreenComponentView.reactEventEmitter emitOnWillAppear];
 }
 
 - (void)viewDidAppear:(BOOL)animated
 {
+  [super viewDidAppear:animated];
   [self.tabScreenComponentView.reactEventEmitter emitOnDidAppear];
 }
 
 - (void)viewWillDisappear:(BOOL)animated
 {
+  [super viewWillDisappear:animated];
   [self.tabScreenComponentView.reactEventEmitter emitOnWillDisappear];
 }
 
 - (void)viewDidDisappear:(BOOL)animated
 {
+  [super viewDidDisappear:animated];
   [self.tabScreenComponentView.reactEventEmitter emitOnDidDisappear];
 }
 
@@ -126,3 +125,17 @@ - (RNSOrientation)evaluateOrientation
 #endif // !TARGET_OS_TV
 
 @end
+
+@implementation RNSTabsScreenViewController (TabsScreenPropsForwarding)
+
+- (nullable NSString *)getScreenKeyOrNull
+{
+  return self.tabScreenComponentView.screenKey;
+}
+
+- (BOOL)isPreventNativeSelectionEnabled
+{
+  return self.tabScreenComponentView.preventNativeSelection;
+}
+
+@end
diff --git a/src/components/tabs/host/TabsHost.types.ts b/src/components/tabs/host/TabsHost.types.ts
index 4cb905f96c..c126263cf6 100644
--- a/src/components/tabs/host/TabsHost.types.ts
+++ b/src/components/tabs/host/TabsHost.types.ts
@@ -105,6 +105,19 @@ export type TabSelectionRejectedEvent = {
   rejectionReason: TabSelectionRejectionReason;
 };
 
+/**
+ * @summary Payload of the event emitted when the native side prevents a tab selection
+ * because the target screen has `preventNativeSelection` enabled.
+ */
+export type TabSelectionPreventedEvent = {
+  /** Screen key of the currently selected (active) tab. */
+  selectedScreenKey: string;
+  /** Provenance of the currently active navigation state. */
+  provenance: number;
+  /** Screen key of the tab whose selection was prevented. */
+  preventedScreenKey: string;
+};
+
 export type TabsHostColorScheme = ColorScheme | 'inherit';
 
 export type TabsHostDirection = Direction | 'inherit';
@@ -258,6 +271,17 @@ export interface TabsHostPropsBase {
   onTabSelectionRejected?: (
     event: NativeSyntheticEvent<TabSelectionRejectedEvent>,
   ) => void;
+
+  /**
+   * @summary
+   * A callback that gets invoked when the native side prevents a tab selection
+   * because the target screen has `preventNativeSelection` enabled.
+   *
+   * @see {@link TabSelectionPreventedEvent}
+   */
+  onTabSelectionPrevented?: (
+    event: NativeSyntheticEvent<TabSelectionPreventedEvent>,
+  ) => void;
 }
 
 export interface TabsHostProps extends TabsHostPropsBase {
diff --git a/src/components/tabs/screen/TabsScreen.types.ts b/src/components/tabs/screen/TabsScreen.types.ts
index 144b72cacd..87b5eba39d 100644
--- a/src/components/tabs/screen/TabsScreen.types.ts
+++ b/src/components/tabs/screen/TabsScreen.types.ts
@@ -30,6 +30,14 @@ export interface TabsScreenPropsBase {
    * @platform android, ios
    */
   screenKey: string;
+  /**
+   * @summary When set to `true`, prevents native tab selection for this screen.
+   *
+   * @default false
+   *
+   * @platform android, ios
+   */
+  preventNativeSelection?: boolean;
 
   // General
   children?: ViewProps['children'];
diff --git a/src/fabric/tabs/TabsHostAndroidNativeComponent.ts b/src/fabric/tabs/TabsHostAndroidNativeComponent.ts
index ca9e08ccfa..28c287bced 100644
--- a/src/fabric/tabs/TabsHostAndroidNativeComponent.ts
+++ b/src/fabric/tabs/TabsHostAndroidNativeComponent.ts
@@ -26,6 +26,12 @@ type TabSelectionRejectedEvent = Readonly<{
   rejectionReason: 'stale' | 'repeated' | 'more-nav-ctrl-not-available';
 }>;
 
+type TabSelectionPreventedEvent = Readonly<{
+  selectedScreenKey: string;
+  provenance: CT.Int32;
+  preventedScreenKey: string;
+}>;
+
 type TabsHostColorScheme = 'inherit' | 'light' | 'dark';
 
 // #endregion General helpers
@@ -42,6 +48,7 @@ export interface NativeProps extends ViewProps {
   // Events
   onTabSelected?: CT.DirectEventHandler<TabSelectedEvent>;
   onTabSelectionRejected?: CT.DirectEventHandler<TabSelectionRejectedEvent>;
+  onTabSelectionPrevented?: CT.DirectEventHandler<TabSelectionPreventedEvent>;
 
   // General
   tabBarHidden?: CT.WithDefault<boolean, false>;
diff --git a/src/fabric/tabs/TabsHostIOSNativeComponent.ts b/src/fabric/tabs/TabsHostIOSNativeComponent.ts
index b6491102e6..b5f9ee88bf 100644
--- a/src/fabric/tabs/TabsHostIOSNativeComponent.ts
+++ b/src/fabric/tabs/TabsHostIOSNativeComponent.ts
@@ -26,6 +26,12 @@ type TabSelectionRejectedEvent = Readonly<{
   rejectionReason: 'stale' | 'repeated' | 'more-nav-ctrl-not-available';
 }>;
 
+type TabSelectionPreventedEvent = Readonly<{
+  selectedScreenKey: string;
+  provenance: CT.Int32;
+  preventedScreenKey: string;
+}>;
+
 type TabsHostColorScheme = 'inherit' | 'light' | 'dark';
 
 type LayoutDirection = 'inherit' | 'ltr' | 'rtl';
@@ -52,6 +58,7 @@ export interface NativeProps extends ViewProps {
   // Events
   onTabSelected?: CT.DirectEventHandler<TabSelectedEvent>;
   onTabSelectionRejected?: CT.DirectEventHandler<TabSelectionRejectedEvent>;
+  onTabSelectionPrevented?: CT.DirectEventHandler<TabSelectionPreventedEvent>;
 
   // General
   tabBarHidden?: CT.WithDefault<boolean, false>;
diff --git a/src/fabric/tabs/TabsScreenAndroidNativeComponent.ts b/src/fabric/tabs/TabsScreenAndroidNativeComponent.ts
index e6daeef7f5..41393ff2ce 100644
--- a/src/fabric/tabs/TabsScreenAndroidNativeComponent.ts
+++ b/src/fabric/tabs/TabsScreenAndroidNativeComponent.ts
@@ -74,6 +74,7 @@ export interface NativeProps extends ViewProps {
 
   // Control
   screenKey: string;
+  preventNativeSelection?: CT.WithDefault<boolean, false>;
 
   // General
   title?: string | undefined | null;
diff --git a/src/fabric/tabs/TabsScreenIOSNativeComponent.ts b/src/fabric/tabs/TabsScreenIOSNativeComponent.ts
index 3132470ec0..724b0c22eb 100644
--- a/src/fabric/tabs/TabsScreenIOSNativeComponent.ts
+++ b/src/fabric/tabs/TabsScreenIOSNativeComponent.ts
@@ -119,6 +119,7 @@ export interface NativeProps extends ViewProps {
   // Control
   isFocused?: boolean;
   screenKey: string;
+  preventNativeSelection?: CT.WithDefault<boolean, false>;
 
   // General
   title?: string | undefined | null;