diff --git a/apps/src/tests/single-feature-tests/contained-modal/index.ts b/apps/src/tests/single-feature-tests/contained-modal/index.ts
new file mode 100644
index 0000000000..49213f790c
--- /dev/null
+++ b/apps/src/tests/single-feature-tests/contained-modal/index.ts
@@ -0,0 +1,14 @@
+import type { ScenarioGroup } from '@apps/tests/shared/helpers';
+import TestContainedModalBase from './test-contained-modal-base-ios';
+
+const scenarios = {
+  TestContainedModalBase,
+};
+
+const ContainedModalScenarioGroup: ScenarioGroup<keyof typeof scenarios> = {
+  name: 'ContainedModal',
+  details: 'Single feature tests for ContainedModals',
+  scenarios,
+};
+
+export default ContainedModalScenarioGroup;
diff --git a/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/index.tsx b/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/index.tsx
new file mode 100644
index 0000000000..301cf08789
--- /dev/null
+++ b/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/index.tsx
@@ -0,0 +1,141 @@
+import React, { useState } from 'react';
+import { Button, Pressable, StyleSheet, Text, View } from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import {
+  ContainedModal,
+  ContainedModalProvider,
+} from 'react-native-screens/experimental';
+import { scenarioDescription } from './scenario-description';
+import { createScenario } from '@apps/tests/shared/helpers';
+import { Colors } from '@apps/shared/styling';
+
+const CONTAINER_ID = 'contained-modal-base';
+
+export function App() {
+  const insets = useSafeAreaInsets();
+  const [isOpen, setIsOpen] = useState(false);
+  const [partialProvider, setPartialProvider] = useState(false);
+  const [insideCount, setInsideCount] = useState(0);
+  const [outsideCount, setOutsideCount] = useState(0);
+
+  return (
+    <View style={[styles.screen, { paddingTop: insets.top }]}>
+      <View style={styles.content}>
+        <Text style={styles.title}>ContainedModal Test</Text>
+        <Button
+          title={
+            partialProvider
+              ? 'Provider: partial (tap for full screen)'
+              : 'Provider: full screen (tap for partial)'
+          }
+          color={Colors.primary}
+          onPress={() => setPartialProvider(value => !value)}
+        />
+        <View style={styles.spacing} />
+        <Button
+          title="Open contained modal"
+          color={Colors.primary}
+          onPress={() => setIsOpen(true)}
+        />
+        <View style={styles.spacing} />
+        <Pressable
+          style={styles.counter}
+          onPress={() => setOutsideCount(value => value + 1)}>
+          <Text style={styles.counterText}>Outside count: {outsideCount}</Text>
+        </Pressable>
+      </View>
+
+      <ContainedModalProvider
+        containerId={CONTAINER_ID}
+        style={partialProvider ? styles.partialProvider : styles.fullProvider}>
+        <View style={styles.providerContent}>
+          <Pressable
+            style={styles.counter}
+            onPress={() => setInsideCount(value => value + 1)}>
+            <Text style={styles.counterText}>Inside count: {insideCount}</Text>
+          </Pressable>
+        </View>
+        <ContainedModal targetContainerId={CONTAINER_ID} isOpen={isOpen}>
+          <View style={styles.modal}>
+            <Text style={styles.sheetTitle}>🎉 This is a contained modal</Text>
+            <View style={styles.spacing} />
+            <Button
+              title="Close"
+              color={Colors.primary}
+              onPress={() => setIsOpen(false)}
+            />
+          </View>
+        </ContainedModal>
+      </ContainedModalProvider>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  screen: {
+    flex: 1,
+    backgroundColor: Colors.offBackground,
+  },
+  content: {
+    paddingTop: 16,
+    alignItems: 'center',
+  },
+  title: {
+    fontSize: 20,
+    fontWeight: 'bold',
+    marginBottom: 20,
+    color: Colors.text,
+  },
+  fullProvider: {
+    flex: 1,
+    marginTop: 16,
+    borderWidth: 2,
+    borderColor: 'transparent',
+  },
+  partialProvider: {
+    height: 320,
+    marginTop: 16,
+    marginHorizontal: 24,
+    marginBottom: 24,
+    borderWidth: 2,
+    borderColor: Colors.primary,
+    borderRadius: 12,
+    overflow: 'hidden',
+  },
+  providerContent: {
+    padding: 16,
+    alignItems: 'center',
+  },
+  counter: {
+    paddingVertical: 12,
+    paddingHorizontal: 20,
+    borderRadius: 8,
+    borderWidth: 2,
+    borderColor: Colors.primary,
+    backgroundColor: Colors.background,
+    alignItems: 'center',
+  },
+  counterText: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: Colors.primary,
+  },
+  modal: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 24,
+    backgroundColor: 'transparent',
+  },
+  sheetTitle: {
+    fontSize: 22,
+    fontWeight: '600',
+    marginBottom: 12,
+    color: Colors.text,
+  },
+  spacing: {
+    height: 32,
+  },
+});
+
+export default createScenario(App, scenarioDescription);
diff --git a/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/scenario-description.ts b/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/scenario-description.ts
new file mode 100644
index 0000000000..68613ed4a2
--- /dev/null
+++ b/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/scenario-description.ts
@@ -0,0 +1,11 @@
+import type { ScenarioDescription } from '@apps/tests/shared/helpers';
+
+export const scenarioDescription: ScenarioDescription = {
+  name: 'Basic functionality',
+  key: 'test-contained-modal-base-ios',
+  details:
+    'Allows testing the basic functionality of the ContainedModal component.',
+  platforms: ['ios'],
+  e2eCoverage: 'tbd',
+  smokeTest: false,
+};
diff --git a/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/scenario.md b/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/scenario.md
new file mode 100644
index 0000000000..888a5f1165
--- /dev/null
+++ b/apps/src/tests/single-feature-tests/contained-modal/test-contained-modal-base-ios/scenario.md
@@ -0,0 +1,119 @@
+# Test Scenario: Basic functionality
+
+## Details
+
+**Description:** Verify the core functionality of the `ContainedModal` component together with `ContainedModalProvider`. This test ensures that the modal is presented within the bounds of the provider it targets (matched by `containerId` / `targetContainerId`), that it works both with a full-screen and a partial-size provider, that its transparent background lets the provider's content show through (over-current-context presentation), and that presenting/dismissing repeatedly keeps working.
+
+**OS test creation version:** iOS: 18.6 and 26.4, iPadOS 26.4
+
+## E2E test
+
+TBD.
+
+## Prerequisites
+
+- iOS device or simulator: iPhone and iPad
+- `ContainedModal` is currently an iOS-only component.
+
+## Note
+
+- The modal is presented from the provider whose `containerId` equals the modal's `targetContainerId`, so it is contained within that provider's bounds, not presented over the whole window.
+- The modal's content has a transparent background, so the provider's content (the "Inside count" button) stays visible behind it.
+- Two counters exercise touch routing:
+  - **"Outside count"** lives outside the provider (in the top section) and is never covered by the modal.
+  - **"Inside count"** lives inside the provider, directly underneath where the modal is presented.
+
+## Touch-routing invariant (applies in every step below)
+
+Regardless of whether the provider is full-screen or partial:
+
+- **"Outside count" must always be tappable** - before, while, and after a modal is presented. It sits outside the provider, so the modal must never block it.
+- **"Inside count" must be blocked _only while the modal is open_.** While the modal is presented it sits underneath the (transparent) modal content and must not receive taps. As soon as the modal is dismissed it must be tappable again.
+
+## Steps
+
+### Baseline
+
+1. Launch the app and navigate to the **Basic functionality** screen.
+
+- [ ] Expected: Content is shown with the "Provider: full screen (tap for partial)" button, an "Open contained modal" button, an "Outside count: 0" button, and (inside the provider region) an "Inside count: 0" button.
+
+---
+
+### Background pressables work (no modal presented)
+
+2. Tap "Outside count" and "Inside count" a few times each.
+
+- [ ] Expected: Both counters increment on every tap (all of the provider's content and the surrounding content are interactive while no modal is presented).
+
+---
+
+### Present within a full-screen provider
+
+3. Tap "Open contained modal".
+
+- [ ] Expected: The modal appears with a cross-dissolve (fade-in) animation. The "🎉 This is a contained modal" text and the "Close" button are centered. Because the modal background is transparent, the underlying "Inside count" button is still visible behind it.
+
+---
+
+### Touch routing while the modal is open (full-screen provider)
+
+4. With the modal still open, tap where the "Inside count" button is (underneath the modal), then tap "Outside count".
+
+- [ ] Expected: "Inside count" does **not** increment (it is covered by the open modal). "Outside count" **does** increment (it is outside the provider and stays interactive). See the touch-routing invariant above.
+
+---
+
+### Dismiss
+
+5. Tap "Close".
+
+- [ ] Expected: The modal dismisses smoothly.
+
+---
+
+### Background pressable works again after dismiss (touch-handler cleanup)
+
+> Regression check: after dismissal, the modal's touch handler must be detached.
+> If it is not, it keeps consuming touches in the area the modal used to occupy and
+> silently swallows taps meant for the "Inside count" button behind it, even though
+> the modal is no longer visible.
+
+6. Note the current "Inside count" value, then tap the "Inside count" button (the one
+   that sits in the region the modal was just covering) several times. Tap "Outside
+   count" too.
+
+- [ ] Expected: Both counters increment on every tap. Taps on "Inside count" are NOT
+      swallowed - there is no dead/unresponsive zone left behind where the dismissed
+      modal used to be.
+
+7. Re-open the modal ("Open contained modal"), tap "Close" again, and repeat the taps
+   from step 6.
+
+- [ ] Expected: Both counters still increment on every tap after this second
+      open/close cycle (the touch handler is correctly re-attached on re-present and
+      detached again on dismiss).
+
+---
+
+### Present within a partial provider
+
+8. Tap "Provider: full screen (tap for partial)" to switch to the partial provider, then tap "Open contained modal".
+
+- [ ] Expected: A bordered region (the provider bounds) is visible. The modal is presented **within that bordered region only**, not over the whole screen. The modal content is sized and positioned within the provider's bounds.
+
+---
+
+### Touch routing while the modal is open (partial provider)
+
+9. With the modal still open, tap where the "Inside count" button is (underneath the modal, inside the bordered region), then tap "Outside count".
+
+- [ ] Expected: Same invariant as the full-screen case - "Inside count" does **not** increment while the modal is open, "Outside count" **does**. The smaller provider size must not change this behavior.
+
+---
+
+### Dismiss from partial provider
+
+10. Tap "Close".
+
+- [ ] Expected: The modal dismisses smoothly and the screen returns to the partial-provider layout. "Inside count" is tappable again and "Outside count" keeps working.
diff --git a/apps/src/tests/single-feature-tests/index.tsx b/apps/src/tests/single-feature-tests/index.tsx
index eafecf16b6..ea6bfe8a1d 100644
--- a/apps/src/tests/single-feature-tests/index.tsx
+++ b/apps/src/tests/single-feature-tests/index.tsx
@@ -12,6 +12,7 @@ import StackV5ScenarioGroup from './stack-v5';
 import StackV4ScenarioGroup from './stack-v4';
 import ScrollViewMarkerScenarioGroup from './scroll-view-marker';
 import FormSheetScenarioGroup from './form-sheet';
+import ContainedModalScenarioGroup from './contained-modal';
 import { ScenarioButton } from '@apps/tests/shared/ScenarioButton';
 import ScenarioSelectionScreen from '@apps/tests/shared/ScenarioScreen';
 
@@ -22,6 +23,7 @@ export const COMPONENT_SCENARIOS = {
   StackV4: StackV4ScenarioGroup,
   ScrollViewMarker: ScrollViewMarkerScenarioGroup,
   FormSheet: FormSheetScenarioGroup,
+  ContainedModal: ContainedModalScenarioGroup,
 } as const;
 
 type ParamsList = { [k: keyof typeof COMPONENT_SCENARIOS]: undefined } & {
diff --git a/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostComponentDescriptor.h b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostComponentDescriptor.h
new file mode 100644
index 0000000000..c79c8c79ba
--- /dev/null
+++ b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostComponentDescriptor.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#if !defined(ANDROID)
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSContainedModalHostShadowNode.h"
+
+namespace facebook::react {
+
+class RNSContainedModalHostComponentDescriptor final
+    : public ConcreteComponentDescriptor<RNSContainedModalHostShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(
+        dynamic_cast<RNSContainedModalHostShadowNode *>(&shadowNode));
+    auto &concreteShadowNode =
+        static_cast<RNSContainedModalHostShadowNode &>(shadowNode);
+
+    react_native_assert(
+        dynamic_cast<YogaLayoutableShadowNode *>(&concreteShadowNode));
+    auto &layoutableShadowNode =
+        static_cast<YogaLayoutableShadowNode &>(concreteShadowNode);
+
+    auto state = std::static_pointer_cast<
+        const RNSContainedModalHostShadowNode::ConcreteState>(
+        shadowNode.getState());
+
+    auto stateData = state->getData();
+
+    if (stateData.frameSize.width > 0 && stateData.frameSize.height > 0) {
+      layoutableShadowNode.setSize(
+          Size{stateData.frameSize.width, stateData.frameSize.height});
+    }
+
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react
+
+#endif // !defined(ANDROID)
diff --git a/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostShadowNode.cpp b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostShadowNode.cpp
new file mode 100644
index 0000000000..b0ff395e32
--- /dev/null
+++ b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostShadowNode.cpp
@@ -0,0 +1,17 @@
+#include "RNSContainedModalHostShadowNode.h"
+
+#if !defined(ANDROID)
+
+namespace facebook::react {
+
+extern const char RNSContainedModalHostComponentName[] =
+    "RNSContainedModalHost";
+
+Point RNSContainedModalHostShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
+  return getStateData().contentOffset;
+}
+
+} // namespace facebook::react
+
+#endif // !defined(ANDROID)
diff --git a/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostShadowNode.h b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostShadowNode.h
new file mode 100644
index 0000000000..141c95600f
--- /dev/null
+++ b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostShadowNode.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#if !defined(ANDROID)
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/rnscreens/EventEmitters.h>
+#include <react/renderer/components/rnscreens/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include "RNSContainedModalHostState.h"
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char RNSContainedModalHostComponentName[];
+
+class JSI_EXPORT RNSContainedModalHostShadowNode final
+    : public ConcreteViewShadowNode<
+          RNSContainedModalHostComponentName,
+          RNSContainedModalHostProps,
+          RNSContainedModalHostEventEmitter,
+          RNSContainedModalHostState> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  Point getContentOriginOffset(bool includeTransform) const override;
+};
+
+} // namespace facebook::react
+
+#endif // !defined(ANDROID)
diff --git a/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostState.h b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostState.h
new file mode 100644
index 0000000000..acd37e5ebe
--- /dev/null
+++ b/common/cpp/react/renderer/components/rnscreens/RNSContainedModalHostState.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#if !defined(ANDROID)
+
+#include <react/renderer/graphics/Geometry.h>
+
+namespace facebook::react {
+
+class JSI_EXPORT RNSContainedModalHostState final {
+ public:
+  RNSContainedModalHostState() = default;
+  RNSContainedModalHostState(Size frameSize, Point contentOffset)
+      : frameSize(frameSize), contentOffset(contentOffset) {}
+
+  Size frameSize{};
+  Point contentOffset{};
+};
+
+} // namespace facebook::react
+
+#endif // !defined(ANDROID)
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalConfigurationApplicator.h b/ios/gamma/modals/contained-modal/RNSContainedModalConfigurationApplicator.h
new file mode 100644
index 0000000000..15f2f26927
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalConfigurationApplicator.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import "RNSContainedModalProviders.h"
+
+@class RNSContainedModalUpdateCoordinator;
+@class RNSContainedModalContentController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalConfigurationApplicator : NSObject
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalConfigurationApplicator.mm b/ios/gamma/modals/contained-modal/RNSContainedModalConfigurationApplicator.mm
new file mode 100644
index 0000000000..b21a99905c
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalConfigurationApplicator.mm
@@ -0,0 +1,5 @@
+#import "RNSContainedModalConfigurationApplicator.h"
+
+@implementation RNSContainedModalConfigurationApplicator
+
+@end
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalContentController.h b/ios/gamma/modals/contained-modal/RNSContainedModalContentController.h
new file mode 100644
index 0000000000..506a8d592a
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalContentController.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+#import "RNSContainedModalProviders.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSContainedModalContentView;
+@class RNSContainedModalContentController;
+
+@protocol RNSContainedModalContentControllerDelegate <NSObject>
+- (void)modalControllerViewDidLayoutSubviews:(RNSContainedModalContentController *)controller;
+- (void)modalControllerViewDidDisappear:(RNSContainedModalContentController *)controller;
+@end
+
+@interface RNSContainedModalContentController : UIViewController
+
+@property (nonatomic, weak, nullable) id<RNSContainedModalContentControllerDelegate> delegate;
+
+@property (nonatomic, weak, nullable) id<RNSContainedModalPresentationProvider> presentationProvider;
+
+@property (nonatomic, readonly, nonnull) RNSContainedModalContentView *contentView;
+
+#pragma mark - Signals
+
+- (void)setNeedsPresentationUpdate;
+- (void)setNeedsBehaviorUpdate;
+- (void)setNeedsAppearanceUpdate;
+
+#pragma mark - Updates
+
+- (void)flushPendingUpdates;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalContentController.mm b/ios/gamma/modals/contained-modal/RNSContainedModalContentController.mm
new file mode 100644
index 0000000000..8961738bf8
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalContentController.mm
@@ -0,0 +1,106 @@
+#import "RNSContainedModalContentController.h"
+#import "RNSContainedModalConfigurationApplicator.h"
+#import "RNSContainedModalContentView.h"
+#import "RNSContainedModalPresentationManager.h"
+#import "RNSContainedModalUpdateCoordinator.h"
+#import "RNSContainedModalUpdateFlags.h"
+
+#import <React/RCTAssert.h>
+
+@implementation RNSContainedModalContentController {
+  RNSContainedModalUpdateCoordinator *_Nonnull _updateCoordinator;
+  RNSContainedModalConfigurationApplicator *_Nonnull _configurationApplicator;
+  RNSContainedModalPresentationManager *_Nonnull _presentationManager;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    // TODO: expose these as props - the transition animation and the presentation style
+    // (UIModalPresentationOverCurrentContext vs UIModalPresentationCurrentContext should be configurable from JS).
+    self.modalPresentationStyle = UIModalPresentationOverCurrentContext;
+    self.modalTransitionStyle = UIModalTransitionStyleCrossDissolve;
+
+    _updateCoordinator = [RNSContainedModalUpdateCoordinator new];
+    _configurationApplicator = [RNSContainedModalConfigurationApplicator new];
+    _presentationManager = [RNSContainedModalPresentationManager new];
+  }
+  return self;
+}
+
+- (RNSContainedModalContentView *)contentView
+{
+  RCTAssert([self.view isKindOfClass:[RNSContainedModalContentView class]],
+            @"[RNScreens] ContentView must be of type RNSContainedModalContentView");
+  return static_cast<RNSContainedModalContentView *>(self.view);
+}
+
+#pragma mark - UIKit callbacks
+
+- (void)loadView
+{
+  self.view = [RNSContainedModalContentView new];
+}
+
+- (void)viewDidLayoutSubviews
+{
+  [super viewDidLayoutSubviews];
+
+  [self.delegate modalControllerViewDidLayoutSubviews:self];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+  [super viewDidDisappear:animated];
+
+  [self.delegate modalControllerViewDidDisappear:self];
+}
+
+#pragma mark - Presentation Setup
+
+- (void)updatePresentationIfNeeded
+{
+  [_updateCoordinator updateIfNeeded:RNSContainedModalUpdateFlagsPresentation
+                   performOperations:^{
+                     [self updatePresentationState];
+                   }];
+}
+
+- (void)updatePresentationState
+{
+  id<RNSContainedModalPresentationProvider> presentationProvider = self.presentationProvider;
+
+  RCTAssert(presentationProvider != nil,
+            @"[RNScreens] Presentation provider must be set before updating presentation state.");
+
+  if (presentationProvider == nil) {
+    return;
+  }
+
+  [_presentationManager updatePresentationIfNeededWithProvider:presentationProvider controller:self];
+}
+
+#pragma mark - Signals
+
+- (void)setNeedsPresentationUpdate
+{
+  [_updateCoordinator setNeeds:RNSContainedModalUpdateFlagsPresentation];
+}
+
+- (void)setNeedsAppearanceUpdate
+{
+  [_updateCoordinator setNeeds:RNSContainedModalUpdateFlagsAppearance];
+}
+
+- (void)setNeedsBehaviorUpdate
+{
+  [_updateCoordinator setNeeds:RNSContainedModalUpdateFlagsBehavior];
+}
+
+#pragma mark - Updates
+
+- (void)flushPendingUpdates
+{
+  [self updatePresentationIfNeeded];
+}
+@end
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalContentView.h b/ios/gamma/modals/contained-modal/RNSContainedModalContentView.h
new file mode 100644
index 0000000000..9fa17aca17
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalContentView.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalContentView : UIView
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)index;
+- (void)removeReactSubview:(UIView *)subview;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalContentView.mm b/ios/gamma/modals/contained-modal/RNSContainedModalContentView.mm
new file mode 100644
index 0000000000..b606c3adb4
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalContentView.mm
@@ -0,0 +1,30 @@
+#import "RNSContainedModalContentView.h"
+
+@implementation RNSContainedModalContentView
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    // Explicitly set to clearColor since this UIView is manually added
+    // into the view hierarchy. This ensures it doesn't interfere with
+    // any background colors defined by child React subviews.
+    self.backgroundColor = [UIColor clearColor];
+    // Ensure the view stretches to fill the presentation context
+    self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  }
+  return self;
+}
+
+#pragma mark - RN Subviews Management
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)index
+{
+  [self insertSubview:subview atIndex:index];
+}
+
+- (void)removeReactSubview:(UIView *)subview
+{
+  [subview removeFromSuperview];
+}
+
+@end
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalHostComponentView.h b/ios/gamma/modals/contained-modal/RNSContainedModalHostComponentView.h
new file mode 100644
index 0000000000..95edf39c54
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalHostComponentView.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#import "RNSReactBaseView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalHostComponentView : RNSReactBaseView
+
+@end
+
+#pragma mark - Props
+
+@interface RNSContainedModalHostComponentView ()
+
+@property (nonatomic, readonly) BOOL isOpen;
+@property (nonatomic, copy, readonly, nullable) NSString *targetContainerId;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalHostComponentView.mm b/ios/gamma/modals/contained-modal/RNSContainedModalHostComponentView.mm
new file mode 100644
index 0000000000..9b75141afd
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalHostComponentView.mm
@@ -0,0 +1,244 @@
+#import "RNSContainedModalHostComponentView.h"
+#import "RNSContainedModalContentController.h"
+#import "RNSContainedModalContentView.h"
+#import "RNSContainedModalHostShadowStateProxy.h"
+#import "RNSContainedModalProviderComponentView.h"
+#import "RNSContainedModalProviders.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTMountingTransactionObserving.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <react/renderer/components/rnscreens/Props.h>
+#import <rnscreens/RNSContainedModalHostComponentDescriptor.h>
+
+namespace react = facebook::react;
+
+@interface RNSContainedModalHostComponentView () <RCTMountingTransactionObserving,
+                                                  RNSContainedModalContentControllerDelegate,
+                                                  RNSContainedModalPresentationProvider>
+@end
+
+@implementation RNSContainedModalHostComponentView {
+  RNSContainedModalHostShadowStateProxy *_Nonnull _shadowStateProxy;
+
+  RNSContainedModalContentController *_controller;
+  NSString *_targetContainerId;
+  RCTSurfaceTouchHandler *_Nullable _touchHandler;
+  BOOL _isOpen;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self initState];
+  }
+  return self;
+}
+
+- (void)initState
+{
+  [self resetProps];
+  [self setupController];
+
+  _shadowStateProxy = [RNSContainedModalHostShadowStateProxy new];
+}
+
+- (void)resetProps
+{
+  static const auto defaultProps = std::make_shared<const react::RNSContainedModalHostProps>();
+  _props = defaultProps;
+
+  _isOpen = NO;
+  _targetContainerId = nil;
+}
+
+- (void)setupController
+{
+  _controller = [RNSContainedModalContentController new];
+  _controller.delegate = self;
+  _controller.presentationProvider = self;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+
+  if (self.window != nil) {
+    [_controller setNeedsPresentationUpdate];
+    [_controller flushPendingUpdates];
+  }
+}
+
+#pragma mark - RNSContainedModalContentControllerDelegate
+
+- (void)modalControllerViewDidLayoutSubviews:(RNSContainedModalContentController *)controller
+{
+  [self syncTouchHandlerOrigin];
+  [self syncShadowNodeState];
+}
+
+- (void)modalControllerViewDidDisappear:(RNSContainedModalContentController *)controller
+{
+  // The touch handler is attached to the controller's content view on present/layout
+  // Once the modal is dismissed, that content view is no longer on screen, so the
+  // handler must be detached.
+  [self detachTouchHandler];
+}
+
+#pragma mark - RNSContainedModalPresentationProvider
+
+- (nullable UIView *)hostView
+{
+  return self;
+}
+
+- (nullable UIWindow *)hostWindow
+{
+  return self.window;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateState:(const react::State::Shared &)state oldState:(const react::State::Shared &)oldState
+{
+  [super updateState:state oldState:oldState];
+  [_shadowStateProxy updateState:state oldState:oldState];
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSContainedModalHostComponentDescriptor>();
+}
+
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_controller.contentView insertReactSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_controller.contentView removeReactSubview:childComponentView];
+}
+
+- (void)updateProps:(const react::Props::Shared &)props oldProps:(const react::Props::Shared &)oldProps
+{
+  const auto &oldComponentProps = *std::static_pointer_cast<const react::RNSContainedModalHostProps>(_props);
+  const auto &newComponentProps = *std::static_pointer_cast<const react::RNSContainedModalHostProps>(props);
+
+  if (oldComponentProps.targetContainerId != newComponentProps.targetContainerId) {
+    _targetContainerId = RCTNSStringFromStringNilIfEmpty(newComponentProps.targetContainerId);
+  }
+
+  if (oldComponentProps.isOpen != newComponentProps.isOpen) {
+    _isOpen = static_cast<BOOL>(newComponentProps.isOpen);
+    [_controller setNeedsPresentationUpdate];
+  }
+
+  // TODO: determine if _controller setNeedsAppearance/BehaviorUpdate is necessary if _isOpen
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)invalidate
+{
+  [self detachTouchHandler];
+
+  if (_controller != nil) {
+    if (_controller.presentingViewController != nil) {
+      [_controller dismissViewControllerAnimated:NO completion:nil];
+    }
+    _controller = nil;
+  }
+}
+
+#pragma mark - RCTMountingTransactionObserving
+
+- (void)mountingTransactionDidMount:(const facebook::react::MountingTransaction &)transaction
+               withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
+{
+  [_controller flushPendingUpdates];
+}
+
+#pragma mark - Touch Handling overrides
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  // The modal's React children are teleported into the presented controller's
+  // content view (RNSContainedModalContentView), which has its own touch handler.
+  // This host view itself is an empty, zero-sized anchor in the React tree, so it
+  // must never be a hit-test target - returning nil lets touches pass through to
+  // whatever is actually behind it instead of being swallowed by this empty view.
+  return nil;
+}
+
+#pragma mark - Layout helpers
+
+- (void)syncShadowNodeState
+{
+  if (_controller == nil || _controller.contentView == nil) {
+    return;
+  }
+
+  // contentOriginOffset is the vector from the host view's origin to the content view's origin,
+  // both expressed in window space. It offsets child layout positions to account for the fact that
+  // React children are mounted in a separate UIViewController hierarchy.
+  CGPoint contentViewOriginInWindow = [_controller.contentView convertPoint:CGPointZero toView:nil];
+  CGPoint hostOriginInWindow = [self convertPoint:CGPointZero toView:nil];
+  CGPoint contentOriginOffset = CGPointMake(contentViewOriginInWindow.x - hostOriginInWindow.x,
+                                            contentViewOriginInWindow.y - hostOriginInWindow.y);
+
+  [_shadowStateProxy updateShadowStateWithBounds:_controller.contentView.bounds origin:contentOriginOffset];
+}
+
+#pragma mark - Touch Handling helpers
+
+- (void)syncTouchHandlerOrigin
+{
+  if (_controller == nil || _controller.contentView == nil) {
+    return;
+  }
+
+  // Touch handler requires absolute positioning coordinates, relatively to root (UIWindow)
+  CGPoint contentViewOriginInWindow = [_controller.contentView convertPoint:CGPointZero toView:nil];
+  [self updateTouchHandlerWithOrigin:contentViewOriginInWindow];
+}
+
+- (void)updateTouchHandlerWithOrigin:(CGPoint)origin
+{
+  if (_touchHandler == nil) {
+    _touchHandler = [RCTSurfaceTouchHandler new];
+    [_touchHandler attachToView:_controller.contentView];
+  }
+
+  // Aligns touch coordinate space with window coordinate space
+  _touchHandler.viewOriginOffset = origin;
+}
+
+- (void)detachTouchHandler
+{
+  if (_touchHandler != nil) {
+    [_touchHandler detachFromView:_controller.contentView];
+    _touchHandler = nil;
+  }
+}
+
+#pragma mark - Dynamic frameworks support
+
+#ifdef RCT_DYNAMIC_FRAMEWORKS
++ (void)load
+{
+  [super load];
+}
+#endif // RCT_DYNAMIC_FRAMEWORKS
+
+@end
+
+Class<RCTComponentViewProtocol> RNSContainedModalHostCls(void)
+{
+  return RNSContainedModalHostComponentView.class;
+}
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalHostShadowStateProxy.h b/ios/gamma/modals/contained-modal/RNSContainedModalHostShadowStateProxy.h
new file mode 100644
index 0000000000..d2c471002c
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalHostShadowStateProxy.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+#ifdef __cplusplus
+#import <React/RCTComponentViewProtocol.h>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalHostShadowStateProxy : NSObject
+
+#ifdef __cplusplus
+- (void)updateState:(facebook::react::State::Shared const &)state
+           oldState:(facebook::react::State::Shared const &)oldState;
+#endif
+
+- (void)updateShadowStateWithBounds:(CGRect)bounds origin:(CGPoint)origin;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalHostShadowStateProxy.mm b/ios/gamma/modals/contained-modal/RNSContainedModalHostShadowStateProxy.mm
new file mode 100644
index 0000000000..f242cf6a47
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalHostShadowStateProxy.mm
@@ -0,0 +1,44 @@
+#import "RNSContainedModalHostShadowStateProxy.h"
+
+#import <React/RCTConversions.h>
+#import <rnscreens/RNSContainedModalHostShadowNode.h>
+#import <rnscreens/RNSContainedModalHostState.h>
+
+namespace react = facebook::react;
+
+@implementation RNSContainedModalHostShadowStateProxy {
+  react::RNSContainedModalHostShadowNode::ConcreteState::Shared _state;
+  CGRect _lastScheduledFrame;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _lastScheduledFrame = CGRectNull;
+  }
+  return self;
+}
+
+- (void)updateState:(react::State::Shared const &)state oldState:(react::State::Shared const &)oldState
+{
+  _state = std::static_pointer_cast<const react::RNSContainedModalHostShadowNode::ConcreteState>(state);
+}
+
+- (void)updateShadowStateWithBounds:(CGRect)bounds origin:(CGPoint)origin
+{
+  if (_state == nullptr) {
+    return;
+  }
+
+  CGRect frame = {origin, bounds.size};
+
+  if (!CGRectEqualToRect(frame, _lastScheduledFrame)) {
+    auto newState = react::RNSContainedModalHostState{RCTSizeFromCGSize(bounds.size), RCTPointFromCGPoint(origin)};
+
+    _state->updateState(std::move(newState), facebook::react::EventQueue::UpdateMode::unstable_Immediate);
+
+    _lastScheduledFrame = frame;
+  }
+}
+
+@end
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalPresentationManager.h b/ios/gamma/modals/contained-modal/RNSContainedModalPresentationManager.h
new file mode 100644
index 0000000000..6cc2235c53
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalPresentationManager.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import "RNSContainedModalProviders.h"
+
+@class RNSContainedModalContentController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalPresentationManager : NSObject
+
+- (void)updatePresentationIfNeededWithProvider:(id<RNSContainedModalPresentationProvider>)provider
+                                    controller:(RNSContainedModalContentController *)controller;
+
+- (void)handleNativeDismiss;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalPresentationManager.mm b/ios/gamma/modals/contained-modal/RNSContainedModalPresentationManager.mm
new file mode 100644
index 0000000000..eeb46a88d9
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalPresentationManager.mm
@@ -0,0 +1,131 @@
+#import "RNSContainedModalPresentationManager.h"
+#import "RNSContainedModalContentController.h"
+#import "RNSContainedModalPresentationState.h"
+#import "RNSContainedModalProviderComponentView.h"
+
+#import <React/RCTAssert.h>
+
+@implementation RNSContainedModalPresentationManager {
+  RNSContainedModalPresentationState _state;
+  __weak RNSContainedModalProviderComponentView *_cachedProviderView;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _state = RNSContainedModalPresentationStateDismissed;
+  }
+  return self;
+}
+
+- (void)updatePresentationIfNeededWithProvider:(id<RNSContainedModalPresentationProvider>)provider
+                                    controller:(RNSContainedModalContentController *)controller
+{
+  BOOL shouldBeOpen = provider.isOpen;
+
+  if (shouldBeOpen) {
+    [self presentIfNeededWithProvider:provider controller:controller];
+  } else {
+    [self dismissIfNeededWithProvider:provider controller:controller];
+  }
+}
+
+#pragma mark - Provider resolution
+
+// A contained modal is presented from the provider whose `containerId` matches the
+// modal's `targetContainerId`, so it stays contained within that provider's bounds.
+- (nullable RNSContainedModalProviderComponentView *)findProviderViewForProvider:
+    (id<RNSContainedModalPresentationProvider>)provider
+{
+  NSString *targetContainerId = [provider targetContainerId];
+
+  if (targetContainerId == nil) {
+    RCTAssert(NO, @"[RNScreens] ContainedModal has a nil targetContainerId; cannot resolve a provider to present in.");
+    return nil;
+  }
+
+  UIView *currentView = [provider hostView];
+  while (currentView != nil) {
+    if ([currentView isKindOfClass:[RNSContainedModalProviderComponentView class]]) {
+      RNSContainedModalProviderComponentView *providerView = (RNSContainedModalProviderComponentView *)currentView;
+
+      if ([targetContainerId isEqualToString:providerView.containerId]) {
+        return providerView;
+      }
+    }
+    currentView = currentView.superview;
+  }
+
+  RCTAssert(NO, @"[RNScreens] No ContainedModalProvider found matching targetContainerId '%@'.", targetContainerId);
+  return nil;
+}
+
+- (void)presentIfNeededWithProvider:(id<RNSContainedModalPresentationProvider>)provider
+                         controller:(RNSContainedModalContentController *)controller
+{
+  if (_state != RNSContainedModalPresentationStateDismissed) {
+    return;
+  }
+
+  // This resolves the provider only once - on the first presentation.
+  // The provider is an ancestor of the ContainedModal in the React tree, so it cannot
+  // be unmounted without also unmounting the modal.
+  if (_cachedProviderView == nil) {
+    _cachedProviderView = [self findProviderViewForProvider:provider];
+  }
+
+  UIViewController *presentationSourceViewController = _cachedProviderView.contextViewController;
+  if (presentationSourceViewController == nil) {
+    return;
+  }
+
+  _state = RNSContainedModalPresentationStatePresenting;
+
+  __weak auto weakSelf = self;
+  [presentationSourceViewController presentViewController:controller
+                                                 animated:YES
+                                               completion:^{
+                                                 auto strongSelf = weakSelf;
+                                                 if (!strongSelf) {
+                                                   return;
+                                                 }
+
+                                                 strongSelf->_state = RNSContainedModalPresentationStatePresented;
+                                                 [strongSelf updatePresentationIfNeededWithProvider:provider
+                                                                                         controller:controller];
+                                               }];
+}
+
+- (void)dismissIfNeededWithProvider:(id<RNSContainedModalPresentationProvider>)provider
+                         controller:(RNSContainedModalContentController *)controller
+{
+  if (_state != RNSContainedModalPresentationStatePresented) {
+    return;
+  }
+
+  if (controller.presentingViewController == nil) {
+    _state = RNSContainedModalPresentationStateDismissed;
+    return;
+  }
+
+  _state = RNSContainedModalPresentationStateDismissing;
+
+  __weak auto weakSelf = self;
+  [controller dismissViewControllerAnimated:YES
+                                 completion:^{
+                                   auto strongSelf = weakSelf;
+                                   if (!strongSelf) {
+                                     return;
+                                   }
+
+                                   strongSelf->_state = RNSContainedModalPresentationStateDismissed;
+                                   [strongSelf updatePresentationIfNeededWithProvider:provider controller:controller];
+                                 }];
+}
+
+- (void)handleNativeDismiss
+{
+  _state = RNSContainedModalPresentationStateDismissed;
+}
+
+@end
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalPresentationState.h b/ios/gamma/modals/contained-modal/RNSContainedModalPresentationState.h
new file mode 100644
index 0000000000..5dae190bc3
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalPresentationState.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RNSContainedModalPresentationState) {
+  RNSContainedModalPresentationStateDismissed,
+  RNSContainedModalPresentationStateDismissing,
+  RNSContainedModalPresentationStatePresented,
+  RNSContainedModalPresentationStatePresenting
+};
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalProviderComponentView.h b/ios/gamma/modals/contained-modal/RNSContainedModalProviderComponentView.h
new file mode 100644
index 0000000000..a869865c0a
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalProviderComponentView.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+#import "RNSReactBaseView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalProviderComponentView : RNSReactBaseView
+
+@property (nonatomic, strong, readonly) UIViewController *contextViewController;
+
+// Identifies this provider (container). A `ContainedModal` is presented in the
+// provider whose `containerId` matches the modal's `targetContainerId`.
+// `nil` when unset.
+@property (nonatomic, copy, readonly, nullable) NSString *containerId;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalProviderComponentView.mm b/ios/gamma/modals/contained-modal/RNSContainedModalProviderComponentView.mm
new file mode 100644
index 0000000000..5637d91f0a
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalProviderComponentView.mm
@@ -0,0 +1,117 @@
+#import "RNSContainedModalProviderComponentView.h"
+#import "RNSContainedModalProviderController.h"
+
+#import <React/RCTConversions.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
+#import <react/renderer/components/rnscreens/Props.h>
+
+namespace react = facebook::react;
+
+@interface RNSContainedModalProviderComponentView ()
+@property (nonatomic, copy, readwrite, nullable) NSString *containerId;
+@end
+
+@implementation RNSContainedModalProviderComponentView
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const react::RNSContainedModalProviderProps>();
+    _props = defaultProps;
+
+    _contextViewController = [[RNSContainedModalProviderController alloc] init];
+  }
+  return self;
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  _contextViewController.view.frame = self.bounds;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+
+  if (self.window != nil) {
+    [self reactAddControllerToClosestParent:_contextViewController];
+  } else {
+    // When the host leaves the window (e.g. navigating back), detach the controller
+    // from its parent. Otherwise it keeps a stale parentViewController pointing at the
+    // already-removed screen controller, and on the next mount it would be presented
+    // from a detached view controller - producing a corrupt, mis-sized presentation.
+    [self reactRemoveControllerFromParent:_contextViewController];
+  }
+}
+
+- (void)reactAddControllerToClosestParent:(UIViewController *)controller
+{
+  if (controller.parentViewController != nil) {
+    return;
+  }
+
+  UIView *parentView = (UIView *)self.reactSuperview;
+  while (parentView != nil) {
+    if (parentView.reactViewController != nil) {
+      [parentView.reactViewController addChildViewController:controller];
+      [self addSubview:controller.view];
+      [controller didMoveToParentViewController:parentView.reactViewController];
+      break;
+    }
+    parentView = (UIView *)parentView.reactSuperview;
+  }
+}
+
+- (void)reactRemoveControllerFromParent:(UIViewController *)controller
+{
+  if (controller.parentViewController == nil) {
+    return;
+  }
+
+  [controller willMoveToParentViewController:nil];
+  [controller.view removeFromSuperview];
+  [controller removeFromParentViewController];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSContainedModalProviderComponentDescriptor>();
+}
+
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_contextViewController.view insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateProps:(const react::Props::Shared &)props oldProps:(const react::Props::Shared &)oldProps
+{
+  const auto &oldComponentProps = *std::static_pointer_cast<const react::RNSContainedModalProviderProps>(_props);
+  const auto &newComponentProps = *std::static_pointer_cast<const react::RNSContainedModalProviderProps>(props);
+
+  if (oldComponentProps.containerId != newComponentProps.containerId) {
+    self.containerId = RCTNSStringFromStringNilIfEmpty(newComponentProps.containerId);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNSContainedModalProviderCls(void)
+{
+  return RNSContainedModalProviderComponentView.class;
+}
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalProviderController.h b/ios/gamma/modals/contained-modal/RNSContainedModalProviderController.h
new file mode 100644
index 0000000000..6c62bcc56f
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalProviderController.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalProviderController : UIViewController
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalProviderController.mm b/ios/gamma/modals/contained-modal/RNSContainedModalProviderController.mm
new file mode 100644
index 0000000000..6282e142e1
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalProviderController.mm
@@ -0,0 +1,20 @@
+#import "RNSContainedModalProviderController.h"
+
+@implementation RNSContainedModalProviderController
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.definesPresentationContext = YES;
+  }
+  return self;
+}
+
+- (void)loadView
+{
+  UIView *view = [[UIView alloc] init];
+  view.backgroundColor = [UIColor clearColor];
+  self.view = view;
+}
+
+@end
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalProviders.h b/ios/gamma/modals/contained-modal/RNSContainedModalProviders.h
new file mode 100644
index 0000000000..ff27027236
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalProviders.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RNSContainedModalPresentationProvider <NSObject>
+
+- (BOOL)isOpen;
+- (nullable UIView *)hostView;
+- (nullable UIWindow *)hostWindow;
+
+// The id of the container (provider) this modal should be presented in.
+// Matched against `RNSContainedModalProviderComponentView.containerId`.
+- (nullable NSString *)targetContainerId;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalUpdateCoordinator.h b/ios/gamma/modals/contained-modal/RNSContainedModalUpdateCoordinator.h
new file mode 100644
index 0000000000..f11e87d707
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalUpdateCoordinator.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+#import "RNSContainedModalUpdateFlags.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSContainedModalUpdateCoordinator : NSObject
+
+- (void)setNeeds:(RNSContainedModalUpdateFlags)flags;
+
+- (BOOL)needsAll:(RNSContainedModalUpdateFlags)flags;
+- (BOOL)needsAny:(RNSContainedModalUpdateFlags)flags;
+
+- (void)updateIfNeeded:(RNSContainedModalUpdateFlags)flags performOperations:(dispatch_block_t)block;
+- (void)updateIfAnyNeeded:(RNSContainedModalUpdateFlags)flags performOperations:(dispatch_block_t)block;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalUpdateCoordinator.mm b/ios/gamma/modals/contained-modal/RNSContainedModalUpdateCoordinator.mm
new file mode 100644
index 0000000000..038ce5943a
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalUpdateCoordinator.mm
@@ -0,0 +1,52 @@
+#import "RNSContainedModalUpdateCoordinator.h"
+
+@implementation RNSContainedModalUpdateCoordinator {
+  RNSContainedModalUpdateFlags _updateFlags;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _updateFlags = RNSContainedModalUpdateFlagsNone;
+  }
+  return self;
+}
+
+- (void)setNeeds:(RNSContainedModalUpdateFlags)flags
+{
+  _updateFlags |= flags;
+}
+
+- (BOOL)needsAll:(RNSContainedModalUpdateFlags)flags
+{
+  if (flags == RNSContainedModalUpdateFlagsNone) {
+    return NO;
+  }
+  return (_updateFlags & flags) == flags;
+}
+
+- (BOOL)needsAny:(RNSContainedModalUpdateFlags)flags
+{
+  if (flags == RNSContainedModalUpdateFlagsNone) {
+    return NO;
+  }
+  return (_updateFlags & flags) != 0;
+}
+
+- (void)updateIfNeeded:(RNSContainedModalUpdateFlags)flags performOperations:(dispatch_block_t)block
+{
+  if ([self needsAll:flags]) {
+    block();
+    _updateFlags &= ~flags;
+  }
+}
+
+- (void)updateIfAnyNeeded:(RNSContainedModalUpdateFlags)flags performOperations:(dispatch_block_t)block
+{
+  if ([self needsAny:flags]) {
+    block();
+    _updateFlags &= ~flags;
+  }
+}
+
+@end
diff --git a/ios/gamma/modals/contained-modal/RNSContainedModalUpdateFlags.h b/ios/gamma/modals/contained-modal/RNSContainedModalUpdateFlags.h
new file mode 100644
index 0000000000..754ff7aeea
--- /dev/null
+++ b/ios/gamma/modals/contained-modal/RNSContainedModalUpdateFlags.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+typedef NS_OPTIONS(NSUInteger, RNSContainedModalUpdateFlags) {
+  RNSContainedModalUpdateFlagsNone = 0,
+  // The modal needs to be presented or dismissed to match the requested open state.
+  RNSContainedModalUpdateFlagsPresentation = 1 << 0,
+  // The modal's visual appearance configuration needs to be re-applied.
+  RNSContainedModalUpdateFlagsAppearance = 1 << 1,
+  // The modal's behavioral layout needs to be re-applied.
+  RNSContainedModalUpdateFlagsBehavior = 1 << 2,
+};
diff --git a/ios/stubs/RNSGammaStubs.h b/ios/stubs/RNSGammaStubs.h
index ce49c9ae03..18392735cd 100644
--- a/ios/stubs/RNSGammaStubs.h
+++ b/ios/stubs/RNSGammaStubs.h
@@ -27,6 +27,12 @@ NS_ASSUME_NONNULL_BEGIN
 @interface RNSFormSheetHostComponentView : NSObject
 @end
 
