diff --git a/packages/session-replay-react-native/README.md b/packages/session-replay-react-native/README.md
index 831187f7e..1e0cd9ec3 100644
--- a/packages/session-replay-react-native/README.md
+++ b/packages/session-replay-react-native/README.md
@@ -21,12 +21,11 @@ the SDK keeps working on older React Native versions on the legacy architecture.
 The TurboModule code path is compiled only when the New Architecture is enabled,
 which itself requires React Native 0.74 or newer.
 
-### Fabric foundation (internal)
+### Fabric-based masking
 
-This release includes internal groundwork for an upcoming layout-transparent
-masking component built on Fabric. The component is currently inert: it is not
-part of the public API, exposes nothing new to call, and does not change any
-masking behavior.
+The layout-transparent masking components (`AmpMask` / `AmpUnmask`, see
+[Layout-transparent masking](#layout-transparent-masking-with-ampmask--ampunmask-experimental))
+are built on Fabric.
 
 The Fabric/C++ sources compile only on the New Architecture with React Native
 0.77 or newer (they rely on capabilities that exist only in those versions).
@@ -116,6 +115,105 @@ import { AmpMaskView } from '@amplitude/session-replay-react-native';
 </AmpMaskView>;
 ```
 
+## Layout-transparent masking with `AmpMask` / `AmpUnmask` (Experimental)
+
+> **@experimental** — this API is new and may change in a future release.
+
+`AmpMaskView` wraps its children in an extra native view, which introduces a
+layout boundary: children that depend on their parent for sizing (`flex: 1`,
+percentage heights, `position: 'absolute'`) can shift or collapse to zero.
+`AmpMask` and `AmpUnmask` are layout-transparent replacements: they mark their
+children as masked/unmasked in the replay without affecting layout at all —
+wrapping content in `<AmpMask>` renders pixel-identical to not wrapping it.
+
+### Requirements
+
+`AmpMask`/`AmpUnmask` require React Native **0.77 or newer** with the
+**New Architecture** enabled (Fabric) **with bridgeless enabled** (the RN
+0.77 default). On Fabric without bridgeless (bridge mode) — as well as on
+the Old Architecture — they are not supported as a layout-transparent path:
+
+- On the Old Architecture, in development they throw with a clear error;
+  in production they fall back to `AmpMaskView` and log a one-time
+  `console.error`.
+- On Fabric without bridgeless (bridge mode), they never throw — they
+  always fall back to `AmpMaskView` and log a one-time `console.error`,
+  in both development and production (bridge-mode Fabric cannot detect
+  `SRMaskView` on iOS).
+- Both fallbacks **ignore `enabled`** — wrapped content stays masked
+  regardless (it fails toward privacy). Neither is layout-transparent —
+  the `AmpMaskView` layout caveats above apply. Use `AmpMaskView`
+  directly outside the bridgeless-Fabric path.
+
+### Caveats
+
+- `style` is not supported on `<AmpMask>`/`<AmpUnmask>` — they never occupy
+  layout, so there is no box to style. Style your children directly instead.
+- `enabled` is only honored on the layout-transparent Fabric path — all
+  fallback paths (Old Architecture, Fabric bridge-mode, and the
+  build-misconfiguration cases below) ignore it and keep content masked
+  regardless (they fail toward privacy).
+- If the New Architecture is active but the native `SRMaskView` component is
+  missing — including on Fabric without bridgeless, which cannot detect
+  `SRMaskView` on iOS and always falls back — `<AmpMask>`/`<AmpUnmask>` log a
+  one-time `console.error` and fall back to `<AmpMaskView>` — content stays
+  **masked**, but layout-transparency is lost. Treat that log as a build
+  error to fix, not a warning to ignore.
+- On the **New Architecture**, if the package's native code is absent
+  entirely (so Session Replay cannot record at all), `<AmpMask>`/`<AmpUnmask>`
+  log a one-time `console.error` and render children directly. If instead the
+  native module is present but neither masking component is registered (an
+  unexpected build error), they throw in development and log a distinct
+  one-time `console.error` in production instead of silently passing content
+  through. On the **Old Architecture** with the native code absent, rendering
+  fails at `requireNativeComponent` like any other native component — there
+  is no silent passthrough.
+
+### Usage
+
+```tsx
+import { AmpMask, AmpUnmask } from '@amplitude/session-replay-react-native';
+
+// Mask: children are masked in the replay, layout is unchanged.
+<AmpMask>
+  <View style={{ flex: 1 }}>
+    <Text>{accountNumber}</Text>
+  </View>
+</AmpMask>
+
+// Block: fully block the subtree from the replay.
+<AmpMask maskLevel="block">
+  <CreditCardForm />
+</AmpMask>
+
+// Unmask: opt content back in to the replay.
+<AmpUnmask>
+  <Text>Public banner</Text>
+</AmpUnmask>
+```
+
+`AmpMask` props:
+
+| Prop | Type | Default | Description |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `true` | When `false`, children render without masking. |
+| `maskLevel` | `'mask' \| 'block'` | `'mask'` | Masking level applied to the children. On iOS, `mask` and `block` currently behave identically (both fully block). |
+
+`AmpUnmask` takes no masking props — it always unmasks its children.
+
+### Migrating from `AmpMaskView`
+
+| Before | After |
+| --- | --- |
+| `<AmpMaskView mask="amp-mask">` | `<AmpMask>` |
+| `<AmpMaskView mask="amp-block">` | `<AmpMask maskLevel="block">` |
+| `<AmpMaskView mask="amp-unmask">` | `<AmpUnmask>` |
+
+`AmpMaskView` remains supported on both architectures. Prefer
+`AmpMask`/`AmpUnmask` on the New Architecture, especially around children that
+are sized by their parent (`flex: 1`, percentage heights, absolute
+positioning).
+
 ## Tracking Web Views (Beta)
 
 Web views are blocked by default and will not be tracked. If you'd like webviews to be tracked, you can manually unmask
diff --git a/packages/session-replay-react-native/android/src/androidTest/java/com/amplitude/sessionreplayreactnative/SRMaskViewTest.kt b/packages/session-replay-react-native/android/src/androidTest/java/com/amplitude/sessionreplayreactnative/SRMaskViewTest.kt
index 5ebdbcf71..1390b67ac 100644
--- a/packages/session-replay-react-native/android/src/androidTest/java/com/amplitude/sessionreplayreactnative/SRMaskViewTest.kt
+++ b/packages/session-replay-react-native/android/src/androidTest/java/com/amplitude/sessionreplayreactnative/SRMaskViewTest.kt
@@ -4,14 +4,18 @@ import android.content.Context
 import android.view.View
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
+import com.amplitude.android.sessionreplay.SessionReplay
 import com.amplitude.sessionreplayreactnative.fabric.SRMaskView
 import com.amplitude.sessionreplayreactnative.fabric.SRMaskViewManager
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertSame
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
+import com.facebook.react.uimanager.PointerEvents
 import org.junit.runner.RunWith
 
 /**
@@ -210,11 +214,15 @@ class SRMaskViewTest {
     assertEquals("childless host height should stay 0", 0, host.height)
   }
 
-  // 4c. Regression: Fabric lays the degenerate display:contents host out at a
-  //     NON-ZERO parent offset. The host must widen to the children's size WITHOUT
-  //     moving — children are host-relative, so moving the host shifts them in
-  //     absolute space (breaks layout neutrality) and mixing the host's parent-space
-  //     frame with the children's host-space frames also miscomputes the size.
+  // 4c. Regression (measured on-device, RN 0.77.2 Fabric): Fabric lays the
+  //     degenerate display:contents host out at a NON-ZERO parent offset
+  //     (flattened intermediate views accumulate into the host origin — e.g.
+  //     an AmpUnmask nested in an AmpMask through a flattened <View>, or a
+  //     mask inside a list row) and the children frames are HOST-relative
+  //     (a child renders at host.left + child.left). The host must widen to
+  //     origin + children extent WITHOUT moving; treating the child extents
+  //     as absolute (a previous revision) produced inverted frames
+  //     (bottom < top) that the capture gate dropped.
   @Test
   fun degenerateHostFrame_atNonZeroOffset_widensWithoutMoving() {
     lateinit var host: SRMaskView
@@ -224,19 +232,80 @@ class SRMaskViewTest {
       val b = View(context)
       host.addView(a)
       host.addView(b)
-      // Children laid out in the host's OWN (host-relative) coordinate space.
+      // Children laid out HOST-relative — as measured from Fabric.
       a.layout(0, 0, 100, 50)
       b.layout(120, 60, 200, 140)
       // Fabric places the 0x0 display:contents host at a non-zero parent offset.
       host.layout(300, 400, 300, 400)
     }
 
-    // Size == children union (200x140), independent of the host's parent offset.
+    // Extent == origin + children union max right/bottom → (300,400,500,540).
     assertEquals("union width at offset", 200, host.width)
     assertEquals("union height at offset", 140, host.height)
     // Position preserved — the host was NOT moved (else children shift absolutely).
     assertEquals("host left preserved", 300, host.left)
     assertEquals("host top preserved", 400, host.top)
+    // Never inverted: bottom/right beyond origin.
+    assertTrue("frame not inverted", host.bottom > host.top && host.right > host.left)
+  }
+
+  // 4d. A child at fully negative host-relative coordinates (e.g. the
+  //     negative-offset badge shape) cannot be enclosed without moving the
+  //     origin (forbidden). The frame must still never be degenerate or
+  //     inverted — clamp to a 1x1 minimum so shouldCapture() keeps the
+  //     subtree.
+  @Test
+  fun degenerateHostFrame_withFullyNegativeChild_clampsToOnePixel() {
+    lateinit var host: SRMaskView
+    onMain {
+      host = SRMaskView(context)
+      val a = View(context)
+      host.addView(a)
+      a.layout(-50, -60, -10, -20) // entirely above/left of the host origin
+      host.layout(74, 3018, 74, 3018)
+    }
+
+    assertEquals("clamped width", 1, host.width)
+    assertEquals("clamped height", 1, host.height)
+    assertEquals("host left preserved", 74, host.left)
+    assertEquals("host top preserved", 3018, host.top)
+  }
+
+  // 4e. Nested-mask shape (AmpUnmask host inside an AmpMask host): the inner
+  //     host sits at a non-zero offset inside the outer host with its own
+  //     host-relative children; the outer host's union must enclose the
+  //     inner host's WIDENED frame. Mirrors the measured Mask-screen nesting
+  //     (outer at (0,0,0,0); inner fabric frame (32,2016,32,2016), inner
+  //     child (0,124,1017,175)).
+  @Test
+  fun nestedHosts_outerEnclosesInnerWidenedFrame() {
+    lateinit var outer: SRMaskView
+    lateinit var inner: SRMaskView
+    onMain {
+      outer = SRMaskView(context)
+      inner = SRMaskView(context)
+      val innerChild = View(context)
+      val outerText = View(context)
+      outer.addView(outerText)
+      outer.addView(inner)
+      inner.addView(innerChild)
+      outerText.layout(32, 2047, 1049, 2098) // host-relative to outer
+      innerChild.layout(0, 124, 1017, 175) // host-relative to inner
+      inner.layout(32, 2016, 32, 2016) // Fabric's degenerate offset frame
+      outer.layout(0, 0, 0, 0)
+    }
+
+    // Inner: origin + child extent = (32,2016,1049,2191), never inverted.
+    assertEquals("inner left", 32, inner.left)
+    assertEquals("inner top", 2016, inner.top)
+    assertEquals("inner width", 1017, inner.width)
+    assertEquals("inner height", 175, inner.height)
+    // Outer: encloses max(outerText.right, inner.right)=1049 and
+    // max(outerText.bottom, inner.bottom)=2191 from its (0,0) origin.
+    assertEquals("outer width", 1049, outer.width)
+    assertEquals("outer height", 2191, outer.height)
+    assertTrue("outer capture gate", outer.width > 0 && outer.height > 0)
+    assertTrue("inner capture gate", inner.width > 0 && inner.height > 0)
   }
 
   // 5. Dropping the host detaches each child's layout listener, so a child that is
@@ -307,4 +376,84 @@ class SRMaskViewTest {
       masksForSomeView.single().level,
     )
   }
+
+  // 7. Default primitive mapping (Task 2.6): [SRDefaultMaskingPrimitive] bridges
+  //    the seam to the Session Replay SDK's tag-based hooks. Each level is
+  //    compared against a control view driven through the SDK static directly,
+  //    so the tests don't depend on the SDK's internal tag constants.
+  @Test
+  fun defaultPrimitive_maskLevelMask_matchesSdkMask() {
+    val primitive = SRDefaultMaskingPrimitive()
+    lateinit var view: View
+    lateinit var control: View
+    onMain {
+      view = View(context)
+      control = View(context)
+      primitive.mask(view, "mask")
+      SessionReplay.mask(control)
+    }
+
+    assertNotNull("SDK mask should set a tag on the control view", control.tag)
+    assertEquals("mask(\"mask\") must apply the SDK's mask tag", control.tag, view.tag)
+  }
+
+  @Test
+  fun defaultPrimitive_maskLevelBlock_matchesSdkBlock() {
+    val primitive = SRDefaultMaskingPrimitive()
+    lateinit var view: View
+    lateinit var control: View
+    onMain {
+      view = View(context)
+      control = View(context)
+      primitive.mask(view, "block")
+      SessionReplay.block(control)
+    }
+
+    assertNotNull("SDK block should set a tag on the control view", control.tag)
+    assertEquals("mask(\"block\") must apply the SDK's block tag", control.tag, view.tag)
+  }
+
+  @Test
+  fun defaultPrimitive_unmask_matchesSdkUnmask() {
+    val primitive = SRDefaultMaskingPrimitive()
+    lateinit var view: View
+    lateinit var control: View
+    onMain {
+      view = View(context)
+      control = View(context)
+      primitive.unmask(view)
+      SessionReplay.unmask(control)
+    }
+
+    assertNotNull("SDK unmask should set a tag on the control view", control.tag)
+    assertEquals("unmask must apply the SDK's unmask tag", control.tag, view.tag)
+  }
+
+  @Test
+  fun defaultPrimitive_reset_clearsTag() {
+    val primitive = SRDefaultMaskingPrimitive()
+    lateinit var view: View
+    onMain {
+      view = View(context)
+      primitive.mask(view, "mask")
+    }
+    assertNotNull("precondition: mask should set a tag", view.tag)
+
+    onMain { primitive.reset(view) }
+    assertNull("reset must clear the SDK tag (return to inherit)", view.tag)
+  }
+
+  // 7. Touch transparency: the widened host frame necessarily overlaps
+  //    unrelated siblings, so the host itself must never be a touch target —
+  //    RN touch targeting must skip it (BOX_NONE) and only consider children.
+  @Test
+  fun host_pointerEvents_isBoxNone() {
+    lateinit var host: SRMaskView
+    onMain { host = SRMaskView(context) }
+    assertEquals(
+      "SRMaskView host must be BOX_NONE so its widened frame can't swallow input",
+      PointerEvents.BOX_NONE,
+      host.pointerEvents,
+    )
+  }
 }
diff --git a/packages/session-replay-react-native/android/src/main/java/com/amplitude/sessionreplayreactnative/SRDefaultMaskingPrimitive.kt b/packages/session-replay-react-native/android/src/main/java/com/amplitude/sessionreplayreactnative/SRDefaultMaskingPrimitive.kt
new file mode 100644
index 000000000..05883dcfb
--- /dev/null
+++ b/packages/session-replay-react-native/android/src/main/java/com/amplitude/sessionreplayreactnative/SRDefaultMaskingPrimitive.kt
@@ -0,0 +1,36 @@
+package com.amplitude.sessionreplayreactnative
+
+import android.view.View
+import com.amplitude.android.sessionreplay.SessionReplay
+
+/**
+ * Default [SRMaskingPrimitive] bridging the masking seam to the Amplitude
+ * Session Replay Android SDK's existing tag-based hooks:
+ *
+ *  - `mask(view, "mask")`  -> [SessionReplay.mask]
+ *  - `mask(view, "block")` -> [SessionReplay.block]
+ *  - `unmask(view)`        -> [SessionReplay.unmask]
+ *  - `reset(view)`         -> `view.tag = null` (the SDK hooks are tag-based;
+ *                             clearing the tag returns the view to "inherit")
+ *
+ * Registered on the UI thread at SDK init
+ * ([SessionReplayReactNativeModule.setup]); registration replays intents
+ * recorded before init, so mount-before-init masking still applies.
+ */
+class SRDefaultMaskingPrimitive : SRMaskingPrimitive {
+  override fun mask(view: View, level: String) {
+    when (level) {
+      "block" -> SessionReplay.block(view)
+      // Default mask level is "mask"; unknown levels fail safe to masking.
+      else -> SessionReplay.mask(view)
+    }
+  }
+
+  override fun unmask(view: View) {
+    SessionReplay.unmask(view)
+  }
+
+  override fun reset(view: View) {
+    view.tag = null
+  }
+}
diff --git a/packages/session-replay-react-native/android/src/main/java/com/amplitude/sessionreplayreactnative/SessionReplayReactNativeModule.kt b/packages/session-replay-react-native/android/src/main/java/com/amplitude/sessionreplayreactnative/SessionReplayReactNativeModule.kt
index 932b65c1d..77c691440 100644
--- a/packages/session-replay-react-native/android/src/main/java/com/amplitude/sessionreplayreactnative/SessionReplayReactNativeModule.kt
+++ b/packages/session-replay-react-native/android/src/main/java/com/amplitude/sessionreplayreactnative/SessionReplayReactNativeModule.kt
@@ -9,6 +9,7 @@ import com.amplitude.core.ServerZone
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.bridge.ReadableMap
@@ -18,6 +19,7 @@ import com.facebook.react.bridge.ReadableMap
 class SessionReplayReactNativeModule(private val reactContext: ReactApplicationContext) :
   SessionReplayReactNativeSpec(reactContext) {
   private lateinit var sessionReplay: SessionReplay
+  @Volatile private var invalidated = false
 
   override fun getName(): String {
     return NAME
@@ -78,11 +80,32 @@ class SessionReplayReactNativeModule(private val reactContext: ReactApplicationC
           "EU" -> ServerZone.EU
           else -> ServerZone.US
         },
-        autoStart = autoStart,
+        // Deferred to the UI-thread block below so primitive registration can
+        // be ordered before start(); behaviorally identical to SDK autoStart.
+        autoStart = false,
         privacyConfig = PrivacyConfig(maskLevel = maskLevel),
       )
-      
-      promise.resolve(null)
+
+      // Register the primitive, start capture, and resolve in ONE UI-thread
+      // block: the registry is UI-thread-only, and registration must precede
+      // start() on the capture (UI) thread so an early capture frame can't
+      // snapshot SRMaskView children before their masking intents apply.
+      // Re-registering on repeated setup() calls is harmless.
+      UiThreadUtil.runOnUiThread {
+        if (invalidated) {
+          promise.reject("SETUP_ERROR", "Session Replay module was invalidated before setup completed", null)
+          return@runOnUiThread
+        }
+        try {
+          SRMaskingRegistry.setPrimitive(SRDefaultMaskingPrimitive())
+          if (autoStart) {
+            sessionReplay.start()
+          }
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("SETUP_ERROR", e.message, e)
+        }
+      }
     } catch (e: Exception) {
       promise.reject("SETUP_ERROR", e.message, e)
     }
@@ -177,8 +200,15 @@ class SessionReplayReactNativeModule(private val reactContext: ReactApplicationC
   }
 
   override fun invalidate() {
-    if (::sessionReplay.isInitialized) {
-      sessionReplay.shutdown()
+    invalidated = true
+    // Serialize teardown with the deferred setup() block: both run on the UI
+    // queue, so a mid-setup invalidate can no longer interleave — shutdown
+    // always runs either before the block (flag rejects it) or after start()
+    // (normal stop).
+    UiThreadUtil.runOnUiThread {
+      if (::sessionReplay.isInitialized) {
+        sessionReplay.shutdown()
+      }
     }
   }
 
diff --git a/packages/session-replay-react-native/android/src/newarch/java/com/amplitude/sessionreplayreactnative/fabric/SRMaskView.kt b/packages/session-replay-react-native/android/src/newarch/java/com/amplitude/sessionreplayreactnative/fabric/SRMaskView.kt
index c876f7083..9016d37fb 100644
--- a/packages/session-replay-react-native/android/src/newarch/java/com/amplitude/sessionreplayreactnative/fabric/SRMaskView.kt
+++ b/packages/session-replay-react-native/android/src/newarch/java/com/amplitude/sessionreplayreactnative/fabric/SRMaskView.kt
@@ -3,6 +3,7 @@ package com.amplitude.sessionreplayreactnative.fabric
 import android.content.Context
 import android.view.View
 import com.amplitude.sessionreplayreactnative.SRMaskingRegistry
+import com.facebook.react.uimanager.PointerEvents
 import com.facebook.react.views.view.ReactViewGroup
 
 /**
@@ -28,8 +29,22 @@ class SRMaskView(context: Context) : ReactViewGroup(context) {
   init {
     clipChildren = false
     clipToPadding = false
+    // The widened frame (see expandBoundsToChildrenUnion) necessarily spans
+    // from the host's Fabric-assigned origin to the children's far corner, so
+    // it overlaps sibling views that have nothing to do with this mask. The
+    // host must therefore never participate in touch targeting itself:
+    // BOX_NONE makes RN's TouchTargetHelper skip the host (only its children
+    // can be targets) and lets misses fall through to views underneath.
+    // Children are unaffected. This view is never created from a JS
+    // pointerEvents prop, so nothing else writes this field.
+    setPointerEvents(PointerEvents.BOX_NONE)
   }
 
+  // Belt-and-braces with the init{} setter: TouchTargetHelper consults this
+  // accessor, and it must stay BOX_NONE even if some future code path (e.g.
+  // view recycling's resetPointerEvents) rewrites the backing field.
+  override fun getPointerEvents(): PointerEvents = PointerEvents.BOX_NONE
+
   // Children can be laid out after the host's own layout pass; re-widen then.
   private val childLayoutChangeListener =
     OnLayoutChangeListener { _, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom ->
@@ -74,13 +89,25 @@ class SRMaskView(context: Context) : ReactViewGroup(context) {
     expandBoundsToChildrenUnion()
   }
 
-  // Widen this host's native frame to enclose its children WITHOUT moving it:
-  // the origin (left, top) must stay Fabric-assigned, because children are
-  // positioned relative to the host — moving it would shift them on screen and
-  // break layout neutrality. Only right/bottom grow. Child coordinates are in
-  // host-space, so the parent-space extent is host origin + max child extent.
-  // (Children at negative host-space coords can't be enclosed without moving
-  // the host; normal RN layout never produces those.)
+  // Widen this host's native frame to enclose its children WITHOUT moving it.
+  //
+  // Measured coordinate model (SDKRN-33, RN 0.77.2 Fabric, on-device):
+  // children are ALWAYS host-relative — a child renders at
+  // (host.left + child.left, host.top + child.top), standard Android. The
+  // host's Fabric-assigned degenerate frame is (X,Y,X,Y) where (X,Y) is the
+  // accumulated origin of any flattened views between the host and its
+  // mounted parent: (0,0) for top-level masks (where host-relative and
+  // parent-space coincide numerically), non-zero for e.g. an AmpUnmask nested
+  // inside an AmpMask through a flattened <View>, a mask inside a list row,
+  // or a mask whose child uses negative offsets. Therefore the enclosing
+  // extent in parent space is origin + max child extent. The origin must
+  // never move (children would shift on screen), so children at negative
+  // host-relative coordinates cannot be enclosed; the extents are clamped so
+  // the frame is never degenerate or inverted while children exist — the
+  // session-replay capture gate (width>0 && height>0) is the whole point of
+  // the widening. The widened frame can overlap unrelated siblings, which is
+  // why the host is pointer-events BOX_NONE (see init) and must never be a
+  // touch target itself.
   private fun expandBoundsToChildrenUnion() {
     if (expanding) return
     if (childCount == 0) return
@@ -93,8 +120,11 @@ class SRMaskView(context: Context) : ReactViewGroup(context) {
       if (c.bottom > maxChildBottom) maxChildBottom = c.bottom
     }
 
-    val newRight = left + maxChildRight
-    val newBottom = top + maxChildBottom
+    // Children are host-relative, so parent-space extent = origin + extent.
+    // Clamp to a 1px minimum so a child at fully negative coordinates can
+    // never produce a zero/inverted frame that the capture gate would drop.
+    val newRight = left + maxOf(maxChildRight, 1)
+    val newBottom = top + maxOf(maxChildBottom, 1)
 
     if (newRight != right || newBottom != bottom) {
       expanding = true
diff --git a/packages/session-replay-react-native/cpp/SRMaskViewComponentDescriptor.h b/packages/session-replay-react-native/cpp/SRMaskViewComponentDescriptor.h
index f9711eaa9..09d712b46 100644
--- a/packages/session-replay-react-native/cpp/SRMaskViewComponentDescriptor.h
+++ b/packages/session-replay-react-native/cpp/SRMaskViewComponentDescriptor.h
@@ -2,27 +2,19 @@
 
 #include "SRMaskViewShadowNode.h"
 
-#include <react/debug/react_native_assert.h>
-#include <react/renderer/components/view/YogaLayoutableShadowNode.h>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
 
 namespace facebook::react {
 
 // Replaces the codegen typedef of the same name (patched on Android; iOS binds
-// via +componentDescriptorProvider). adopt() runs after updateYogaProps() on
-// every create/clone so display:contents is authoritative.
+// via +componentDescriptorProvider). Exists only to bind the custom
+// SRMaskViewContentsShadowNode class — no adopt() override; the ShadowNode's
+// own constructors handle the ForceFlattenView unset (see
+// SRMaskViewShadowNode.h).
 class SRMaskViewComponentDescriptor final
     : public ConcreteComponentDescriptor<SRMaskViewContentsShadowNode> {
  public:
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
-
-  void adopt(ShadowNode& shadowNode) const override {
-    react_native_assert(
-        dynamic_cast<SRMaskViewContentsShadowNode*>(&shadowNode));
-    auto& contentsNode = static_cast<SRMaskViewContentsShadowNode&>(shadowNode);
-    contentsNode.applyContentsDisplay();
-    ConcreteComponentDescriptor::adopt(shadowNode);
-  }
 };
 
 } // namespace facebook::react
diff --git a/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.cpp b/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.cpp
index 72ae3c7ab..0f860f502 100644
--- a/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.cpp
+++ b/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.cpp
@@ -1,16 +1,54 @@
 #include "SRMaskViewShadowNode.h"
 
+#include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/core/ShadowNodeTraits.h>
-#include <yoga/style/Style.h>
+#include <yoga/Yoga.h>
 
 namespace facebook::react {
 
-void SRMaskViewContentsShadowNode::applyContentsDisplay() {
+void SRMaskViewContentsShadowNode::initialize() {
+  // display:contents comes from the JS style prop and is already in
+  // yogaNode_'s style (parsed by RN's own updateYogaProps(), which also set
+  // ForceFlattenView). We never write the Yoga style in C++; the only trait
+  // customization is keeping the host view mounted (the session-replay SDK
+  // needs a real view to tag for masking) while Yoga still lays the children
+  // out as if the host didn't exist.
+  if (YGNodeStyleGetDisplay(&yogaNode_) != YGDisplayContents) {
+    return;
+  }
+
   traits_.unset(ShadowNodeTraits::Trait::ForceFlattenView);
 
-  auto style = yogaNode_.style();
-  style.setDisplay(yoga::Display::Contents);
-  yogaNode_.setStyle(style);
+  // Workaround for an upstream Yoga display:contents bug present in
+  // RN 0.77-0.82 (fixed by facebook/react-native#56422, shipped in 0.86 and
+  // backports): because contents nodes are skipped by Yoga's layout
+  // traversal, their children are cloned through side channels
+  // (cleanupContentsNodesRecursively / layoutAbsoluteDescendants) that call
+  // cloneChildrenIfNeeded() on a contents node even when it is clean and
+  // belongs to an already-committed (sealed) tree. If this node was cloned
+  // without re-adopting its children, that fires the ShadowNode clone
+  // callback on the sealed node and SIGABRTs debug builds
+  // (Sealable::ensureUnsealed). Defuse the precondition: eagerly take
+  // ownership of every Yoga child at construction time (we are unsealed
+  // here), so cloneChildrenIfNeeded() on this node is always a no-op later.
+  // This mirrors what YogaLayoutableShadowNode::cloneChildInPlace() does
+  // lazily during layout, just moved to a legal (unsealed) point in time.
+  auto yogaChildren = yogaNode_.getChildren(); // copy: replaceChild mutates
+  for (yoga::Node* childYogaNode : yogaChildren) {
+    if (childYogaNode->getOwner() == &yogaNode_) {
+      continue;
+    }
+    auto& childShadowNode = *static_cast<YogaLayoutableShadowNode*>(
+        childYogaNode->getContext());
+    auto clonedChildShadowNode = childShadowNode.clone(
+        {ShadowNodeFragment::propsPlaceholder(),
+         ShadowNodeFragment::childrenPlaceholder(),
+         childShadowNode.getState()});
+    // Public replaceChild() performs the same Yoga bookkeeping as RN's
+    // private cloneChildInPlace(): swaps the ShadowNode child and re-owns
+    // the fresh clone's Yoga node under yogaNode_.
+    replaceChild(childShadowNode, clonedChildShadowNode);
+  }
 }
 
 } // namespace facebook::react
diff --git a/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.h b/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.h
index 22f9a7cba..650bdc4fc 100644
--- a/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.h
+++ b/packages/session-replay-react-native/cpp/SRMaskViewShadowNode.h
@@ -10,6 +10,19 @@ namespace facebook::react {
 // clashes with generated ShadowNodes.h while reusing the same component name.
 extern const char SRMaskViewComponentName[];
 
+// The JS component passes style={display:'contents'}; RN's own
+// updateYogaProps() (run inside the base constructors) parses it into the
+// Yoga style and sets ShadowNodeTraits::ForceFlattenView. We never mutate the
+// Yoga style in C++ — the only customization is unsetting ForceFlattenView
+// after each construction so the Android/iOS host view stays mounted (the
+// session-replay SDK needs a real view to tag for masking) while Yoga still
+// lays the children out as if the host didn't exist.
+//
+// This mirrors the pattern shipped by Expensify react-native-live-markdown
+// (MarkdownTextInputDecoratorShadowNode) and Expo's expo-modules-core
+// (ExpoViewShadowNode's disableForceFlatten): a post-constructor hook invoked
+// from BOTH constructors (create + clone), no ComponentDescriptor::adopt()
+// override, no Yoga style writes.
 class SRMaskViewContentsShadowNode final
     : public ConcreteViewShadowNode<
           SRMaskViewComponentName,
@@ -20,16 +33,24 @@ class SRMaskViewContentsShadowNode final
       const ShadowNodeFragment& fragment,
       const ShadowNodeFamily::Shared& family,
       ShadowNodeTraits traits)
-      : ConcreteViewShadowNode(fragment, family, traits) {}
+      : ConcreteViewShadowNode(fragment, family, traits) {
+    initialize();
+  }
 
   SRMaskViewContentsShadowNode(
       const ShadowNode& sourceShadowNode,
       const ShadowNodeFragment& fragment)
-      : ConcreteViewShadowNode(sourceShadowNode, fragment) {}
+      : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+    initialize();
+  }
 
-  // Applied from ComponentDescriptor::adopt() after updateYogaProps() on every
-  // create/clone so display:contents survives prop-driven Yoga style resets.
-  void applyContentsDisplay();
+ private:
+  // Runs after the base constructors (and therefore after updateYogaProps(),
+  // which re-sets ForceFlattenView on every clone that carries new props).
+  // Must be called from every constructor. Besides the trait unset it also
+  // eagerly re-owns this node's Yoga children — a workaround for an upstream
+  // RN 0.77-0.82 display:contents crash; see the .cpp for details.
+  void initialize();
 };
 
 } // namespace facebook::react
diff --git a/packages/session-replay-react-native/example/App.tsx b/packages/session-replay-react-native/example/App.tsx
index 1b321198e..7c3ae55d7 100644
--- a/packages/session-replay-react-native/example/App.tsx
+++ b/packages/session-replay-react-native/example/App.tsx
@@ -24,6 +24,7 @@ import {
   Switch,
   Text,
   TextInput,
+  UIManager,
   View,
 } from 'react-native';
 import { WebView } from 'react-native-webview';
@@ -42,6 +43,9 @@ import {
   getSessionReplayProperties,
   setSessionId,
   setDeviceId,
+  AmpMask,
+  AmpUnmask,
+  AmpMaskView,
 } from '@amplitude/session-replay-react-native';
 
 const g = global as unknown as {
@@ -51,6 +55,9 @@ const g = global as unknown as {
 };
 const isTurboModule = g.__turboModuleProxy != null || g.RN$Bridgeless === true;
 const isFabric = g.nativeFabricUIManager != null;
+// Same New Architecture check the library uses to select the AmpMask
+// implementation (src/index.tsx) — keep the two in sync.
+const isNewArch = g.RN$Bridgeless === true || g.nativeFabricUIManager != null;
 const rnv = Platform.constants?.reactNativeVersion;
 const rnVersion = rnv ? `${rnv.major}.${rnv.minor}.${rnv.patch}` : 'unknown';
 
@@ -68,6 +75,7 @@ type RootStackParamList = {
   Form: undefined;
   Gallery: undefined;
   Web: undefined;
+  Mask: undefined;
 };
 
 type HomeProps = NativeStackScreenProps<RootStackParamList, 'Home'>;
@@ -172,6 +180,7 @@ function HomeScreen({ navigation }: HomeProps): React.JSX.Element {
           <Button title="Form" onPress={() => navigation.navigate('Form')} />
           <Button title="Gallery" onPress={() => navigation.navigate('Gallery')} />
           <Button title="Web" onPress={() => navigation.navigate('Web')} />
+          <Button title="Mask" onPress={() => navigation.navigate('Mask')} />
         </View>
 
         <Text style={styles.heading}>Log</Text>
@@ -264,6 +273,123 @@ function WebScreen(): React.JSX.Element {
   );
 }
 
+type MaskDemoWrapper = 'none' | 'ampmask' | 'ampmaskview';
+
+/**
+ * One layout-neutrality row: the same flex:1 child inside a fixed-height slot,
+ * under one wrapper. The child's measured onLayout frame is printed next to
+ * the label so zero layout shift can be verified by eye: the <AmpMask> row
+ * must measure identical to the bare row, while the legacy <AmpMaskView> row
+ * collapses the child to height 0 on the New Architecture.
+ */
+function MaskDemoRow({
+  label,
+  wrapper,
+}: {
+  label: string;
+  wrapper: MaskDemoWrapper;
+}): React.JSX.Element {
+  const [frame, setFrame] = useState('measuring…');
+  const child = (
+    <View
+      style={styles.maskFill}
+      onLayout={(e) => {
+        const { width, height } = e.nativeEvent.layout;
+        setFrame(
+          `${Math.round(width * 10) / 10}×${Math.round(height * 10) / 10}`,
+        );
+      }}
+    >
+      <Text style={styles.maskFillText}>flex:1 child</Text>
+    </View>
+  );
+  return (
+    <View style={styles.maskRow}>
+      <Text style={styles.maskRowLabel}>
+        {label} · <Text style={styles.maskRowFrame}>{frame}</Text>
+      </Text>
+      <View style={styles.maskSlot}>
+        {wrapper === 'none' && child}
+        {wrapper === 'ampmask' && <AmpMask>{child}</AmpMask>}
+        {wrapper === 'ampmaskview' && (
+          <AmpMaskView mask="amp-mask">{child}</AmpMaskView>
+        )}
+      </View>
+    </View>
+  );
+}
+
+function MaskScreen(): React.JSX.Element {
+  const [secret, setSecret] = useState('4242-4242-4242-4242');
+
+  if (!isNewArch) {
+    return (
+      <SafeAreaView style={styles.root}>
+        <View style={styles.bodyContent}>
+          <Text style={styles.heading}>
+            {'<AmpMask> requires the New Architecture'}
+          </Text>
+          <Text style={styles.note}>
+            This app is running on the Old Architecture (Paper). Rebuild with
+            newArchEnabled=true (Android) / RCT_NEW_ARCH_ENABLED=1 (iOS) to try
+            {' <AmpMask>/<AmpUnmask>, or use <AmpMaskView>, which supports '}
+            both architectures (but is not layout-transparent).
+          </Text>
+        </View>
+      </SafeAreaView>
+    );
+  }
+
+  return (
+    <SafeAreaView style={styles.root}>
+      <ScrollView contentContainerStyle={styles.bodyContent}>
+        <Text style={styles.metaText}>
+          RN$Bridgeless: {String(g.RN$Bridgeless)} · Native SRMaskView:{' '}
+          {UIManager.hasViewManagerConfig?.('SRMaskView')
+            ? 'available'
+            : 'missing'}
+        </Text>
+
+        <Text style={styles.heading}>
+          Layout neutrality (flex:1 child in a fixed-height slot)
+        </Text>
+        <Text style={styles.note}>
+          All three rows render the same flex:1 child in a 96px slot.
+          {' <AmpMask> is layout-transparent, so row 2 must measure identical '}
+          to row 1. The legacy wrapper in row 3 introduces a layout boundary:
+          on the New Architecture the child collapses to height 0.
+        </Text>
+        <MaskDemoRow label="1. bare <View>" wrapper="none" />
+        <MaskDemoRow label="2. <AmpMask> wrapped" wrapper="ampmask" />
+        <MaskDemoRow label="3. <AmpMaskView> wrapped (legacy)" wrapper="ampmaskview" />
+
+        <Text style={styles.heading}>Replay masking</Text>
+        <AmpMask>
+          <Text style={styles.label}>Masked text: SECRET-1234</Text>
+          <TextInput
+            style={styles.input}
+            value={secret}
+            onChangeText={setSecret}
+          />
+        </AmpMask>
+        <AmpMask maskLevel="block">
+          <Text style={styles.label}>
+            {'Blocked text (maskLevel="block")'}
+          </Text>
+        </AmpMask>
+        <AmpUnmask>
+          <Text style={styles.label}>Unmasked text: visible in replay</Text>
+        </AmpUnmask>
+        <Text style={styles.note}>
+          Start recording on the Home screen, interact here, then check the
+          replay: the masked/blocked content above must be obscured while the
+          unmasked text stays visible.
+        </Text>
+      </ScrollView>
+    </SafeAreaView>
+  );
+}
+
 const Stack = createNativeStackNavigator<RootStackParamList>();
 
 export default function App(): React.JSX.Element {
@@ -278,6 +404,7 @@ export default function App(): React.JSX.Element {
         <Stack.Screen name="Form" component={FormScreen} />
         <Stack.Screen name="Gallery" component={GalleryScreen} />
         <Stack.Screen name="Web" component={WebScreen} />
+        <Stack.Screen name="Mask" component={MaskScreen} />
       </Stack.Navigator>
     </NavigationContainer>
   );
@@ -332,4 +459,28 @@ const styles = StyleSheet.create({
     fontSize: 12,
     fontFamily: Platform.select({ ios: 'Menlo', default: 'monospace' }),
   },
+  maskRow: { marginBottom: 12 },
+  maskRowLabel: {
+    fontSize: 13,
+    fontWeight: '600',
+    color: '#374151',
+    marginBottom: 4,
+  },
+  maskRowFrame: { color: '#2563eb', fontWeight: '400' },
+  maskSlot: {
+    height: 96,
+    borderWidth: 1,
+    borderColor: '#d1d5db',
+    borderRadius: 8,
+    padding: 4,
+    backgroundColor: '#f3f4f6',
+  },
+  maskFill: {
+    flex: 1,
+    backgroundColor: '#dbeafe',
+    borderRadius: 6,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  maskFillText: { fontSize: 13, color: '#1e40af', fontWeight: '600' },
 });
diff --git a/packages/session-replay-react-native/example/ios/exampleTests/SRMaskViewTests.mm b/packages/session-replay-react-native/example/ios/exampleTests/SRMaskViewTests.mm
index ab55563c6..b74787ce6 100644
--- a/packages/session-replay-react-native/example/ios/exampleTests/SRMaskViewTests.mm
+++ b/packages/session-replay-react-native/example/ios/exampleTests/SRMaskViewTests.mm
@@ -8,6 +8,16 @@
 // React-RCTFabric header. Used as a concrete child in the per-child mask test.
 #import <React/RCTViewComponentView.h>
 
+// `UIView.amp_isBlocked` — the Session Replay SDK hook the default primitive
+// (Task 2.6) bridges to. The SDK declares it in its generated Swift interface
+// header (`AmplitudeSessionReplay-Swift.h`), which is not C++-clean (enum
+// forward references), so this `.mm` file redeclares the property instead. The
+// declaration matches the SDK's exactly; at runtime the accessors dispatch by
+// selector to the SDK's implementation (`UIView+AmplitudeSessionReplay.swift`).
+@interface UIView (AMPSessionReplayMaskingTestSupport)
+@property (nonatomic) BOOL amp_isBlocked;
+@end
+
 #pragma mark - Recording primitive
 
 /// A `<SRMaskingPrimitive>` that records every call so tests can assert on the
@@ -282,4 +292,109 @@ - (void)testMountChildMasksAndRecycleResetsViaView
 #pragma clang diagnostic pop
 }
 
+#pragma mark Frame widening + touch transparency
+
+/// The host's real frame widens to enclose its children WITHOUT moving its
+/// origin (UIKit's accessibility traversal prunes zero-sized views together
+/// with their descendants — the a11y fix), and the widened host itself stays
+/// touch-transparent: only children can be hit, misses return nil.
+- (void)testHostFrameWidensToChildrenUnionAndStaysTouchTransparent
+{
+  Class maskViewClass = NSClassFromString(@"SRMaskView");
+  if (maskViewClass == Nil) {
+    XCTSkip(@"SRMaskView not available (new arch disabled)");
+    return;
+  }
+
+  RCTViewComponentView *maskView =
+      [[maskViewClass alloc] initWithFrame:CGRectMake(12, 346, 0, 0)];
+  RCTViewComponentView *childA =
+      [[RCTViewComponentView alloc] initWithFrame:CGRectMake(0, 0, 100, 50)];
+  RCTViewComponentView *childB =
+      [[RCTViewComponentView alloc] initWithFrame:CGRectMake(120, 60, 80, 80)];
+  [maskView mountChildComponentView:childA index:0];
+  [maskView mountChildComponentView:childB index:1];
+
+  // Origin pinned; size == children max extent (childB right 200, bottom 140).
+  XCTAssertEqual(maskView.frame.origin.x, 12, @"widening must not move the origin");
+  XCTAssertEqual(maskView.frame.origin.y, 346, @"widening must not move the origin");
+  XCTAssertEqual(maskView.frame.size.width, 200, @"width == max child extent");
+  XCTAssertEqual(maskView.frame.size.height, 140, @"height == max child extent");
+
+  // Touch transparency: a point inside the widened frame but outside every
+  // child must NOT hit the host; a point inside a child resolves to the child.
+  XCTAssertNil([maskView hitTest:CGPointMake(150, 20) withEvent:nil],
+               @"widened host must never be the touch target itself");
+  XCTAssertEqualObjects([maskView hitTest:CGPointMake(50, 25) withEvent:nil], childA,
+                        @"children inside the mask must stay tappable");
+}
+
+#pragma mark Default primitive mapping (Task 2.6)
+
+/// Returns a fresh instance of the pod's default masking primitive
+/// (`SRDefaultMaskingPrimitive`, registered at SDK init). Reached via the
+/// runtime: the class is Swift-defined inside the pod with an explicit ObjC
+/// name, so no public header is needed (the runtime de-dups duplicate class
+/// copies to one, and `amp_isBlocked` dispatches by selector, so writes and
+/// reads stay consistent across the app/test bundles).
+static id<SRMaskingPrimitive> SRMakeDefaultPrimitive(void)
+{
+  Class cls = NSClassFromString(@"SRDefaultMaskingPrimitive");
+  return [[cls alloc] init];
+}
+
+/// mask (level "mask") → `amp_isBlocked == YES` (the SDK's masking hook).
+- (void)testDefaultPrimitiveMaskLevelMaskSetsAmpIsBlocked
+{
+  id<SRMaskingPrimitive> primitive = SRMakeDefaultPrimitive();
+  XCTAssertNotNil(primitive, @"SRDefaultMaskingPrimitive must be linked (registered at SDK init)");
+
+  UIView *view = [[UIView alloc] init];
+  XCTAssertFalse(view.amp_isBlocked, @"Sanity: a fresh view is not blocked");
+
+  [primitive maskView:view level:@"mask"];
+  XCTAssertTrue(view.amp_isBlocked, @"mask(\"mask\") must set amp_isBlocked");
+}
+
+/// mask (level "block") → `amp_isBlocked == YES` (iOS has a single blocking
+/// hook, so "mask" and "block" map identically).
+- (void)testDefaultPrimitiveMaskLevelBlockSetsAmpIsBlocked
+{
+  id<SRMaskingPrimitive> primitive = SRMakeDefaultPrimitive();
+  XCTAssertNotNil(primitive);
+
+  UIView *view = [[UIView alloc] init];
+  [primitive maskView:view level:@"block"];
+  XCTAssertTrue(view.amp_isBlocked, @"mask(\"block\") must set amp_isBlocked");
+}
+
+/// unmask → `amp_isBlocked == NO`, including on a previously-masked view.
+- (void)testDefaultPrimitiveUnmaskClearsAmpIsBlocked
+{
+  id<SRMaskingPrimitive> primitive = SRMakeDefaultPrimitive();
+  XCTAssertNotNil(primitive);
+
+  UIView *view = [[UIView alloc] init];
+  [primitive maskView:view level:@"mask"];
+  XCTAssertTrue(view.amp_isBlocked, @"Precondition: view is masked");
+
+  [primitive unmaskView:view];
+  XCTAssertFalse(view.amp_isBlocked, @"unmask must clear amp_isBlocked");
+}
+
+/// reset → `amp_isBlocked == NO` (approximation: the SDK has no per-view
+/// "inherit" reset today; a precise `.none` reset is a documented fast-follow).
+- (void)testDefaultPrimitiveResetClearsAmpIsBlocked
+{
+  id<SRMaskingPrimitive> primitive = SRMakeDefaultPrimitive();
+  XCTAssertNotNil(primitive);
+
+  UIView *view = [[UIView alloc] init];
+  [primitive maskView:view level:@"mask"];
+  XCTAssertTrue(view.amp_isBlocked, @"Precondition: view is masked");
+
+  [primitive resetView:view];
+  XCTAssertFalse(view.amp_isBlocked, @"reset must clear amp_isBlocked");
+}
+
 @end
diff --git a/packages/session-replay-react-native/ios/NativeSessionReplay.swift b/packages/session-replay-react-native/ios/NativeSessionReplay.swift
index 521041563..1a312b71c 100644
--- a/packages/session-replay-react-native/ios/NativeSessionReplay.swift
+++ b/packages/session-replay-react-native/ios/NativeSessionReplay.swift
@@ -16,7 +16,7 @@ class NativeSessionReplay: NSObject, RCTBridgeModule {
     }
     
     @objc(setup:resolve:reject:)
-    func setup(_ config: NSDictionary, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
+    func setup(_ config: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
         guard let apiKey = config["apiKey"] as? String,
               let sessionId = config["sessionId"] as? NSNumber,
               let serverZone = config["serverZone"] as? String,
@@ -62,10 +62,25 @@ class NativeSessionReplay: NSObject, RCTBridgeModule {
             enableRemoteConfig: enableRemoteConfig
         )
         
-        if (autoStart) {
-            sessionReplay.start()
+        // Register the primitive, start capture, and resolve in ONE main-thread
+        // block: the registry is main-thread-only (setup runs on the RN
+        // native-modules queue), and registration must precede start() on the
+        // capture (main) thread so an early capture frame can't snapshot
+        // SRMaskView children before their masking intents apply.
+        // Re-registering on repeated setup() calls is harmless.
+        DispatchQueue.main.async {
+            // Invalidated (e.g. RN reload) before deferred setup ran — settle
+            // the promise so JS init() never hangs.
+            guard let sessionReplay = self.sessionReplay else {
+                reject("SETUP_ERROR", "Session Replay module was invalidated before setup completed", nil)
+                return
+            }
+            SRMaskingRegistry.primitive = SRDefaultMaskingPrimitive()
+            if (autoStart) {
+                sessionReplay.start()
+            }
+            resolve(nil)
         }
-        resolve(nil)
     }
     
     @objc(setSessionId:resolve:reject:)
@@ -127,10 +142,16 @@ class NativeSessionReplay: NSObject, RCTBridgeModule {
     
     @objc(invalidate)
     func invalidate() {
-        print("invalidate")
-        // could be nil here
-        sessionReplay?.stop()
-        sessionReplay = nil
+        // Serialize teardown with the deferred setup() block on the main queue —
+        // a mid-setup invalidate can no longer interleave; stop always runs either
+        // before the block (guard rejects) or after start() (normal teardown).
+        // Strong self capture is intentional: keep the module alive until teardown runs.
+        DispatchQueue.main.async {
+            print("invalidate")
+            // could be nil here
+            self.sessionReplay?.stop()
+            self.sessionReplay = nil
+        }
     }
 }
 
diff --git a/packages/session-replay-react-native/ios/SRDefaultMaskingPrimitive.swift b/packages/session-replay-react-native/ios/SRDefaultMaskingPrimitive.swift
new file mode 100644
index 000000000..290e4ab76
--- /dev/null
+++ b/packages/session-replay-react-native/ios/SRDefaultMaskingPrimitive.swift
@@ -0,0 +1,34 @@
+import UIKit
+import AmplitudeSessionReplay
+
+/// Default `SRMaskingPrimitive` bridging the masking seam to the Amplitude
+/// Session Replay iOS SDK's existing hook (`UIView.amp_isBlocked`):
+///
+///  - `maskView(_:level:)` — both `"mask"` and `"block"` map to
+///    `amp_isBlocked = true` (the iOS SDK exposes a single blocking hook).
+///  - `unmaskView(_:)` — `amp_isBlocked = false`.
+///  - `resetView(_:)` — `amp_isBlocked = false`. Approximation: the SDK has no
+///    per-view "inherit" reset today; a precise `.none` reset is a documented
+///    fast-follow.
+///
+/// Registered on the main thread at SDK init (`NativeSessionReplay.setup`);
+/// registration replays intents recorded before init, so mount-before-init
+/// masking still applies.
+///
+/// The explicit ObjC name lets the native canaries reach this class via
+/// `NSClassFromString` without new public headers.
+@objc(SRDefaultMaskingPrimitive)
+class SRDefaultMaskingPrimitive: NSObject, SRMaskingPrimitive {
+    func maskView(_ view: UIView, level: String) {
+        // "mask", "block", and unknown levels all fail safe to blocking.
+        view.amp_isBlocked = true
+    }
+
+    func unmaskView(_ view: UIView) {
+        view.amp_isBlocked = false
+    }
+
+    func resetView(_ view: UIView) {
+        view.amp_isBlocked = false
+    }
+}
diff --git a/packages/session-replay-react-native/ios/fabric/SRMaskView.mm b/packages/session-replay-react-native/ios/fabric/SRMaskView.mm
index 941934629..0efd7f134 100644
--- a/packages/session-replay-react-native/ios/fabric/SRMaskView.mm
+++ b/packages/session-replay-react-native/ios/fabric/SRMaskView.mm
@@ -60,12 +60,14 @@ - (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childCompone
 {
   [super mountChildComponentView:childComponentView index:index];
   [self applyMaskingToChild:childComponentView];
+  [self expandFrameToChildrenUnion];
 }
 
 - (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
 {
   [SRMaskingRegistry resetView:childComponentView];
   [super unmountChildComponentView:childComponentView index:index];
+  [self expandFrameToChildrenUnion];
 }
 
 - (void)prepareForRecycle
@@ -98,6 +100,65 @@ - (void)applyMaskingToChild:(UIView *)childView
   [SRMaskingRegistry maskView:childView level:_maskLevel ?: @"mask"];
 }
 
+#pragma mark - Frame widening (accessibility)
+
+// This host is intentionally zero-sized: its Yoga node is display:contents-style
+// layout-transparent, so Fabric assigns it a degenerate (w=0,h=0) frame while the
+// children keep real host-relative frames outside our bounds (clipsToBounds=NO).
+// iOS's accessibility machinery prunes zero-sized views TOGETHER WITH their
+// descendants, which made everything inside <AmpMask>/<AmpUnmask> invisible to
+// VoiceOver/XCUITest/a11y tree dumps. Accessibility-only remedies do not work:
+// overriding -accessibilityFrame and/or -accessibilityElements was verified
+// ineffective on-device — the AX snapshot culls this host by its REAL frame
+// before consulting either API. So mirror the Android fix (SRMaskView.kt
+// expandBoundsToChildrenUnion): widen the host's real frame to enclose its
+// children without ever moving its origin (children are host-relative; moving
+// the origin would shift them on screen). Yoga layout is unaffected (UIKit
+// frames never feed back into Fabric layout), and the widened frame cannot
+// swallow touches because -hitTest:withEvent: below returns nil whenever the
+// host itself would be the target (the iOS analogue of Android's BOX_NONE).
+// Re-widen wherever the degenerate frame can be (re)applied or the children's
+// extent can change: host layout metrics updates, child mount/unmount, and
+// -layoutSubviews (UIKit marks the host as needing layout when a subview's
+// frame changes, which covers child-only Fabric layout transactions).
+- (void)expandFrameToChildrenUnion
+{
+  if (self.subviews.count == 0) {
+    return;
+  }
+
+  CGFloat maxChildRight = 0;
+  CGFloat maxChildBottom = 0;
+  for (UIView *child in self.subviews) {
+    maxChildRight = MAX(maxChildRight, CGRectGetMaxX(child.frame));
+    maxChildBottom = MAX(maxChildBottom, CGRectGetMaxY(child.frame));
+  }
+
+  // Children are host-relative, so the enclosing size is just their max extent.
+  // Clamp to a 1pt minimum so a child at fully negative coordinates can never
+  // produce a degenerate frame that the accessibility traversal would prune.
+  CGSize newSize = CGSizeMake(MAX(maxChildRight, 1), MAX(maxChildBottom, 1));
+  CGRect frame = self.frame;
+  if (!CGSizeEqualToSize(frame.size, newSize)) {
+    frame.size = newSize;
+    self.frame = frame;
+  }
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  // super re-applies the degenerate Fabric frame; widen right after.
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  [self expandFrameToChildrenUnion];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  [self expandFrameToChildrenUnion];
+}
+
 - (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
 {
   UIView *hitView = [super hitTest:point withEvent:event];
diff --git a/packages/session-replay-react-native/src/Mask.types.ts b/packages/session-replay-react-native/src/Mask.types.ts
new file mode 100644
index 000000000..f505e3b77
--- /dev/null
+++ b/packages/session-replay-react-native/src/Mask.types.ts
@@ -0,0 +1,45 @@
+import type { ViewProps } from 'react-native';
+import type { ReactNode } from 'react';
+
+/** Masking level for `<AmpMask>`. See {@link MaskProps.maskLevel}. */
+export type AmpMaskLevel = 'mask' | 'block';
+
+/**
+ * Props for `<AmpMask>`, which masks its children in Session Replay
+ * recordings without affecting their layout.
+ *
+ * `style` is not supported: the wrapper is layout-transparent and never
+ * carries a layout box of its own, so styles would have no effect.
+ */
+export interface MaskProps extends Omit<ViewProps, 'style'> {
+  /**
+   * When false, children are rendered without masking.
+   * @default true
+   */
+  enabled?: boolean;
+
+  /**
+   * Masking level applied to children. On iOS, 'mask' and 'block' currently
+   * behave identically (both fully block).
+   * @default 'mask'
+   */
+  maskLevel?: AmpMaskLevel;
+
+  children?: ReactNode;
+}
+
+/**
+ * Props for `<AmpUnmask>`, which exempts its children from masking inside a
+ * masked region, without affecting their layout.
+ *
+ * `style` is not supported: the wrapper is layout-transparent and never
+ * carries a layout box of its own, so styles would have no effect.
+ */
+export interface UnmaskProps extends Omit<ViewProps, 'style'> {
+  children?: ReactNode;
+}
+
+/** Maps the public {@link AmpMaskLevel} to the `<AmpMaskView>` `mask` prop value. */
+export function ampMaskViewMaskProp(level?: AmpMaskLevel): 'amp-mask' | 'amp-block' {
+  return level === 'block' ? 'amp-block' : 'amp-mask';
+}
diff --git a/packages/session-replay-react-native/src/fabric/MaskFabric.tsx b/packages/session-replay-react-native/src/fabric/MaskFabric.tsx
new file mode 100644
index 000000000..aeeecca00
--- /dev/null
+++ b/packages/session-replay-react-native/src/fabric/MaskFabric.tsx
@@ -0,0 +1,73 @@
+import React from 'react';
+import { NativeModules, TurboModuleRegistry, UIManager } from 'react-native';
+import SRMaskViewNative from '../specs/SRMaskViewNativeComponent';
+import { createAmpMaskViewFallback, warnOnce } from '../mask-fallback';
+import type { MaskProps, UnmaskProps } from '../Mask.types';
+
+// Three-tier fail-closed probe. We never fall open (unmasked) unless the
+// package's native code is entirely absent — i.e. the recorder itself cannot
+// run and nothing can be captured:
+//   1. SRMaskView registered -> use it directly, layout-transparent.
+//   2. Only the Paper AMPMaskComponentView registered (Fabric sources not
+//      built) -> render through <AmpMaskView>: masked, layout-unsafe.
+//   3. Neither registered -> behavior depends on RECORDER_PRESENT below.
+const FABRIC_AVAILABLE = UIManager.hasViewManagerConfig?.('SRMaskView') ?? false;
+const PAPER_MASK_AVAILABLE = UIManager.hasViewManagerConfig?.('AMPMaskComponentView') ?? false;
+// Whether the Session Replay native module is linked. Must be resolved the
+// same way src/native-module.ts resolves it (TurboModuleRegistry.get, then the
+// legacy NativeModules interop proxy) so this gate can never disagree with the
+// recorder's actual availability.
+const RECORDER_PRESENT =
+  (TurboModuleRegistry?.get?.('AMPNativeSessionReplay') ?? NativeModules?.AMPNativeSessionReplay) != null;
+
+const contents = { display: 'contents' as unknown as 'flex' }; // zero-box hint; C++ adopt() is authoritative
+
+function MaskImpl({ enabled = true, maskLevel = 'mask', children, ...vp }: MaskProps) {
+  return (
+    <SRMaskViewNative {...vp} enabled={enabled} unmask={false} maskLevel={maskLevel} style={contents}>
+      {children}
+    </SRMaskViewNative>
+  );
+}
+function UnmaskImpl({ children, ...vp }: UnmaskProps) {
+  return (
+    <SRMaskViewNative {...vp} enabled unmask maskLevel="mask" style={contents}>
+      {children}
+    </SRMaskViewNative>
+  );
+}
+
+// Tier 2: masked but not layout-transparent. `enabled` is intentionally
+// ignored (over-mask), matching the Old-Arch prod fallback in MaskPaper.
+const FALLBACK_WARNING =
+  '[AmpMask] New Architecture detected but the native SRMaskView component is unavailable — falling back to <AmpMaskView> (content stays MASKED but layout transparency is lost). Verify the Fabric masking sources were built (new architecture + RN >= 0.77) and codegen ran. Note: Fabric without bridgeless (bridge mode) cannot detect SRMaskView on iOS and always uses this fallback.';
+const FallbackMask = createAmpMaskViewFallback<MaskProps>({ mask: 'from-maskLevel', warning: FALLBACK_WARNING });
+const FallbackUnmask = createAmpMaskViewFallback<UnmaskProps>({ mask: 'amp-unmask', warning: FALLBACK_WARNING });
+
+// Tier 3: no masking-capable native view exists, so children render directly.
+// Safe only when the recorder is absent too (nothing can be captured); when
+// the recorder IS present this is a build error we must not infer our way
+// past — throw in dev, warn loudly in prod.
+const UNMASKED_WARNING =
+  '[AmpMask] New Architecture detected but the native SRMaskView component is unavailable — <AmpMask>/<AmpUnmask> render children UNMASKED. Verify the Fabric masking sources were built (new architecture + RN >= 0.77) and codegen ran.';
+const UNMASKABLE_MSG =
+  '<AmpMask> cannot mask: the Session Replay native module is present but neither SRMaskView nor AMPMaskComponentView is registered. Fix the build before shipping.';
+const UNMASKABLE_WARNING =
+  '[AmpMask] The Session Replay native module is present but neither SRMaskView nor AMPMaskComponentView is registered — <AmpMask>/<AmpUnmask> render children UNMASKED. This is a build error (not an expected environment) — fix the build before shipping.';
+
+function createPassthrough(warning: string, devThrowMessage?: string) {
+  return function PassthroughChildren({ children }: { children?: React.ReactNode }) {
+    if (devThrowMessage !== undefined && __DEV__) {
+      throw new Error(devThrowMessage);
+    }
+    warnOnce(warning);
+    return <>{children}</>;
+  };
+}
+const Passthrough = createPassthrough(UNMASKED_WARNING);
+const UnmaskableGuard = createPassthrough(UNMASKABLE_WARNING, UNMASKABLE_MSG);
+
+const NeitherAvailable = RECORDER_PRESENT ? UnmaskableGuard : Passthrough;
+
+export const AmpMask = FABRIC_AVAILABLE ? MaskImpl : PAPER_MASK_AVAILABLE ? FallbackMask : NeitherAvailable;
+export const AmpUnmask = FABRIC_AVAILABLE ? UnmaskImpl : PAPER_MASK_AVAILABLE ? FallbackUnmask : NeitherAvailable;
diff --git a/packages/session-replay-react-native/src/index.tsx b/packages/session-replay-react-native/src/index.tsx
index 11d61946a..d3f081ebb 100644
--- a/packages/session-replay-react-native/src/index.tsx
+++ b/packages/session-replay-react-native/src/index.tsx
@@ -14,3 +14,21 @@ export { SessionReplayPlugin } from './plugin-session-replay';
 export type { SessionReplayPluginConfig } from './plugin-session-replay-config';
 
 export { AmpMaskView } from './amp-mask-view';
+
+import type { ComponentType } from 'react';
+import type { MaskProps, UnmaskProps } from './Mask.types';
+
+const g = global as unknown as { RN$Bridgeless?: boolean; nativeFabricUIManager?: unknown };
+const isNewArch = g.RN$Bridgeless === true || g.nativeFabricUIManager != null;
+/**
+ * Layout-transparent Session Replay masking.
+ * `<AmpMask>` masks its children; `<AmpUnmask>` exempts children inside a masked region.
+ * Requires the New Architecture (React Native >= 0.77). On the Old Architecture:
+ * throws in dev, falls back to `<AmpMaskView>` (masked but layout-unsafe) in prod.
+ * @experimental Subject to change while experimental.
+ */
+// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment
+export const { AmpMask, AmpUnmask }: { AmpMask: ComponentType<MaskProps>; AmpUnmask: ComponentType<UnmaskProps> } =
+  isNewArch ? require('./fabric/MaskFabric') : require('./paper/MaskPaper');
+// Named AmpMaskLevel because `MaskLevel` is already exported from './session-replay-config'.
+export type { MaskProps, UnmaskProps, AmpMaskLevel } from './Mask.types';
diff --git a/packages/session-replay-react-native/src/mask-fallback.tsx b/packages/session-replay-react-native/src/mask-fallback.tsx
new file mode 100644
index 000000000..f6d0b736a
--- /dev/null
+++ b/packages/session-replay-react-native/src/mask-fallback.tsx
@@ -0,0 +1,60 @@
+import React from 'react';
+import type { ReactElement, ReactNode } from 'react';
+import { AmpMaskView } from './amp-mask-view';
+import { ampMaskViewMaskProp } from './Mask.types';
+import type { AmpMaskLevel } from './Mask.types';
+
+let warned = false;
+
+/** Logs at most one degraded-masking error per app session, across all fallback paths. */
+export function warnOnce(message: string) {
+  if (!warned) {
+    warned = true;
+    console.error(message);
+  }
+}
+
+interface FallbackOptions {
+  /** `mask` value forced onto `<AmpMaskView>`; 'from-maskLevel' derives it from the caller's `maskLevel` prop. */
+  mask: 'amp-unmask' | 'from-maskLevel';
+  /** Passed to {@link warnOnce} on every render. */
+  warning: string;
+  /** When set, dev builds throw this instead of rendering the fallback. */
+  devThrowMessage?: string;
+}
+
+/**
+ * Builds an `<AmpMask>`/`<AmpUnmask>` stand-in that renders through the Paper
+ * `<AmpMaskView>`: privacy-safe (content stays masked) but not
+ * layout-transparent. Used when the Fabric `SRMaskView` isn't available —
+ * Old-Architecture apps and New-Architecture build misconfigurations.
+ *
+ * Fail-closed rules, enforced at runtime because untyped callers can spread
+ * arbitrary props even though the public types omit them:
+ * `style`/`enabled`/`mask` are stripped, and the forced `mask` value is
+ * applied after the caller's props so it can never be overridden.
+ */
+export function createAmpMaskViewFallback<P extends { children?: ReactNode }>(
+  options: FallbackOptions,
+): (props: P) => ReactElement {
+  return function AmpMaskViewFallback(props: P) {
+    if (options.devThrowMessage !== undefined && __DEV__) {
+      throw new Error(options.devThrowMessage);
+    }
+    warnOnce(options.warning);
+    const {
+      children,
+      maskLevel,
+      style: _style,
+      enabled: _enabled,
+      mask: _mask,
+      ...safeProps
+    } = props as P & { maskLevel?: AmpMaskLevel; style?: unknown; enabled?: boolean; mask?: unknown };
+    const mask = options.mask === 'amp-unmask' ? 'amp-unmask' : ampMaskViewMaskProp(maskLevel);
+    return (
+      <AmpMaskView {...safeProps} mask={mask}>
+        {children}
+      </AmpMaskView>
+    );
+  };
+}
diff --git a/packages/session-replay-react-native/src/paper/MaskPaper.tsx b/packages/session-replay-react-native/src/paper/MaskPaper.tsx
new file mode 100644
index 000000000..107550b94
--- /dev/null
+++ b/packages/session-replay-react-native/src/paper/MaskPaper.tsx
@@ -0,0 +1,24 @@
+import { createAmpMaskViewFallback } from '../mask-fallback';
+import type { MaskProps, UnmaskProps } from '../Mask.types';
+
+const MSG = '<AmpMask> requires the New Architecture. Use <AmpMaskView> on the Old Architecture.';
+const WARNING =
+  '[AmpMask] Old Architecture detected — falling back to AmpMaskView (layout-unsafe). Use <AmpMaskView> on Old Arch.';
+
+/**
+ * Old-Architecture guard: dev builds throw (the developer is using an
+ * unsupported component); production falls back to `<AmpMaskView>` —
+ * privacy-safe but layout-unsafe. `enabled` is ignored: the fallback fails
+ * toward privacy.
+ */
+export const AmpMask = createAmpMaskViewFallback<MaskProps>({
+  mask: 'from-maskLevel',
+  warning: WARNING,
+  devThrowMessage: MSG,
+});
+
+export const AmpUnmask = createAmpMaskViewFallback<UnmaskProps>({
+  mask: 'amp-unmask',
+  warning: WARNING,
+  devThrowMessage: MSG,
+});
diff --git a/packages/session-replay-react-native/test/Mask.types.test.ts b/packages/session-replay-react-native/test/Mask.types.test.ts
new file mode 100644
index 000000000..bcc509c0b
--- /dev/null
+++ b/packages/session-replay-react-native/test/Mask.types.test.ts
@@ -0,0 +1,24 @@
+import type { AmpMaskLevel, MaskProps, UnmaskProps } from '../src/Mask.types';
+
+describe('Mask.types', () => {
+  it('should export AmpMaskLevel type', () => {
+    const level: AmpMaskLevel = 'block';
+    expect(level).toBe('block');
+  });
+
+  it('should export MaskProps interface', () => {
+    const props: MaskProps = {
+      enabled: false,
+      maskLevel: 'mask',
+      children: null,
+    };
+    expect(props).toBeTruthy();
+  });
+
+  it('should export UnmaskProps interface', () => {
+    const props: UnmaskProps = {
+      children: null,
+    };
+    expect(props).toBeTruthy();
+  });
+});
diff --git a/packages/session-replay-react-native/test/__mocks__/react-native.ts b/packages/session-replay-react-native/test/__mocks__/react-native.ts
index bfc7f6278..6c2efabe2 100644
--- a/packages/session-replay-react-native/test/__mocks__/react-native.ts
+++ b/packages/session-replay-react-native/test/__mocks__/react-native.ts
@@ -29,3 +29,7 @@ export const Platform = {
 };
 
 export const requireNativeComponent = jest.fn((_componentName: string) => _componentName);
+
+export const UIManager = {
+  hasViewManagerConfig: jest.fn((_name: string) => true),
+};
diff --git a/packages/session-replay-react-native/test/fabric/MaskFabric.test.tsx b/packages/session-replay-react-native/test/fabric/MaskFabric.test.tsx
new file mode 100644
index 000000000..ce098a114
--- /dev/null
+++ b/packages/session-replay-react-native/test/fabric/MaskFabric.test.tsx
@@ -0,0 +1,405 @@
+// The spec imports the default export from the deep RN submodule path (see
+// test/specs/SRMaskViewNativeComponent.test.ts for why this needs its own mock).
+// With this mock, SRMaskViewNative under test is the string 'SRMaskView', so a
+// rendered element's `type` is `'SRMaskView'`.
+jest.mock('react-native/Libraries/Utilities/codegenNativeComponent', () => ({
+  __esModule: true,
+  default: (name: string) => name,
+}));
+
+// Use the manual mock from __mocks__ directory (adds UIManager.hasViewManagerConfig).
+jest.mock('react-native');
+
+import React from 'react';
+import type { ReactElement, ReactNode } from 'react';
+import { NativeModules, TurboModuleRegistry, UIManager } from 'react-native';
+import type { MaskProps, UnmaskProps } from '../../src/Mask.types';
+
+// Shape of the props MaskFabric forwards onto the native SRMaskView element.
+interface NativeMaskElementProps {
+  enabled: boolean;
+  unmask: boolean;
+  maskLevel: string;
+  style: { display: string };
+  children?: ReactNode;
+}
+
+// Shape of the props on the passthrough Fragment element.
+interface PassthroughElementProps {
+  children?: ReactNode;
+}
+
+// Shape of the props MaskFabric forwards onto the fallback AmpMaskView element.
+interface FallbackMaskElementProps {
+  mask: 'amp-mask' | 'amp-unmask' | 'amp-block';
+  enabled?: boolean;
+  style?: unknown;
+  children?: ReactNode;
+}
+
+type NativeMaskComponent = (props: MaskProps) => ReactElement<NativeMaskElementProps> | null;
+type NativeUnmaskComponent = (props: UnmaskProps) => ReactElement<NativeMaskElementProps> | null;
+type PassthroughMaskComponent = (props: MaskProps) => ReactElement<PassthroughElementProps> | null;
+type PassthroughUnmaskComponent = (props: UnmaskProps) => ReactElement<PassthroughElementProps> | null;
+type FallbackMaskComponent = (props: MaskProps) => ReactElement<FallbackMaskElementProps> | null;
+type FallbackUnmaskComponent = (props: UnmaskProps) => ReactElement<FallbackMaskElementProps> | null;
+
+interface NativeMaskFabricModule {
+  AmpMask: NativeMaskComponent;
+  AmpUnmask: NativeUnmaskComponent;
+}
+
+interface PassthroughMaskFabricModule {
+  AmpMask: PassthroughMaskComponent;
+  AmpUnmask: PassthroughUnmaskComponent;
+}
+
+interface FallbackMaskFabricModule {
+  AmpMask: FallbackMaskComponent;
+  AmpUnmask: FallbackUnmaskComponent;
+}
+
+function loadMaskFabricModule<T>(): T {
+  let mod: T | undefined;
+  // isolateModules re-evaluates MaskFabric's module scope (so NATIVE_AVAILABLE is
+  // recomputed against the current hasViewManagerConfig mock return value) while
+  // preserving the identity of already-mocked modules like 'react-native', so the
+  // top-level `UIManager` import above stays the same object MaskFabric resolves.
+  jest.isolateModules(() => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    mod = require('../../src/fabric/MaskFabric') as T;
+  });
+  return mod as T;
+}
+
+const mockHasViewManagerConfig = UIManager.hasViewManagerConfig as jest.Mock;
+
+// The mock's NativeModules export is a plain object (see
+// test/__mocks__/react-native.ts) with AMPNativeSessionReplay present by
+// default, and TurboModuleRegistry.get/getEnforcing are jest.fn mocks that
+// resolve the same module. Tier-3 tests need to toggle the recorder's
+// presence to distinguish "recorder truly absent" from "recorder present but
+// unreachable" — mutate BOTH resolution paths (NativeModules and
+// TurboModuleRegistry.get) since MaskFabric now probes the same way
+// src/native-module.ts does, and always restore so other suites still see
+// the module.
+const nativeModules = NativeModules as { AMPNativeSessionReplay?: unknown };
+const originalAmpNativeSessionReplay = nativeModules.AMPNativeSessionReplay;
+const mockTurboModuleRegistryGet = TurboModuleRegistry.get as jest.Mock;
+function removeRecorder(): void {
+  delete nativeModules.AMPNativeSessionReplay;
+  mockTurboModuleRegistryGet.mockReturnValue(null);
+}
+function restoreRecorder(): void {
+  nativeModules.AMPNativeSessionReplay = originalAmpNativeSessionReplay;
+  mockTurboModuleRegistryGet.mockReturnValue(originalAmpNativeSessionReplay);
+}
+
+describe('MaskFabric', () => {
+  describe('when native view manager is available', () => {
+    let AmpMask: NativeMaskComponent;
+    let AmpUnmask: NativeUnmaskComponent;
+
+    beforeEach(() => {
+      mockHasViewManagerConfig.mockReturnValue(true);
+      ({ AmpMask, AmpUnmask } = loadMaskFabricModule<NativeMaskFabricModule>());
+    });
+
+    it('probes hasViewManagerConfig with SRMaskView', () => {
+      expect(mockHasViewManagerConfig).toHaveBeenCalledWith('SRMaskView');
+    });
+
+    it('renders SRMaskView with default enabled=true, unmask=false, maskLevel="mask"', () => {
+      const child = React.createElement('Text', null, 'hello');
+      const rendered = AmpMask({ children: child });
+
+      expect(rendered?.type).toBe('SRMaskView');
+      expect(rendered?.props.enabled).toBe(true);
+      expect(rendered?.props.unmask).toBe(false);
+      expect(rendered?.props.maskLevel).toBe('mask');
+      expect(rendered?.props.children).toBe(child);
+      expect(rendered?.props.style).toEqual({ display: 'contents' });
+    });
+
+    it('respects explicit enabled=false', () => {
+      const rendered = AmpMask({ enabled: false, children: null });
+      expect(rendered?.props.enabled).toBe(false);
+    });
+
+    it('respects explicit maskLevel="block"', () => {
+      const rendered = AmpMask({ maskLevel: 'block', children: null });
+      expect(rendered?.props.maskLevel).toBe('block');
+    });
+
+    it('always renders unmask=false for AmpMask regardless of caller props', () => {
+      const rendered = AmpMask({ children: null });
+      expect(rendered?.props.unmask).toBe(false);
+    });
+
+    it('forces style to display:contents even when caller passes their own style', () => {
+      // `style` is a type error by design (see Mask.types.ts) but is still
+      // runtime-defended against untyped/JS callers, hence the cast here.
+      const rendered = AmpMask({ children: null, style: { flex: 1 } } as unknown as MaskProps);
+      expect(rendered?.props.style).toEqual({ display: 'contents' });
+    });
+
+    it('renders AmpUnmask as SRMaskView with unmask=true, enabled=true', () => {
+      const child = React.createElement('Text', null, 'hello');
+      const rendered = AmpUnmask({ children: child });
+
+      expect(rendered?.type).toBe('SRMaskView');
+      expect(rendered?.props.unmask).toBe(true);
+      expect(rendered?.props.enabled).toBe(true);
+      expect(rendered?.props.maskLevel).toBe('mask');
+      expect(rendered?.props.children).toBe(child);
+      expect(rendered?.props.style).toEqual({ display: 'contents' });
+    });
+
+    it('forces style to display:contents for AmpUnmask even when caller passes their own style', () => {
+      // `style` is a type error by design (see Mask.types.ts) but is still
+      // runtime-defended against untyped/JS callers, hence the cast here.
+      const rendered = AmpUnmask({ children: null, style: { flex: 1 } } as unknown as UnmaskProps);
+      expect(rendered?.props.style).toEqual({ display: 'contents' });
+    });
+  });
+
+  describe('when SRMaskView is unavailable but AMPMaskComponentView is available (fail-closed fallback)', () => {
+    let AmpMask: FallbackMaskComponent;
+    let AmpUnmask: FallbackUnmaskComponent;
+    let errorSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      mockHasViewManagerConfig.mockImplementation((name: string) => name === 'AMPMaskComponentView');
+      errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+      ({ AmpMask, AmpUnmask } = loadMaskFabricModule<FallbackMaskFabricModule>());
+    });
+
+    afterEach(() => {
+      errorSpy.mockRestore();
+    });
+
+    it('probes hasViewManagerConfig with SRMaskView and AMPMaskComponentView', () => {
+      expect(mockHasViewManagerConfig).toHaveBeenCalledWith('SRMaskView');
+      expect(mockHasViewManagerConfig).toHaveBeenCalledWith('AMPMaskComponentView');
+    });
+
+    it('AmpMask renders AmpMaskView with mask="amp-mask" by default', () => {
+      const child = React.createElement('Text', null, 'hello');
+      const rendered = AmpMask({ children: child });
+
+      expect(rendered?.type).toBe('AMPMaskComponentView');
+      expect(rendered?.props.mask).toBe('amp-mask');
+      expect(rendered?.props.children).toBe(child);
+    });
+
+    it('AmpMask renders AmpMaskView with mask="amp-block" when maskLevel="block"', () => {
+      const rendered = AmpMask({ maskLevel: 'block', children: null });
+
+      expect(rendered?.type).toBe('AMPMaskComponentView');
+      expect(rendered?.props.mask).toBe('amp-block');
+    });
+
+    it('AmpUnmask renders AmpMaskView with mask="amp-unmask"', () => {
+      const child = React.createElement('Text', null, 'hello');
+      const rendered = AmpUnmask({ children: child });
+
+      expect(rendered?.type).toBe('AMPMaskComponentView');
+      expect(rendered?.props.mask).toBe('amp-unmask');
+      expect(rendered?.props.children).toBe(child);
+    });
+
+    it('ignores enabled=false and still masks (fails toward privacy)', () => {
+      const rendered = AmpMask({ enabled: false, children: null });
+
+      expect(rendered?.type).toBe('AMPMaskComponentView');
+      expect(rendered?.props.mask).toBe('amp-mask');
+    });
+
+    it('logs a one-time console.error warning that content stays MASKED via AmpMaskView, across multiple renders', () => {
+      AmpMask({ children: React.createElement('Text', null, 'a') });
+      AmpMask({ children: React.createElement('Text', null, 'b') });
+      AmpUnmask({ children: React.createElement('Text', null, 'c') });
+
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('MASKED'));
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('AmpMaskView'));
+    });
+
+    it('a caller-supplied mask prop does not override the forced value on AmpMask', () => {
+      // Untyped/JS callers can spread a stray `mask` prop through; the
+      // forced value must win. Cast needed since `mask` isn't on MaskProps.
+      const rendered = AmpMask({ children: null, mask: 'amp-unmask' } as unknown as MaskProps);
+      expect(rendered?.props.mask).toBe('amp-mask');
+    });
+
+    it('a caller-supplied mask prop does not override the forced value on AmpUnmask', () => {
+      const rendered = AmpUnmask({ children: null, mask: 'amp-mask' } as unknown as UnmaskProps);
+      expect(rendered?.props.mask).toBe('amp-unmask');
+    });
+
+    it('does not forward enabled or style onto the rendered AmpMaskView element (AmpMask)', () => {
+      const rendered = AmpMask({
+        enabled: false,
+        children: null,
+        style: { flex: 1 },
+      } as unknown as MaskProps);
+      expect(rendered?.props.enabled).toBeUndefined();
+      expect(rendered?.props.style).toBeUndefined();
+    });
+
+    it('does not forward enabled or style onto the rendered AmpMaskView element (AmpUnmask)', () => {
+      const rendered = AmpUnmask({
+        children: null,
+        enabled: false,
+        style: { flex: 1 },
+      } as unknown as UnmaskProps);
+      expect(rendered?.props.enabled).toBeUndefined();
+      expect(rendered?.props.style).toBeUndefined();
+    });
+  });
+
+  describe('when neither SRMaskView nor AMPMaskComponentView is available and the recorder is absent (passthrough)', () => {
+    let AmpMask: PassthroughMaskComponent;
+    let AmpUnmask: PassthroughUnmaskComponent;
+    let errorSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      mockHasViewManagerConfig.mockImplementation(() => false);
+      removeRecorder();
+      errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+      ({ AmpMask, AmpUnmask } = loadMaskFabricModule<PassthroughMaskFabricModule>());
+    });
+
+    afterEach(() => {
+      errorSpy.mockRestore();
+      restoreRecorder();
+    });
+
+    it('probes hasViewManagerConfig with SRMaskView and AMPMaskComponentView', () => {
+      expect(mockHasViewManagerConfig).toHaveBeenCalledWith('SRMaskView');
+      expect(mockHasViewManagerConfig).toHaveBeenCalledWith('AMPMaskComponentView');
+    });
+
+    it('AmpMask renders children directly without SRMaskView in the tree', () => {
+      const child = React.createElement('Text', null, 'hello');
+      const rendered = AmpMask({ children: child });
+
+      expect(rendered?.type).not.toBe('SRMaskView');
+      // Fragment wrapping children.
+      expect(rendered?.type).toBe(React.Fragment);
+      expect(rendered?.props.children).toBe(child);
+    });
+
+    it('AmpUnmask renders children directly without SRMaskView in the tree', () => {
+      const child = React.createElement('Text', null, 'hello');
+      const rendered = AmpUnmask({ children: child });
+
+      expect(rendered?.type).not.toBe('SRMaskView');
+      expect(rendered?.type).toBe(React.Fragment);
+      expect(rendered?.props.children).toBe(child);
+    });
+
+    it('logs a one-time console.error warning that children render UNMASKED, across multiple renders', () => {
+      AmpMask({ children: React.createElement('Text', null, 'a') });
+      AmpMask({ children: React.createElement('Text', null, 'b') });
+      AmpUnmask({ children: React.createElement('Text', null, 'c') });
+
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('UNMASKED'));
+    });
+  });
+
+  describe('when neither SRMaskView nor AMPMaskComponentView is available but the recorder IS present (should-be-unreachable build error)', () => {
+    beforeEach(() => {
+      mockHasViewManagerConfig.mockImplementation(() => false);
+      // Recorder present by default in the mock; be explicit for clarity.
+      restoreRecorder();
+    });
+
+    describe('in development (__DEV__ = true)', () => {
+      it('AmpMask throws a clear build-error message instead of silently passing content through', () => {
+        const { AmpMask } = loadMaskFabricModule<PassthroughMaskFabricModule>();
+        expect(() => AmpMask({ children: null })).toThrow(/neither SRMaskView nor AMPMaskComponentView is registered/);
+      });
+
+      it('AmpUnmask throws a clear build-error message instead of silently passing content through', () => {
+        const { AmpUnmask } = loadMaskFabricModule<PassthroughMaskFabricModule>();
+        expect(() => AmpUnmask({ children: null })).toThrow(
+          /neither SRMaskView nor AMPMaskComponentView is registered/,
+        );
+      });
+    });
+
+    describe('in production (__DEV__ = false)', () => {
+      const globalWithDev = global as unknown as { __DEV__: boolean };
+      let originalDev: boolean;
+      let errorSpy: jest.SpyInstance;
+
+      beforeEach(() => {
+        originalDev = globalWithDev.__DEV__;
+        globalWithDev.__DEV__ = false;
+        errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+      });
+
+      afterEach(() => {
+        globalWithDev.__DEV__ = originalDev;
+        errorSpy.mockRestore();
+      });
+
+      it('AmpMask warns once and renders children directly (Fragment)', () => {
+        const { AmpMask } = loadMaskFabricModule<PassthroughMaskFabricModule>();
+        const child = React.createElement('Text', null, 'hello');
+        const rendered = AmpMask({ children: child });
+
+        expect(rendered?.type).toBe(React.Fragment);
+        expect(rendered?.props.children).toBe(child);
+        expect(errorSpy).toHaveBeenCalledTimes(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('build error'));
+      });
+
+      it('AmpUnmask warns once (shared with AmpMask) and renders children directly (Fragment)', () => {
+        const { AmpMask, AmpUnmask } = loadMaskFabricModule<PassthroughMaskFabricModule>();
+        AmpMask({ children: React.createElement('Text', null, 'a') });
+        const child = React.createElement('Text', null, 'b');
+        const rendered = AmpUnmask({ children: child });
+
+        expect(rendered?.type).toBe(React.Fragment);
+        expect(rendered?.props.children).toBe(child);
+        expect(errorSpy).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
+
+  describe('when the recorder is reachable ONLY via TurboModuleRegistry (NativeModules interop proxy misses it)', () => {
+    // Regression test for the Bugbot finding: the probe must resolve the
+    // native module the same way src/native-module.ts does
+    // (TurboModuleRegistry.get first), not solely via NativeModules. If the
+    // TurboModule is linked but not exposed on the NativeModules interop
+    // proxy, the old NativeModules-only probe would read false and the
+    // Passthrough tier would render children UNMASKED while the recorder can
+    // still record — exactly the scenario simulated here.
+    beforeEach(() => {
+      mockHasViewManagerConfig.mockImplementation(() => false);
+      delete nativeModules.AMPNativeSessionReplay;
+      mockTurboModuleRegistryGet.mockReturnValue(originalAmpNativeSessionReplay);
+    });
+
+    afterEach(() => {
+      restoreRecorder();
+    });
+
+    describe('in development (__DEV__ = true)', () => {
+      it('AmpMask is the UnmaskableGuard: throws a build-error message rather than silently passing through', () => {
+        const { AmpMask } = loadMaskFabricModule<PassthroughMaskFabricModule>();
+        expect(() => AmpMask({ children: null })).toThrow(/neither SRMaskView nor AMPMaskComponentView is registered/);
+      });
+
+      it('AmpUnmask is the UnmaskableGuard: throws a build-error message rather than silently passing through', () => {
+        const { AmpUnmask } = loadMaskFabricModule<PassthroughMaskFabricModule>();
+        expect(() => AmpUnmask({ children: null })).toThrow(
+          /neither SRMaskView nor AMPMaskComponentView is registered/,
+        );
+      });
+    });
+  });
+});
diff --git a/packages/session-replay-react-native/test/index.arch.test.tsx b/packages/session-replay-react-native/test/index.arch.test.tsx
new file mode 100644
index 000000000..ab0813c08
--- /dev/null
+++ b/packages/session-replay-react-native/test/index.arch.test.tsx
@@ -0,0 +1,151 @@
+// index -> fabric -> src/specs/SRMaskViewNativeComponent needs the deep codegen mock
+// (see test/specs/SRMaskViewNativeComponent.test.ts and test/fabric/MaskFabric.test.tsx
+// for why the manual react-native mock alone doesn't cover this deep default import).
+jest.mock('react-native/Libraries/Utilities/codegenNativeComponent', () => ({
+  __esModule: true,
+  default: (name: string) => name,
+}));
+
+// Use the manual mock from __mocks__ directory (adds UIManager.hasViewManagerConfig,
+// which defaults to returning true).
+jest.mock('react-native');
+
+import type { ReactElement, ReactNode } from 'react';
+import type { MaskProps, UnmaskProps, AmpMaskLevel } from '../src/Mask.types';
+import type { MaskLevel } from '../src/session-replay-config';
+
+// Shape of props on the native SRMaskView element rendered by fabric's AmpMask/AmpUnmask.
+interface NativeMaskElementProps {
+  children?: ReactNode;
+}
+
+type AnyMaskComponent = (props: MaskProps) => ReactElement<NativeMaskElementProps> | null;
+type AnyUnmaskComponent = (props: UnmaskProps) => ReactElement<NativeMaskElementProps> | null;
+
+interface IndexModule {
+  init: unknown;
+  start: unknown;
+  stop: unknown;
+  flush: unknown;
+  getSessionId: unknown;
+  setSessionId: unknown;
+  setDeviceId: unknown;
+  getSessionReplayProperties: unknown;
+  SessionReplayPlugin: unknown;
+  AmpMaskView: unknown;
+  AmpMask: AnyMaskComponent;
+  AmpUnmask: AnyUnmaskComponent;
+}
+
+function loadIndexModule(): IndexModule {
+  let mod: IndexModule | undefined;
+  // isolateModules re-evaluates index's module scope (so isNewArch is recomputed
+  // against the globals set by the caller) while preserving the identity of
+  // already-mocked modules like 'react-native' — see test/fabric/MaskFabric.test.tsx
+  // for why bare jest.resetModules + a static import would break mock identity.
+  jest.isolateModules(() => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    mod = require('../src/index') as IndexModule;
+  });
+  return mod as IndexModule;
+}
+
+const FABRIC_MSG_TYPE = 'SRMaskView';
+const PAPER_THROW_MSG = '<AmpMask> requires the New Architecture. Use <AmpMaskView> on the Old Architecture.';
+
+describe('index arch switch', () => {
+  afterEach(() => {
+    delete (global as unknown as { RN$Bridgeless?: boolean }).RN$Bridgeless;
+    delete (global as unknown as { nativeFabricUIManager?: unknown }).nativeFabricUIManager;
+  });
+
+  describe('RN$Bridgeless === true (bridgeless new arch)', () => {
+    let index: IndexModule;
+
+    beforeEach(() => {
+      (global as unknown as { RN$Bridgeless?: boolean }).RN$Bridgeless = true;
+      index = loadIndexModule();
+    });
+
+    it('resolves AmpMask/AmpUnmask from the fabric variant', () => {
+      const rendered = index.AmpMask({ children: null });
+      expect(rendered?.type).toBe(FABRIC_MSG_TYPE);
+
+      const renderedUnmask = index.AmpUnmask({ children: null });
+      expect(renderedUnmask?.type).toBe(FABRIC_MSG_TYPE);
+    });
+  });
+
+  describe('nativeFabricUIManager != null (fabric new arch)', () => {
+    let index: IndexModule;
+
+    beforeEach(() => {
+      (global as unknown as { nativeFabricUIManager?: unknown }).nativeFabricUIManager = {};
+      index = loadIndexModule();
+    });
+
+    it('resolves AmpMask/AmpUnmask from the fabric variant', () => {
+      const rendered = index.AmpMask({ children: null });
+      expect(rendered?.type).toBe(FABRIC_MSG_TYPE);
+
+      const renderedUnmask = index.AmpUnmask({ children: null });
+      expect(renderedUnmask?.type).toBe(FABRIC_MSG_TYPE);
+    });
+  });
+
+  describe('neither global set (old arch)', () => {
+    let index: IndexModule;
+
+    beforeEach(() => {
+      index = loadIndexModule();
+    });
+
+    it('resolves AmpMask/AmpUnmask from the paper variant', () => {
+      // __DEV__ is true under jest; paper's AmpMask/AmpUnmask throw synchronously
+      // when called, per src/paper/MaskPaper.tsx. Requiring the module does not throw.
+      expect(() => index.AmpMask({ children: null })).toThrow(PAPER_THROW_MSG);
+      expect(() => index.AmpUnmask({ children: null })).toThrow(PAPER_THROW_MSG);
+    });
+  });
+
+  describe('existing exports remain present regardless of arch', () => {
+    let index: IndexModule;
+
+    beforeEach(() => {
+      index = loadIndexModule();
+    });
+
+    it('keeps all pre-existing function/class exports', () => {
+      expect(index.init).toBeDefined();
+      expect(index.start).toBeDefined();
+      expect(index.stop).toBeDefined();
+      expect(index.flush).toBeDefined();
+      expect(index.getSessionId).toBeDefined();
+      expect(index.setSessionId).toBeDefined();
+      expect(index.setDeviceId).toBeDefined();
+      expect(index.getSessionReplayProperties).toBeDefined();
+      expect(index.SessionReplayPlugin).toBeDefined();
+    });
+
+    it('keeps AmpMaskView export (=== "AMPMaskComponentView" under the mock)', () => {
+      expect(index.AmpMaskView).toBe('AMPMaskComponentView');
+    });
+
+    it('exports AmpMask and AmpUnmask', () => {
+      expect(index.AmpMask).toBeDefined();
+      expect(index.AmpUnmask).toBeDefined();
+    });
+
+    it('typechecks old MaskLevel and new AmpMaskLevel/MaskProps/UnmaskProps types side by side', () => {
+      const oldLevel: MaskLevel = 'conservative';
+      const newLevel: AmpMaskLevel = 'block';
+      const maskProps: MaskProps = { enabled: true, maskLevel: newLevel, children: null };
+      const unmaskProps: UnmaskProps = { children: null };
+
+      expect(oldLevel).toBe('conservative');
+      expect(newLevel).toBe('block');
+      expect(maskProps).toBeTruthy();
+      expect(unmaskProps).toBeTruthy();
+    });
+  });
+});
diff --git a/packages/session-replay-react-native/test/paper/MaskPaper.test.tsx b/packages/session-replay-react-native/test/paper/MaskPaper.test.tsx
new file mode 100644
index 000000000..fc93a882f
--- /dev/null
+++ b/packages/session-replay-react-native/test/paper/MaskPaper.test.tsx
@@ -0,0 +1,119 @@
+// FIXME: remove these eslint rules
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+jest.mock('react-native');
+
+import type { MaskProps, UnmaskProps } from '../../src/Mask.types';
+
+const MSG = '<AmpMask> requires the New Architecture. Use <AmpMaskView> on the Old Architecture.';
+
+type MaskPaperModule = typeof import('../../src/paper/MaskPaper');
+
+function loadMaskPaper(): MaskPaperModule {
+  return require('../../src/paper/MaskPaper') as MaskPaperModule;
+}
+
+function setDev(value: boolean): void {
+  (global as unknown as { __DEV__: boolean }).__DEV__ = value;
+}
+
+describe('MaskPaper', () => {
+  afterEach(() => {
+    setDev(true);
+    jest.resetModules();
+    jest.restoreAllMocks();
+  });
+
+  describe('when __DEV__ is true', () => {
+    it('AmpMask throws the documented message', () => {
+      setDev(true);
+      const { AmpMask } = loadMaskPaper();
+      expect(() => AmpMask({ children: null })).toThrow(MSG);
+    });
+
+    it('AmpUnmask throws the documented message', () => {
+      setDev(true);
+      const { AmpUnmask } = loadMaskPaper();
+      expect(() => AmpUnmask({ children: null })).toThrow(MSG);
+    });
+  });
+
+  describe('when __DEV__ is false', () => {
+    beforeEach(() => {
+      setDev(false);
+      jest.resetModules();
+    });
+
+    it('AmpMask renders AmpMaskView with mask="amp-mask" by default', () => {
+      const { AmpMask } = loadMaskPaper();
+      const element = AmpMask({ children: 'hello' });
+      expect(element.type).toBe('AMPMaskComponentView');
+      expect(element.props.mask).toBe('amp-mask');
+      expect(element.props.children).toBe('hello');
+    });
+
+    it('AmpMask renders AmpMaskView with mask="amp-block" when maskLevel="block"', () => {
+      const { AmpMask } = loadMaskPaper();
+      const element = AmpMask({ maskLevel: 'block', children: 'hello' });
+      expect(element.type).toBe('AMPMaskComponentView');
+      expect(element.props.mask).toBe('amp-block');
+    });
+
+    it('AmpUnmask renders AmpMaskView with mask="amp-unmask"', () => {
+      const { AmpUnmask } = loadMaskPaper();
+      const element = AmpUnmask({ children: 'world' });
+      expect(element.type).toBe('AMPMaskComponentView');
+      expect(element.props.mask).toBe('amp-unmask');
+      expect(element.props.children).toBe('world');
+    });
+
+    it('calls console.error exactly once across multiple AmpMask + AmpUnmask calls', () => {
+      const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+      const { AmpMask, AmpUnmask } = loadMaskPaper();
+
+      AmpMask({ children: null });
+      AmpMask({ maskLevel: 'block', children: null });
+      AmpUnmask({ children: null });
+
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('AmpMaskView'));
+    });
+
+    it('a caller-supplied mask prop does not override the forced value on AmpMask', () => {
+      const { AmpMask } = loadMaskPaper();
+      // Untyped/JS callers can spread a stray `mask` prop through; the
+      // forced value must win. Cast needed since `mask` isn't on MaskProps.
+      const element = AmpMask({ children: null, mask: 'amp-unmask' } as unknown as MaskProps);
+      expect(element.props.mask).toBe('amp-mask');
+    });
+
+    it('a caller-supplied mask prop does not override the forced value on AmpUnmask', () => {
+      const { AmpUnmask } = loadMaskPaper();
+      const element = AmpUnmask({ children: null, mask: 'amp-mask' } as unknown as UnmaskProps);
+      expect(element.props.mask).toBe('amp-unmask');
+    });
+
+    it('does not forward enabled or style onto the rendered AmpMaskView element (AmpMask)', () => {
+      const { AmpMask } = loadMaskPaper();
+      const element = AmpMask({
+        enabled: false,
+        children: null,
+        style: { flex: 1 },
+      } as unknown as MaskProps);
+      expect(element.props.enabled).toBeUndefined();
+      expect(element.props.style).toBeUndefined();
+    });
+
+    it('does not forward enabled or style onto the rendered AmpMaskView element (AmpUnmask)', () => {
+      const { AmpUnmask } = loadMaskPaper();
+      const element = AmpUnmask({
+        children: null,
+        enabled: false,
+        style: { flex: 1 },
+      } as unknown as UnmaskProps);
+      expect(element.props.enabled).toBeUndefined();
+      expect(element.props.style).toBeUndefined();
+    });
+  });
+});