+@interface RNSContainedModalHostComponentView : NSObject
+@end
+
+@interface RNSContainedModalProviderHostComponentView : NSObject
+@end
+
 @interface RNSStackHeaderConfigComponentView : NSObject
 @end
 
diff --git a/ios/stubs/RNSGammaStubs.mm b/ios/stubs/RNSGammaStubs.mm
index 7b168c4892..a4fcd4a392 100644
--- a/ios/stubs/RNSGammaStubs.mm
+++ b/ios/stubs/RNSGammaStubs.mm
@@ -18,6 +18,12 @@ @implementation RNSScrollViewMarkerComponentView
 @implementation RNSFormSheetHostComponentView
 @end
 
+@implementation RNSContainedModalHostComponentView
+@end
+
+@implementation RNSContainedModalProviderComponentView
+@end
+
 @implementation RNSFormSheetContentWrapperComponentView
 @end
 
diff --git a/package.json b/package.json
index d0267a5ec4..3fa51be96e 100644
--- a/package.json
+++ b/package.json
@@ -235,6 +235,12 @@
         },
         "RNSFormSheetContentWrapper": {
           "className": "RNSFormSheetContentWrapperComponentView"
+        },
+        "RNSContainedModalHost": {
+          "className": "RNSContainedModalHostComponentView"
+        },
+        "RNSContainedModalProvider": {
+          "className": "RNSContainedModalProviderComponentView"
         }
       }
     }
diff --git a/src/components/gamma/modals/contained-modal/ContainedModal.android.tsx b/src/components/gamma/modals/contained-modal/ContainedModal.android.tsx
new file mode 100644
index 0000000000..a6e9456971
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModal.android.tsx
@@ -0,0 +1,9 @@
+import warnOnce from 'warn-once';
+
+export const ContainedModal = () => {
+  warnOnce(
+    true,
+    '[RNScreens] As of now, ContainedModal component is supported only for iOS.',
+  );
+  return null;
+};
diff --git a/src/components/gamma/modals/contained-modal/ContainedModal.tsx b/src/components/gamma/modals/contained-modal/ContainedModal.tsx
new file mode 100644
index 0000000000..f024d51a99
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModal.tsx
@@ -0,0 +1,30 @@
+import React from 'react';
+import type { ContainedModalProps } from './ContainedModal.types';
+import ContainedModalHostNativeComponent from '../../../../fabric/gamma/modals/contained-modal/ContainedModalHostNativeComponent';
+import { StyleSheet } from 'react-native';
+
+export function ContainedModal(props: ContainedModalProps) {
+  const { children, ...rest } = props;
+
+  return (
+    <ContainedModalHostNativeComponent {...rest} style={styles.host}>
+      {children}
+    </ContainedModalHostNativeComponent>
+  );
+}
+
+const styles = StyleSheet.create({
+  // We use absolute positioning so the Host view doesn't affect the layout of its siblings.
+  // Setting `top: 0` and `left: 0` explicitly anchors the view to a predictable origin,
+  // preventing it from floating at an arbitrary offset based on its position in the Element tree.
+  //
+  // IMPORTANT: "Absolute" positioning is still relative to the nearest positioned containing
+  // box. This anchors it to that specific container's (0,0), not the global window (0,0).
+  host: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    width: 0,
+    height: 0,
+  },
+});
diff --git a/src/components/gamma/modals/contained-modal/ContainedModal.types.ts b/src/components/gamma/modals/contained-modal/ContainedModal.types.ts
new file mode 100644
index 0000000000..0abcad7e8e
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModal.types.ts
@@ -0,0 +1,25 @@
+import type { ViewProps } from 'react-native';
+
+export interface ContainedModalProps {
+  children?: ViewProps['children'] | undefined;
+  /**
+   * @summary Determines whether the contained modal is currently visible.
+   *
+   * Presentation is driven by state transitions: updating this property
+   * from `false` to `true` triggers the modal to present, while changing
+   * it from `true` to `false` triggers a programmatic dismissal.
+   *
+   * @platform ios
+   */
+  isOpen: boolean;
+  /**
+   * @summary Selects which `ContainedModalProvider` this modal is presented in.
+   *
+   * The modal is matched to a provider by comparing this `targetContainerId`
+   * against the provider's `containerId`. The modal is presented within the
+   * bounds of the provider whose `containerId` equals this value.
+   *
+   * @platform ios
+   */
+  targetContainerId: string;
+}
diff --git a/src/components/gamma/modals/contained-modal/ContainedModal.web.tsx b/src/components/gamma/modals/contained-modal/ContainedModal.web.tsx
new file mode 100644
index 0000000000..a6e9456971
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModal.web.tsx
@@ -0,0 +1,9 @@
+import warnOnce from 'warn-once';
+
+export const ContainedModal = () => {
+  warnOnce(
+    true,
+    '[RNScreens] As of now, ContainedModal component is supported only for iOS.',
+  );
+  return null;
+};
diff --git a/src/components/gamma/modals/contained-modal/ContainedModalProvider.android.tsx b/src/components/gamma/modals/contained-modal/ContainedModalProvider.android.tsx
new file mode 100644
index 0000000000..a866676e3b
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModalProvider.android.tsx
@@ -0,0 +1,9 @@
+import warnOnce from 'warn-once';
+
+export const ContainedModalProvider = () => {
+  warnOnce(
+    true,
+    '[RNScreens] As of now, ContainedModalProvider component is supported only for iOS.',
+  );
+  return null;
+};
diff --git a/src/components/gamma/modals/contained-modal/ContainedModalProvider.tsx b/src/components/gamma/modals/contained-modal/ContainedModalProvider.tsx
new file mode 100644
index 0000000000..cb04602292
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModalProvider.tsx
@@ -0,0 +1,13 @@
+import React from 'react';
+import ContainedModalProviderNativeComponent from '../../../../fabric/gamma/modals/contained-modal/ContainedModalProviderNativeComponent';
+import type { ContainedModalProviderProps } from './ContainedModalProvider.types';
+
+export function ContainedModalProvider(props: ContainedModalProviderProps) {
+  const { children, style, ...rest } = props;
+
+  return (
+    <ContainedModalProviderNativeComponent style={style} {...rest}>
+      {children}
+    </ContainedModalProviderNativeComponent>
+  );
+}
diff --git a/src/components/gamma/modals/contained-modal/ContainedModalProvider.types.ts b/src/components/gamma/modals/contained-modal/ContainedModalProvider.types.ts
new file mode 100644
index 0000000000..3aace6d13c
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModalProvider.types.ts
@@ -0,0 +1,26 @@
+import type { StyleProp, ViewProps, ViewStyle } from 'react-native';
+
+export interface ContainedModalProviderProps {
+  children?: ViewProps['children'] | undefined;
+  /**
+   * @summary Style applied to the provider's host view.
+   *
+   * The provider is a regular, space-filling container whose bounds define the
+   * area within which a matched `ContainedModal` is presented, so its size is
+   * configurable - unlike `ContainedModal`, whose host is a zero-sized logical anchor.
+   *
+   * @platform ios
+   */
+  style?: StyleProp<ViewStyle> | undefined;
+  /**
+   * @summary Identifies this provider so a `ContainedModal` can target it.
+   *
+   * A `ContainedModal` is matched to its provider by comparing this
+   * `containerId` against the modal's `targetContainerId`. The modal is
+   * presented within the bounds of the provider whose `containerId` equals
+   * the modal's `targetContainerId`.
+   *
+   * @platform ios
+   */
+  containerId: string;
+}
diff --git a/src/components/gamma/modals/contained-modal/ContainedModalProvider.web.tsx b/src/components/gamma/modals/contained-modal/ContainedModalProvider.web.tsx
new file mode 100644
index 0000000000..a866676e3b
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/ContainedModalProvider.web.tsx
@@ -0,0 +1,9 @@
+import warnOnce from 'warn-once';
+
+export const ContainedModalProvider = () => {
+  warnOnce(
+    true,
+    '[RNScreens] As of now, ContainedModalProvider component is supported only for iOS.',
+  );
+  return null;
+};
diff --git a/src/components/gamma/modals/contained-modal/index.ts b/src/components/gamma/modals/contained-modal/index.ts
new file mode 100644
index 0000000000..f1481ea45b
--- /dev/null
+++ b/src/components/gamma/modals/contained-modal/index.ts
@@ -0,0 +1,5 @@
+export type { ContainedModalProps } from './ContainedModal.types';
+export type { ContainedModalProviderProps } from './ContainedModalProvider.types';
+
+export { ContainedModal } from './ContainedModal';
+export { ContainedModalProvider } from './ContainedModalProvider';
diff --git a/src/experimental/index.ts b/src/experimental/index.ts
index 8e508a2a7b..9245c06b7f 100644
--- a/src/experimental/index.ts
+++ b/src/experimental/index.ts
@@ -10,3 +10,4 @@ export * from '../components/gamma/split';
 export * from '../components/safe-area';
 export * from '../components/gamma/scroll-view-marker';
 export * from '../components/gamma/modals/form-sheet';
+export * from '../components/gamma/modals/contained-modal';
diff --git a/src/fabric/gamma/modals/contained-modal/ContainedModalHostNativeComponent.ts b/src/fabric/gamma/modals/contained-modal/ContainedModalHostNativeComponent.ts
new file mode 100644
index 0000000000..4d76e45ece
--- /dev/null
+++ b/src/fabric/gamma/modals/contained-modal/ContainedModalHostNativeComponent.ts
@@ -0,0 +1,14 @@
+'use client';
+
+import { codegenNativeComponent } from 'react-native';
+import type { CodegenTypes as CT, ViewProps } from 'react-native';
+
+export interface NativeProps extends ViewProps {
+  isOpen?: CT.WithDefault<boolean, false>;
+  targetContainerId?: CT.WithDefault<string, ''>;
+}
+
+export default codegenNativeComponent<NativeProps>('RNSContainedModalHost', {
+  interfaceOnly: true,
+  excludedPlatforms: ['android'],
+});
diff --git a/src/fabric/gamma/modals/contained-modal/ContainedModalProviderNativeComponent.ts b/src/fabric/gamma/modals/contained-modal/ContainedModalProviderNativeComponent.ts
new file mode 100644
index 0000000000..5d1e0ab2cb
--- /dev/null
+++ b/src/fabric/gamma/modals/contained-modal/ContainedModalProviderNativeComponent.ts
@@ -0,0 +1,15 @@
+'use client';
+
+import { codegenNativeComponent } from 'react-native';
+import type { CodegenTypes as CT, ViewProps } from 'react-native';
+
+export interface NativeProps extends ViewProps {
+  containerId?: CT.WithDefault<string, ''>;
+}
+
+export default codegenNativeComponent<NativeProps>(
+  'RNSContainedModalProvider',
+  {
+    excludedPlatforms: ['android'],
+  },
+);