diff --git a/docs/docs/guides/view-components.md b/docs/docs/guides/view-components.md
index b44f195d8e..ff28b9812f 100644
--- a/docs/docs/guides/view-components.md
+++ b/docs/docs/guides/view-components.md
@@ -158,6 +158,70 @@ function App() {
 }
 ```
 
+## Self-measurement (`MeasurableView`)
+
+By default a `HybridView` is sized by its children or by explicit style props. To instead size a view to its **own content** - a `<Text>` that grows to fit its string, a chart that derives a height from its data - conform your native implementation to `MeasurableView`. Nitro then makes the view a measurable Yoga **leaf**: Yoga calls your `measureContent` during layout and uses the returned `Size` as the intrinsic size, so no explicit `height` is needed. Like [`RecyclableView`](#recycling) it's a native opt-in, so **your `.nitro.ts` spec is unchanged**:
+
+```ts title="NitroTextView.nitro.ts"
+export interface NitroTextViewProps extends HybridViewProps {
+  text: string
+  fontSize: number
+}
+export type NitroTextView = HybridView<NitroTextViewProps>
+```
+
+<Tabs groupId="native-view-language">
+  <TabItem value="swift" label="Swift" default>
+    ```swift title="HybridNitroTextView.swift"
+    class HybridNitroTextView: HybridNitroTextViewSpec, MeasurableView {
+      let view = UILabel()
+      var text: String = "" { didSet { view.text = text } }
+      var fontSize: Double = 17 { didSet { view.font = .systemFont(ofSize: fontSize) } }
+
+      // `static` - no view instance needed.
+      // highlight-next-line
+      static func measureContent(props: NitroTextViewProps, layoutContext: LayoutContext, layoutConstraints: LayoutConstraints) -> Size {
+        // Measure `props.text` within `layoutConstraints.maximumSize` (off-thread, e.g. NSAttributedString.boundingRect).
+        return Size(width: measuredWidth, height: measuredHeight)
+      }
+    }
+    ```
+  </TabItem>
+  <TabItem value="kotlin" label="Kotlin">
+    ```kotlin title="HybridNitroTextView.kt"
+    class HybridNitroTextView(context: Context) : HybridNitroTextViewSpec() {
+      override val view = TextView(context)
+      override var text: String = "" /* set { view.text = … } */
+      override var fontSize: Double = 17.0 /* set { view.textSize = … } */
+
+      // Kotlin interfaces can't require statics, so measureContent lives on the companion.
+      companion object : MeasurableView<NitroTextViewProps> {
+        override fun measureContent(props: NitroTextViewProps, layoutContext: LayoutContext, layoutConstraints: LayoutConstraints): Size {
+          // Measure `props.text` within `layoutConstraints.maximumSize` (off-thread, e.g. StaticLayout).
+          return Size(measuredWidth, measuredHeight)
+        }
+      }
+    }
+    ```
+  </TabItem>
+</Tabs>
+
+Now `<NitroTextView text="…" fontSize={17} />` grows to fit its text - no `height` in its style:
+
+```jsx
+<NitroTextView text="A long string that wraps onto several lines…" fontSize={17} />
+```
+
+Because Yoga runs `measureContent` on the shadow thread during layout, it has a few hard rules:
+
+- **No view, pure function.** Never touch your native view inside it (it may not exist yet, and runs on another thread). Compute the size from `props` only - Yoga caches the result keyed on `props` + constraints. Use whatever measurement fits your content and is safe off the main thread (text → `boundingRect`/`StaticLayout`, an image → its source dimensions, …).
+- **It's a Yoga leaf**, so a measurable view **can't also host React children** - the two are mutually exclusive (like RN's `<Text>`).
+- `maximumSize.width`/`.height` is `.infinity` on an unconstrained axis (return your intrinsic size) and finite when bounded (measure within it, e.g. to wrap text).
+
+:::caution Not every view can self-measure
+The size must be derivable from `props`, off the main thread, with no mounted view. Content that can only be sized on the main thread or via a live view's layout pass (UIKit `systemLayoutSizeFitting`, Android `View.measure()`) doesn't fit - use flexbox + explicit sizing, or precompute the size and pass it in as props.
+:::
+
 ## Props
 
 Since every `HybridView` is also a `HybridObject`, you can use any type that Nitro supports as a property - including custom types (`interface`), `ArrayBuffer`, and even other `HybridObject`s!
diff --git a/example/src/screens/ViewScreen.tsx b/example/src/screens/ViewScreen.tsx
index c17b84864d..e23d4f04aa 100644
--- a/example/src/screens/ViewScreen.tsx
+++ b/example/src/screens/ViewScreen.tsx
@@ -5,6 +5,7 @@ import { callback, NitroModules } from 'react-native-nitro-modules'
 import { useSafeAreaInsets } from 'react-native-safe-area-context'
 import { useColors } from '../useColors'
 import {
+  MeasuredView,
   HybridTestObjectSwiftKotlin,
   RecyclableTestView,
   TestView,
@@ -14,6 +15,30 @@ import { useIsFocused } from '@react-navigation/native'
 const VIEWS_X = 15
 const VIEWS_Y = 15
 
+
+const MeasuredViewImpl = () => {
+  const [longText, setLongText] = React.useState(false)
+  const measuredText = longText
+    ? 'MeasuredView sizes its own height from this text a long string that wraps onto several lines, so the bordered box grows to fit it. Tap the button to shrink it.'
+    : 'MeasuredView: tap below to grow.'
+
+  return (
+    <View style={styles.measuredWrapper}>
+      <MeasuredView
+        text={measuredText}
+        fontSize={17}
+        style={styles.measuredView}
+      />
+      <View style={styles.measuredButtonRow}>
+        <Button
+          title={longText ? 'Shrink text' : 'Grow text'}
+          onPress={() => setLongText((v) => !v)}
+        />
+      </View>
+    </View>
+  )
+}
+
 export function ViewScreenImpl() {
   const safeArea = useSafeAreaInsets()
   const colors = useColors()
@@ -76,6 +101,8 @@ export function ViewScreenImpl() {
         <Text style={styles.buildTypeText}>{NitroModules.buildType}</Text>
       </View>
 
+      <MeasuredViewImpl />
+
       <View style={styles.resultContainer}>
         <View style={[styles.viewShadow]}>
           <View style={[styles.viewBorder, { borderColor: colors.foreground }]}>
@@ -128,6 +155,23 @@ const styles = StyleSheet.create({
     }),
     fontWeight: 'bold',
   },
+  // No fixed height: the box grows to the height MeasuredView measures.
+  measuredWrapper: {
+    marginHorizontal: 15,
+    marginBottom: 15,
+    padding: 12,
+    borderRadius: 12,
+    borderWidth: 2,
+    borderColor: 'teal',
+    backgroundColor: 'rgba(0, 128, 128, 0.12)',
+  },
+  measuredView: {
+    width: '100%',
+  },
+  measuredButtonRow: {
+    marginTop: 8,
+    alignItems: 'flex-start',
+  },
   segmentedControl: {
     minWidth: 180,
   },
diff --git a/packages/nitrogen/src/views/CppHybridViewComponent.ts b/packages/nitrogen/src/views/CppHybridViewComponent.ts
index 9e9fd47f18..c29bdb72ba 100644
--- a/packages/nitrogen/src/views/CppHybridViewComponent.ts
+++ b/packages/nitrogen/src/views/CppHybridViewComponent.ts
@@ -92,11 +92,16 @@ ${createFileMetadataString(`${component}.hpp`)}
 #include <optional>
 #include <NitroModules/NitroDefines.hpp>
 #include <NitroModules/NitroHash.hpp>
+#include <atomic>
 #include <NitroModules/CachedProp.hpp>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
 
 ${includes.join('\n')}
 
@@ -156,13 +161,61 @@ namespace ${namespace} {
     std::shared_ptr<${propsClassName}> _props;
   };
 
+  /**
+   * The base Shadow Node for the "${spec.name}" View.
+   */
+  using ${shadowNodeClassName}Base = react::ConcreteViewShadowNode<${nameVariable} /* "${HybridT}" */,
+        ${shadowIndent}                                     ${propsClassName} /* custom props */,
+        ${shadowIndent}                                     react::ViewEventEmitter /* default */,
+        ${shadowIndent}                                     ${stateClassName} /* custom state */>;
+
   /**
    * The Shadow Node for the "${spec.name}" View.
+   *
+   * Self-measurement is opt-in: when the native implementation conforms to
+   * \`MeasurableView\`, the platform layer installs \`measureFunction\` once during
+   * view registration and this becomes a measurable Yoga leaf that sizes itself
+   * from its props. Otherwise it stays a normal container whose React children
+   * are laid out by flexbox.
    */
-  using ${shadowNodeClassName} = react::ConcreteViewShadowNode<${nameVariable} /* "${HybridT}" */,
-        ${shadowIndent}                                 ${propsClassName} /* custom props */,
-        ${shadowIndent}                                 react::ViewEventEmitter /* default */,
-        ${shadowIndent}                                 ${stateClassName} /* custom state */>;
+  class ${shadowNodeClassName} final: public ${shadowNodeClassName}Base {
+  public:
+    // Inherit both the create- and clone-constructors.
+    using ${shadowNodeClassName}Base::${shadowNodeClassName}Base;
+
+    /**
+     * A pure (props + constraints) -> size function, run on the Yoga/shadow thread.
+     */
+    using MeasureFunction = react::Size (*)(const react::ViewProps& props,
+                                            const react::LayoutContext& layoutContext,
+                                            const react::LayoutConstraints& layoutConstraints);
+
+    /**
+     * Installed exactly once during view registration (before the first layout
+     * pass), iff the native implementation conforms to \`MeasurableView\`. Read
+     * lock-free on the shadow thread - no map lookup, locking or allocation on
+     * the measure hot-path.
+     */
+    inline static std::atomic<MeasureFunction> measureFunction{nullptr};
+
+    static react::ShadowNodeTraits BaseTraits() {
+      auto traits = ${shadowNodeClassName}Base::BaseTraits();
+      if (measureFunction.load(std::memory_order_acquire) != nullptr) {
+        traits.set(react::ShadowNodeTraits::Trait::LeafYogaNode);
+        traits.set(react::ShadowNodeTraits::Trait::MeasurableYogaNode);
+      }
+      return traits;
+    }
+
+    react::Size measureContent(const react::LayoutContext& layoutContext,
+                               const react::LayoutConstraints& layoutConstraints) const override {
+      const MeasureFunction measure = measureFunction.load(std::memory_order_acquire);
+      if (measure == nullptr) [[unlikely]] {
+        return react::Size{0, 0};
+      }
+      return measure(getConcreteProps(), layoutContext, layoutConstraints);
+    }
+  };
 
   /**
    * The Component Descriptor for the "${spec.name}" View.
diff --git a/packages/nitrogen/src/views/createViewMeasurerShared.ts b/packages/nitrogen/src/views/createViewMeasurerShared.ts
new file mode 100644
index 0000000000..c7424c0542
--- /dev/null
+++ b/packages/nitrogen/src/views/createViewMeasurerShared.ts
@@ -0,0 +1,60 @@
+import type { HybridObjectSpec } from '../syntax/HybridObjectSpec.js'
+import type { Language } from '../getPlatformSpecs.js'
+import { isFunction } from '../syntax/helpers.js'
+import { StructType } from '../syntax/types/StructType.js'
+import { NamedWrappingType } from '../syntax/types/NamedWrappingType.js'
+import { NumberType } from '../syntax/types/NumberType.js'
+import { BooleanType } from '../syntax/types/BooleanType.js'
+import { addKnownType } from '../syntax/createType.js'
+
+export function getMeasureProps(spec: HybridObjectSpec) {
+  return spec.properties.filter((p) => !isFunction(p.type))
+}
+
+export function getMeasurePropsStructName(spec: HybridObjectSpec): string {
+  return `${spec.name}Props`
+}
+
+export function buildMeasurePropsStruct(
+  spec: HybridObjectSpec,
+  languages: Language[]
+): StructType {
+  const props = getMeasureProps(spec)
+  const struct = new StructType(
+    getMeasurePropsStructName(spec),
+    props.map((p) => new NamedWrappingType(p.name, p.type))
+  )
+  for (const language of languages) {
+    addKnownType(struct.structName, struct, language)
+  }
+  return struct
+}
+
+export interface MeasureGeometryStructs {
+  size: StructType
+  layoutContext: StructType
+  layoutConstraints: StructType
+}
+
+export function buildMeasureGeometryStructs(
+  languages: Language[]
+): MeasureGeometryStructs {
+  const size = new StructType('Size', [
+    new NamedWrappingType('width', new NumberType()),
+    new NamedWrappingType('height', new NumberType()),
+  ])
+  const layoutContext = new StructType('LayoutContext', [
+    new NamedWrappingType('pointScaleFactor', new NumberType()),
+    new NamedWrappingType('isRTL', new BooleanType()),
+  ])
+  const layoutConstraints = new StructType('LayoutConstraints', [
+    new NamedWrappingType('minimumSize', size),
+    new NamedWrappingType('maximumSize', size),
+  ])
+  for (const language of languages) {
+    addKnownType(size.structName, size, language)
+    addKnownType(layoutContext.structName, layoutContext, language)
+    addKnownType(layoutConstraints.structName, layoutConstraints, language)
+  }
+  return { size, layoutContext, layoutConstraints }
+}
diff --git a/packages/nitrogen/src/views/kotlin/KotlinHybridViewManager.ts b/packages/nitrogen/src/views/kotlin/KotlinHybridViewManager.ts
index a27718115b..5544051339 100644
--- a/packages/nitrogen/src/views/kotlin/KotlinHybridViewManager.ts
+++ b/packages/nitrogen/src/views/kotlin/KotlinHybridViewManager.ts
@@ -11,6 +11,10 @@ import {
 import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
 import { addJNINativeRegistration } from '../../syntax/kotlin/JNINativeRegistrations.js'
 import { indent } from '../../utils.js'
+import {
+  createKotlinViewMeasurer,
+  getKotlinMeasurerName,
+} from './createKotlinViewMeasurer.js'
 
 export function createKotlinHybridViewManager(
   spec: HybridObjectSpec
@@ -37,6 +41,8 @@ export function createKotlinHybridViewManager(
     )
   }
   const viewImplementation = implementation.implementationClassName
+  const measurerName = getKotlinMeasurerName(spec)
+  const measurerFiles = createKotlinViewMeasurer(spec)
 
   const viewManagerCode = `
 ${createFileMetadataString(`${manager}.kt`)}
@@ -159,6 +165,7 @@ ${createFileMetadataString(`J${stateUpdaterName}.hpp`)}
 #include <NitroModules/JStateWrapper.hpp>
 #include "${JHybridTSpec}.hpp"
 #include "views/${component}.hpp"
+#include "views/J${measurerName}.hpp"
 
 namespace ${cxxNamespace} {
 
@@ -183,6 +190,8 @@ public:
     auto provider = react::concreteComponentDescriptorProvider<${descriptorClassName}>();
     auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
     providerRegistry->add(provider);
+    // Install lock-free self-measurement (no-op unless the impl conforms to MeasurableView)
+    J${measurerName}::install();
   }
 };
 
@@ -290,5 +299,6 @@ void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class
       platform: 'android',
       subdirectory: ['views'],
     },
+    ...measurerFiles,
   ]
 }
diff --git a/packages/nitrogen/src/views/kotlin/createKotlinViewMeasurer.ts b/packages/nitrogen/src/views/kotlin/createKotlinViewMeasurer.ts
new file mode 100644
index 0000000000..5546f613bb
--- /dev/null
+++ b/packages/nitrogen/src/views/kotlin/createKotlinViewMeasurer.ts
@@ -0,0 +1,216 @@
+import type { SourceFile } from '../../syntax/SourceFile.js'
+import type { HybridObjectSpec } from '../../syntax/HybridObjectSpec.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
+import { KotlinCxxBridgedType } from '../../syntax/kotlin/KotlinCxxBridgedType.js'
+import { getViewComponentNames } from '../CppHybridViewComponent.js'
+import { buildMeasurePropsStruct } from '../createViewMeasurerShared.js'
+
+export function getKotlinMeasurerName(spec: HybridObjectSpec): string {
+  const { HybridT } = getHybridObjectName(spec.name)
+  return `${HybridT}Measurer`
+}
+
+/**
+ * Generates the Android side of `MeasurableView`:
+ *  - the props Nitro struct (Kotlin data class + `J<Props>` fbjni bridge),
+ *  - a Kotlin trampoline `object` that resolves the impl's companion (once,
+ *    cached) and forwards `measureContent`,
+ *  - a C++ fbjni wrapper that calls that trampoline with cached method ids,
+ *  - a C++ installer that, at startup, sets the ShadowNode's lock-free
+ *    `measureFunction` iff the impl conforms.
+ */
+export function createKotlinViewMeasurer(spec: HybridObjectSpec): SourceFile[] {
+  const implementation = spec.config.getAndroidAutolinkedImplementation(
+    spec.name
+  )
+  if (implementation?.language !== 'kotlin') {
+    throw new Error(
+      `Cannot create Kotlin MeasurableView trampoline for ${spec.name} - it must be autolinked with a Kotlin Android implementation in nitro.json!`
+    )
+  }
+  const viewImpl = implementation.implementationClassName
+  const measurerName = getKotlinMeasurerName(spec)
+  const { propsClassName, shadowNodeClassName, component } =
+    getViewComponentNames(spec)
+  const propsStruct = buildMeasurePropsStruct(spec, ['kotlin', 'c++'])
+  const propsStructName = propsStruct.structName
+  const propsStructCxxName = propsStruct.getCode('c++', {
+    fullyQualified: true,
+  })
+
+  const javaSubNamespace = spec.config.getAndroidPackage('java/kotlin', 'views')
+  const javaNamespace = spec.config.getAndroidPackage('java/kotlin')
+  const cxxNamespace = spec.config.getCxxNamespace('c++', 'views')
+  const jniClassDescriptor = spec.config.getAndroidPackage(
+    'c++/jni',
+    'views',
+    measurerName
+  )
+
+  const kotlinFile: SourceFile = {
+    name: `${measurerName}.kt`,
+    platform: 'android',
+    language: 'kotlin',
+    subdirectory: javaSubNamespace.split('.'),
+    content: `
+${createFileMetadataString(`${measurerName}.kt`)}
+
+package ${javaSubNamespace}
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.views.LayoutConstraints
+import com.margelo.nitro.views.LayoutContext
+import com.margelo.nitro.views.MeasurableView
+import com.margelo.nitro.views.Size
+import ${javaNamespace}.*
+
+/**
+ * Bridges the C++ ShadowNode's \`measureContent\` to ${viewImpl}'s
+ * \`MeasurableView<${propsStructName}>\` companion. Do not call directly.
+ */
+@DoNotStrip
+object ${measurerName} {
+  // Resolved once (lazily, at first registration touch) and cached. The companion
+  // holds the pure, static measure function - no view instance, no Context, no
+  // main-thread construction. Reflection here is one-time; the per-measure path is
+  // a typed, direct virtual call (the \`<${propsStructName}>\` generic is what keeps
+  // it reflection-free).
+  @Suppress("UNCHECKED_CAST")
+  private val measurer: MeasurableView<${propsStructName}>? = run {
+    try {
+      val field = ${viewImpl}::class.java.getDeclaredField("Companion")
+      field.isAccessible = true
+      field.get(null) as? MeasurableView<${propsStructName}>
+    } catch (e: NoSuchFieldException) {
+      null
+    }
+  }
+
+  @JvmStatic
+  @DoNotStrip
+  fun isMeasurable(): Boolean = measurer != null
+
+  // Returns the measured size packed into a Long - width in the high 32 bits,
+  // height in the low 32 bits, each as raw IEEE-754 float bits. This matches
+  // React Native's own measure path (\`yogaMeassureToSize\`) and avoids allocating
+  // a Size object across JNI on the measure hot-path.
+  @JvmStatic
+  @DoNotStrip
+  fun measure(props: ${propsStructName},
+              pointScaleFactor: Double,
+              isRTL: Boolean,
+              minWidth: Double,
+              minHeight: Double,
+              maxWidth: Double,
+              maxHeight: Double): Long {
+    val m = measurer ?: error("${viewImpl} must expose companion object : MeasurableView<${propsStructName}> before ${measurerName}.measure is called.")
+    val size = m.measureContent(
+      props,
+      LayoutContext(pointScaleFactor, isRTL),
+      LayoutConstraints(Size(minWidth, minHeight), Size(maxWidth, maxHeight))
+    )
+    val w = size.width.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    val h = size.height.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    return (w shl 32) or h
+  }
+}
+`.trim(),
+  }
+
+  const headerName = `J${measurerName}.hpp`
+  const jProps = `J${propsStructName}`
+  const cxxFile: SourceFile = {
+    name: headerName,
+    platform: 'android',
+    language: 'c++',
+    subdirectory: ['views'],
+    content: `
+${createFileMetadataString(headerName)}
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/conversions.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
+
+#include "${jProps}.hpp"
+#include "views/${component}.hpp"
+
+namespace ${cxxNamespace} {
+
+  using namespace facebook;
+
+  /**
+   * C++ <-> Kotlin bridge for the "${spec.name}" measurer. All \`jclass\`/method
+   * lookups are cached; the per-measure path is one cached static call.
+   */
+  struct J${measurerName} final: public jni::JavaClass<J${measurerName}> {
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
+
+    /** Whether the Kotlin impl's companion conforms to \`MeasurableView\`. */
+    static bool isMeasurable() {
+      static const auto method = javaClassStatic()->getStaticMethod<jboolean()>("isMeasurable");
+      return method(javaClassStatic());
+    }
+
+    /**
+     * Installs the lock-free measure function on the ShadowNode iff the impl is
+     * measurable. Called once at startup (JVM attached).
+     */
+    static void install() {
+      if (!isMeasurable()) {
+        return;
+      }
+      ${shadowNodeClassName}::measureFunction.store(
+        [](const react::ViewProps& propsBase,
+           const react::LayoutContext& layoutContext,
+           const react::LayoutConstraints& layoutConstraints) -> react::Size {
+          // Attach this (Yoga/shadow) thread to the JVM for the call. fbjni
+          // no-ops if the thread is already attached (Fabric usually is).
+          jni::ThreadScope scope;
+          const auto& props = static_cast<const ${propsClassName}&>(propsBase);
+          ${propsStructCxxName} measureProps = ${reMeasurePropsCtor(spec, propsStructCxxName)};
+
+          // Kotlin returns the size packed into a jlong (width<<32 | height, each
+          // as raw float bits); \`yogaMeassureToSize\` unpacks it. No Size object is
+          // allocated across JNI - same scheme RN's own measure path uses.
+          static const auto measure = javaClassStatic()
+            ->getStaticMethod<jlong(jni::alias_ref<${jProps}::javaobject>, jdouble, jboolean, jdouble, jdouble, jdouble, jdouble)>("measure");
+          jlong packed = measure(
+            javaClassStatic(),
+            ${jProps}::fromCpp(measureProps),
+            layoutContext.pointScaleFactor,
+            static_cast<jboolean>(layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft),
+            layoutConstraints.minimumSize.width,
+            layoutConstraints.minimumSize.height,
+            layoutConstraints.maximumSize.width,
+            layoutConstraints.maximumSize.height);
+          return react::yogaMeassureToSize(packed);
+        },
+        std::memory_order_release);
+    }
+  };
+
+} // namespace ${cxxNamespace}
+`.trim(),
+  }
+
+  const structFiles = [
+    ...propsStruct.getExtraFiles(),
+    ...new KotlinCxxBridgedType(propsStruct).getExtraFiles(),
+  ]
+  return [...structFiles, kotlinFile, cxxFile]
+}
+
+function reMeasurePropsCtor(
+  spec: HybridObjectSpec,
+  propsStructCxxName: string
+): string {
+  const props = spec.properties.filter((p) => p.type.kind !== 'function')
+  const fields = props.map((p) => `props.${p.name}.value`).join(', ')
+  return `${propsStructCxxName} { ${fields} }`
+}
diff --git a/packages/nitrogen/src/views/swift/SwiftHybridViewManager.ts b/packages/nitrogen/src/views/swift/SwiftHybridViewManager.ts
index 68c579ffb6..9afe806974 100644
--- a/packages/nitrogen/src/views/swift/SwiftHybridViewManager.ts
+++ b/packages/nitrogen/src/views/swift/SwiftHybridViewManager.ts
@@ -16,6 +16,10 @@ import {
 } from '../../syntax/swift/SwiftHybridObjectRegistration.js'
 import { indent } from '../../utils.js'
 import { SwiftCxxBridgedType } from '../../syntax/swift/SwiftCxxBridgedType.js'
+import {
+  createSwiftViewMeasurer,
+  createSwiftViewMeasurerRegistration,
+} from './createSwiftViewMeasurer.js'
 
 export function createSwiftHybridViewManager(
   spec: HybridObjectSpec
@@ -92,6 +96,8 @@ using namespace ${namespace}::views;
 + (void) load {
   [super load];
   [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[${component} class]];
+
+  ${indent(createSwiftViewMeasurerRegistration(spec, swiftNamespace), '  ')}
 }
 
 + (react::ComponentDescriptorProvider) componentDescriptorProvider {
@@ -177,5 +183,6 @@ using namespace ${namespace}::views;
       platform: 'ios',
       subdirectory: ['views'],
     },
+    ...createSwiftViewMeasurer(spec),
   ]
 }
diff --git a/packages/nitrogen/src/views/swift/createSwiftViewMeasurer.ts b/packages/nitrogen/src/views/swift/createSwiftViewMeasurer.ts
new file mode 100644
index 0000000000..1e49610ab1
--- /dev/null
+++ b/packages/nitrogen/src/views/swift/createSwiftViewMeasurer.ts
@@ -0,0 +1,156 @@
+import type { SourceFile } from '../../syntax/SourceFile.js'
+import type { HybridObjectSpec } from '../../syntax/HybridObjectSpec.js'
+import type { StructType } from '../../syntax/types/StructType.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
+import { SwiftCxxBridgedType } from '../../syntax/swift/SwiftCxxBridgedType.js'
+import { getViewComponentNames } from '../CppHybridViewComponent.js'
+import {
+  buildMeasureGeometryStructs,
+  buildMeasurePropsStruct,
+  getMeasureProps,
+} from '../createViewMeasurerShared.js'
+
+function getMeasurePropsStruct(spec: HybridObjectSpec) {
+  return buildMeasurePropsStruct(spec, ['swift', 'c++'])
+}
+
+function getGeometryStructs() {
+  return buildMeasureGeometryStructs(['swift', 'c++'])
+}
+
+export function getSwiftMeasurerName(spec: HybridObjectSpec): string {
+  const { HybridT } = getHybridObjectName(spec.name)
+  return `${HybridT}Measurer`
+}
+
+function structFiles(struct: StructType): SourceFile[] {
+  return [
+    ...struct.getExtraFiles(),
+    ...new SwiftCxxBridgedType(struct).getExtraFiles(),
+  ]
+}
+
+export function createSwiftViewMeasurer(spec: HybridObjectSpec): SourceFile[] {
+  const implementation = spec.config.getIosAutolinkedImplementation(spec.name)
+  if (implementation?.language !== 'swift') {
+    throw new Error(
+      `Cannot create Swift MeasurableView trampoline for ${spec.name} - it must be autolinked with a Swift iOS implementation in nitro.json!`
+    )
+  }
+  const swiftClassName = implementation.implementationClassName
+  const measurerName = getSwiftMeasurerName(spec)
+  const propsStruct = getMeasurePropsStruct(spec)
+  const propsStructName = propsStruct.structName
+  const geometry = getGeometryStructs()
+
+  const code = `
+${createFileMetadataString(`${measurerName}.swift`)}
+
+import NitroModules
+
+extension ${swiftClassName} {
+  static func measureContent<Props, LayoutContext, LayoutConstraints, Size>(
+    props: Props,
+    layoutContext: LayoutContext,
+    layoutConstraints: LayoutConstraints
+  ) -> Size {
+    fatalError("${swiftClassName} cannot be measured because it does not implement the generated measureContent(props:layoutContext:layoutConstraints:) signature.")
+  }
+}
+
+/// Generated trampoline bridging the C++ ShadowNode's \`measureContent\` to
+/// ${swiftClassName}'s \`MeasurableView.measureContent(...)\`. Do not call directly.
+///
+/// All four boundary types are Nitro structs, so each crosses the Swift<->C++
+/// boundary as a single value.
+public final class ${measurerName} {
+  /// The conformance is resolved once and cached - the per-measure path then
+  /// avoids re-checking against the metatype on every layout pass.
+  private static let isMeasurableView: Bool = ${swiftClassName}.self is any MeasurableView.Type
+
+  /// Type-level conformance check - no instance required.
+  public static func isMeasurable() -> Bool {
+    return isMeasurableView
+  }
+
+  public static func measure(props: ${propsStructName},
+                             layoutContext: LayoutContext,
+                             layoutConstraints: LayoutConstraints) -> Size {
+    return ${swiftClassName}.measureContent(
+      props: props,
+      layoutContext: layoutContext,
+      layoutConstraints: layoutConstraints
+    )
+  }
+}
+`.trim()
+
+  return [
+    ...structFiles(propsStruct),
+    ...structFiles(geometry.size),
+    ...structFiles(geometry.layoutContext),
+    ...structFiles(geometry.layoutConstraints),
+    {
+      content: code,
+      language: 'swift',
+      name: `${measurerName}.swift`,
+      platform: 'ios',
+      subdirectory: ['views'],
+    },
+  ]
+}
+
+/**
+ * Generates the Objective-C++ snippet (placed in the ViewManager's `+load`)
+ * that installs this view's `measureFunction` on its ShadowNode when the native
+ * implementation conforms to `MeasurableView`.
+ */
+export function createSwiftViewMeasurerRegistration(
+  spec: HybridObjectSpec,
+  swiftNamespace: string
+): string {
+  const { propsClassName, shadowNodeClassName } = getViewComponentNames(spec)
+  const measurerName = getSwiftMeasurerName(spec)
+  const props = getMeasureProps(spec)
+  const propsStruct = getMeasurePropsStruct(spec)
+  const geometry = getGeometryStructs()
+  const propsCxx = propsStruct.getCode('c++', { fullyQualified: true })
+  const sizeCxx = geometry.size.getCode('c++', { fullyQualified: true })
+  const contextCxx = geometry.layoutContext.getCode('c++', {
+    fullyQualified: true,
+  })
+  const constraintsCxx = geometry.layoutConstraints.getCode('c++', {
+    fullyQualified: true,
+  })
+
+  const propsFields = props
+    .map((p) => `/* ${p.name} */ props.${p.name}.value`)
+    .join(',\n        ')
+
+  return `
+// Install self-measurement iff "${spec.name}" conforms to \`MeasurableView\`.
+if (${swiftNamespace}::${measurerName}::isMeasurable()) {
+  ${shadowNodeClassName}::measureFunction.store(
+    +[](const react::ViewProps& propsBase,
+        const react::LayoutContext& layoutContext,
+        const react::LayoutConstraints& layoutConstraints) -> react::Size {
+      const auto& props = static_cast<const ${propsClassName}&>(propsBase);
+      ${propsCxx} measureProps {
+        ${propsFields}
+      };
+      ${contextCxx} measureContext {
+        /* pointScaleFactor */ layoutContext.pointScaleFactor,
+        /* isRTL */ layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft
+      };
+      ${constraintsCxx} measureConstraints {
+        /* minimumSize */ ${sizeCxx} { layoutConstraints.minimumSize.width, layoutConstraints.minimumSize.height },
+        /* maximumSize */ ${sizeCxx} { layoutConstraints.maximumSize.width, layoutConstraints.maximumSize.height }
+      };
+      auto size = ${swiftNamespace}::${measurerName}::measure(measureProps, measureContext, measureConstraints);
+      return react::Size { static_cast<react::Float>(size.width), static_cast<react::Float>(size.height) };
+    },
+    std::memory_order_release);
+}
+`.trim()
+}
diff --git a/packages/react-native-nitro-modules/android/src/main/java/com/margelo/nitro/views/MeasurableView.kt b/packages/react-native-nitro-modules/android/src/main/java/com/margelo/nitro/views/MeasurableView.kt
new file mode 100644
index 0000000000..42447132d3
--- /dev/null
+++ b/packages/react-native-nitro-modules/android/src/main/java/com/margelo/nitro/views/MeasurableView.kt
@@ -0,0 +1,50 @@
+package com.margelo.nitro.views
+
+/** A size returned from [MeasurableView.measureContent]. */
+data class Size(val width: Double, val height: Double) {
+  companion object {
+    val ZERO = Size(0.0, 0.0)
+  }
+}
+
+/** The layout context a measure pass runs in. */
+data class LayoutContext(val pointScaleFactor: Double, val isRTL: Boolean)
+
+/**
+ * The size constraints a measure pass must resolve within.
+ *
+ * A dimension is "at most" when its [maximumSize] component is finite, and
+ * "undefined" (intrinsic) when it is [Double.POSITIVE_INFINITY].
+ */
+data class LayoutConstraints(val minimumSize: Size, val maximumSize: Size)
+
+/**
+ * Opt-in for a `HybridView` that computes its own intrinsic size (Text-like
+ * auto-height) instead of being laid out purely by its React children / flexbox.
+ *
+ * Kotlin interfaces cannot require static members, so implement this on the view's
+ * **companion object** - the idiomatic equivalent of the Swift `static` requirement:
+ *
+ * ```kotlin
+ * class HybridNitroText(context: Context) : HybridNitroTextSpec() {
+ *   companion object : MeasurableView<NitroTextProps> {
+ *     override fun measureContent(props: NitroTextProps,
+ *                                 layoutContext: LayoutContext,
+ *                                 layoutConstraints: LayoutConstraints): Size {
+ *       // Measure off the main thread (e.g. StaticLayout) - never touch the View.
+ *       return Size(100.0, 50.0)
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Conformance is detected at view registration; Nitro then makes this view a
+ * measurable Yoga leaf.
+ *
+ * - Important: [measureContent] runs on the **shadow/layout thread** with no view.
+ *   Measure purely from `props` with a thread-safe primitive.
+ * - Note: A measurable view is a Yoga **leaf** and cannot host React children.
+ */
+interface MeasurableView<P> {
+  fun measureContent(props: P, layoutContext: LayoutContext, layoutConstraints: LayoutConstraints): Size
+}
diff --git a/packages/react-native-nitro-modules/ios/views/MeasurableView.swift b/packages/react-native-nitro-modules/ios/views/MeasurableView.swift
new file mode 100644
index 0000000000..e7dbd632e9
--- /dev/null
+++ b/packages/react-native-nitro-modules/ios/views/MeasurableView.swift
@@ -0,0 +1,42 @@
+//
+//  MeasurableView.swift
+//  NitroModules
+//
+//  Created by Patrick Kabwe on 13.06.26.
+//
+
+/// A `HybridView` type that computes its own intrinsic size,
+/// instead of being laid out purely by its React children.
+///
+/// Opt in by conforming your `HybridView` implementation type to this protocol
+/// and implementing the generated static
+/// `measureContent(props:layoutContext:layoutConstraints:)` signature.
+/// Conformance is detected at registration; Nitro then makes this view a
+/// measurable Yoga leaf.
+///
+/// - Important: `measureContent` runs on the **shadow/layout thread** and is
+///   given no view. You must measure purely from `props` using a thread-safe
+///   API (e.g. `NSAttributedString.boundingRect`). Never access the live
+///   `UIView`. The result is cached by Yoga keyed on `props` + constraints, so
+///   the function must be deterministic.
+///
+/// - Note: A measurable view is a Yoga **leaf** and therefore cannot host React
+///   children - this is its own feature, mutually exclusive with children.
+///
+public protocol MeasurableView: HybridView {
+  static func measureContent<Props, LayoutContext, LayoutConstraints, Size>(
+    props: Props,
+    layoutContext: LayoutContext,
+    layoutConstraints: LayoutConstraints
+  ) -> Size
+}
+
+public extension MeasurableView {
+  static func measureContent<Props, LayoutContext, LayoutConstraints, Size>(
+    props: Props,
+    layoutContext: LayoutContext,
+    layoutConstraints: LayoutConstraints
+  ) -> Size {
+    fatalError("\(Self.self) conforms to MeasurableView but does not implement the generated measureContent(props:layoutContext:layoutConstraints:) signature.")
+  }
+}
diff --git a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridMeasuredView.kt b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridMeasuredView.kt
new file mode 100644
index 0000000000..b0a507aa76
--- /dev/null
+++ b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridMeasuredView.kt
@@ -0,0 +1,63 @@
+package com.margelo.nitro.test
+
+import android.content.Context
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.util.TypedValue
+import android.widget.TextView
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.views.LayoutConstraints
+import com.margelo.nitro.views.LayoutContext
+import com.margelo.nitro.views.MeasurableView
+import com.margelo.nitro.views.Size
+import kotlin.math.ceil
+
+
+@DoNotStrip
+class HybridMeasuredView(context: Context) : HybridMeasuredViewSpec() {
+  override val view: TextView = TextView(context)
+
+  override var text: String = ""
+    set(value) {
+      field = value
+      view.text = value
+    }
+
+  override var fontSize: Double = 17.0
+    set(value) {
+      field = value
+      view.setTextSize(TypedValue.COMPLEX_UNIT_SP, value.toFloat())
+    }
+
+  companion object : MeasurableView<MeasuredViewProps> {
+    override fun measureContent(
+      props: MeasuredViewProps,
+      layoutContext: LayoutContext,
+      layoutConstraints: LayoutConstraints,
+    ): Size {
+      val density = layoutContext.pointScaleFactor.toFloat()
+      val paint = TextPaint().apply {
+        isAntiAlias = true
+        textSize = props.fontSize.toFloat() * density
+      }
+      val maxWidthPx =
+        if (layoutConstraints.maximumSize.width.isFinite()) {
+          (layoutConstraints.maximumSize.width * density).toInt()
+        } else {
+          Int.MAX_VALUE
+        }
+      val layout = StaticLayout.Builder
+        .obtain(props.text, 0, props.text.length, paint, maxWidthPx)
+        .build()
+      var widthPx = 0f
+      for (i in 0 until layout.lineCount) {
+        widthPx = maxOf(widthPx, layout.getLineWidth(i))
+      }
+
+      return Size(
+        ceil(widthPx / density).toDouble(),
+        ceil(layout.height / density).toDouble(),
+      )
+    }
+  }
+}
diff --git a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/NitroTestPackage.kt b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/NitroTestPackage.kt
index 50bc8911c5..d14fa3c1c9 100644
--- a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/NitroTestPackage.kt
+++ b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/NitroTestPackage.kt
@@ -5,6 +5,7 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.test.views.HybridMeasuredViewManager
 import com.margelo.nitro.test.views.HybridRecyclableTestViewManager
 import com.margelo.nitro.test.views.HybridTestViewManager
 
@@ -20,6 +21,7 @@ class NitroTestPackage : BaseReactPackage() {
     val viewManagers = ArrayList<ViewManager<*, *>>()
     viewManagers.add(HybridTestViewManager())
     viewManagers.add(HybridRecyclableTestViewManager())
+    viewManagers.add(HybridMeasuredViewManager())
     return viewManagers
   }
 
diff --git a/packages/react-native-nitro-test/ios/HybridMeasuredView.swift b/packages/react-native-nitro-test/ios/HybridMeasuredView.swift
new file mode 100644
index 0000000000..ea03c35d94
--- /dev/null
+++ b/packages/react-native-nitro-test/ios/HybridMeasuredView.swift
@@ -0,0 +1,36 @@
+//
+//  HybridMeasuredView.swift
+//  react-native-nitro-test
+//
+//  Created by Patrick Kabwe on 14.06.26.
+//
+
+import NitroModules
+import UIKit
+
+final class HybridMeasuredView: HybridMeasuredViewSpec, MeasurableView {
+  let view: UILabel = {
+    let label = UILabel()
+    label.numberOfLines = 0
+    return label
+  }()
+
+  // Props
+  var text: String = "" {
+    didSet { view.text = text }
+  }
+  var fontSize: Double = 17 {
+    didSet { view.font = .systemFont(ofSize: fontSize) }
+  }
+
+  static func measureContent(props: MeasuredViewProps, layoutContext: LayoutContext, layoutConstraints: LayoutConstraints) -> Size {
+    let maxWidth = layoutConstraints.maximumSize.width.isFinite ? layoutConstraints.maximumSize.width : Double.greatestFiniteMagnitude
+
+    let attributed = NSAttributedString(string: props.text, attributes: [.font: UIFont.systemFont(ofSize: props.fontSize)])
+
+    let rect = attributed.boundingRect(with: CGSize(width: maxWidth, height: .greatestFiniteMagnitude),
+                                       options: [.usesLineFragmentOrigin, .usesFontLeading], context: nil)
+
+    return Size(width: ceil(rect.width), height: ceil(rect.height))
+  }
+}
diff --git a/packages/react-native-nitro-test/nitro.json b/packages/react-native-nitro-test/nitro.json
index b3a180b75e..caf792c523 100644
--- a/packages/react-native-nitro-test/nitro.json
+++ b/packages/react-native-nitro-test/nitro.json
@@ -74,6 +74,16 @@
         "language": "kotlin",
         "implementationClassName": "HybridRecyclableTestView"
       }
+    },
+    "MeasuredView": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridMeasuredView"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridMeasuredView"
+      }
     }
   },
   "ignorePaths": [
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
index 222b2ef3fe..0d8ff4a027 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
@@ -35,6 +35,8 @@ target_sources(
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridBaseSpec.cpp
   ../nitrogen/generated/shared/c++/HybridChildSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMeasuredViewSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridMeasuredViewComponent.cpp
   ../nitrogen/generated/shared/c++/HybridPlatformObjectSpec.cpp
   ../nitrogen/generated/shared/c++/HybridRecyclableTestViewSpec.cpp
   ../nitrogen/generated/shared/c++/views/HybridRecyclableTestViewComponent.cpp
@@ -47,6 +49,8 @@ target_sources(
   ../nitrogen/generated/android/c++/JHybridChildSpec.cpp
   ../nitrogen/generated/android/c++/JNamedVariant.cpp
   ../nitrogen/generated/android/c++/JVariant_Double_String.cpp
+  ../nitrogen/generated/android/c++/JHybridMeasuredViewSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridMeasuredViewStateUpdater.cpp
   ../nitrogen/generated/android/c++/JHybridPlatformObjectSpec.cpp
   ../nitrogen/generated/android/c++/JHybridRecyclableTestViewSpec.cpp
   ../nitrogen/generated/android/c++/views/JHybridRecyclableTestViewStateUpdater.cpp
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp
index 5ebdab53ba..449dcc2b75 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp
@@ -17,6 +17,8 @@
 
 #include "JHybridBaseSpec.hpp"
 #include "JHybridChildSpec.hpp"
+#include "JHybridMeasuredViewSpec.hpp"
+#include "views/JHybridMeasuredViewStateUpdater.hpp"
 #include "JHybridPlatformObjectSpec.hpp"
 #include "JHybridRecyclableTestViewSpec.hpp"
 #include "views/JHybridRecyclableTestViewStateUpdater.hpp"
@@ -95,6 +97,14 @@ struct JHybridRecyclableTestViewSpecImpl: public jni::JavaClass<JHybridRecyclabl
     return javaPart->getJHybridRecyclableTestViewSpec();
   }
 };
+struct JHybridMeasuredViewSpecImpl: public jni::JavaClass<JHybridMeasuredViewSpecImpl, JHybridMeasuredViewSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/HybridMeasuredView;";
+  static std::shared_ptr<JHybridMeasuredViewSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridMeasuredViewSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMeasuredViewSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMeasuredViewSpec();
+  }
+};
 
 void registerAllNatives() {
   using namespace margelo::nitro;
@@ -103,6 +113,8 @@ void registerAllNatives() {
   // Register native JNI methods
   margelo::nitro::test::JHybridBaseSpec::CxxPart::registerNatives();
   margelo::nitro::test::JHybridChildSpec::CxxPart::registerNatives();
+  margelo::nitro::test::JHybridMeasuredViewSpec::CxxPart::registerNatives();
+  margelo::nitro::test::views::JHybridMeasuredViewStateUpdater::registerNatives();
   margelo::nitro::test::JHybridPlatformObjectSpec::CxxPart::registerNatives();
   margelo::nitro::test::JHybridRecyclableTestViewSpec::CxxPart::registerNatives();
   margelo::nitro::test::views::JHybridRecyclableTestViewStateUpdater::registerNatives();
@@ -169,6 +181,12 @@ void registerAllNatives() {
       return JHybridRecyclableTestViewSpecImpl::create();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MeasuredView",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMeasuredViewSpecImpl::create();
+    }
+  );
 }
 
 } // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridMeasuredViewSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridMeasuredViewSpec.cpp
new file mode 100644
index 0000000000..326cfe2225
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridMeasuredViewSpec.cpp
@@ -0,0 +1,66 @@
+///
+/// JHybridMeasuredViewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridMeasuredViewSpec.hpp"
+
+
+
+#include <string>
+
+namespace margelo::nitro::test {
+
+  std::shared_ptr<JHybridMeasuredViewSpec> JHybridMeasuredViewSpec::JavaPart::getJHybridMeasuredViewSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridMeasuredViewSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridMeasuredViewSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridMeasuredViewSpec::CxxPart::jhybriddata> JHybridMeasuredViewSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridMeasuredViewSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridMeasuredViewSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridMeasuredViewSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridMeasuredViewSpec>(castJavaPart);
+  }
+
+  void JHybridMeasuredViewSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridMeasuredViewSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::string JHybridMeasuredViewSpec::getText() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getText");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridMeasuredViewSpec::setText(const std::string& text) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* text */)>("setText");
+    method(_javaPart, jni::make_jstring(text));
+  }
+  double JHybridMeasuredViewSpec::getFontSize() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getFontSize");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridMeasuredViewSpec::setFontSize(double fontSize) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* fontSize */)>("setFontSize");
+    method(_javaPart, fontSize);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridMeasuredViewSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridMeasuredViewSpec.hpp
new file mode 100644
index 0000000000..52dbdd7a08
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridMeasuredViewSpec.hpp
@@ -0,0 +1,66 @@
+///
+/// HybridMeasuredViewSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridMeasuredViewSpec.hpp"
+
+
+
+
+namespace margelo::nitro::test {
+
+  using namespace facebook;
+
+  class JHybridMeasuredViewSpec: public virtual HybridMeasuredViewSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/HybridMeasuredViewSpec;";
+      std::shared_ptr<JHybridMeasuredViewSpec> getJHybridMeasuredViewSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/HybridMeasuredViewSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridMeasuredViewSpec(const jni::local_ref<JHybridMeasuredViewSpec::JavaPart>& javaPart):
+      HybridObject(HybridMeasuredViewSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridMeasuredViewSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridMeasuredViewSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::string getText() override;
+    void setText(const std::string& text) override;
+    double getFontSize() override;
+    void setFontSize(double fontSize) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    jni::global_ref<JHybridMeasuredViewSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JMeasuredViewProps.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JMeasuredViewProps.hpp
new file mode 100644
index 0000000000..6bb4742040
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JMeasuredViewProps.hpp
@@ -0,0 +1,61 @@
+///
+/// JMeasuredViewProps.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MeasuredViewProps.hpp"
+
+#include <string>
+
+namespace margelo::nitro::test {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MeasuredViewProps" and the Kotlin data class "MeasuredViewProps".
+   */
+  struct JMeasuredViewProps final: public jni::JavaClass<JMeasuredViewProps> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/MeasuredViewProps;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MeasuredViewProps by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MeasuredViewProps toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldText = clazz->getField<jni::JString>("text");
+      jni::local_ref<jni::JString> text = this->getFieldValue(fieldText);
+      static const auto fieldFontSize = clazz->getField<double>("fontSize");
+      double fontSize = this->getFieldValue(fieldFontSize);
+      return MeasuredViewProps(
+        text->toStdString(),
+        fontSize
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMeasuredViewProps::javaobject> fromCpp(const MeasuredViewProps& value) {
+      using JSignature = JMeasuredViewProps(jni::alias_ref<jni::JString>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.text),
+        value.fontSize
+      );
+    }
+  };
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JRecyclableTestViewProps.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JRecyclableTestViewProps.hpp
new file mode 100644
index 0000000000..5c763fe417
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JRecyclableTestViewProps.hpp
@@ -0,0 +1,57 @@
+///
+/// JRecyclableTestViewProps.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RecyclableTestViewProps.hpp"
+
+
+
+namespace margelo::nitro::test {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RecyclableTestViewProps" and the Kotlin data class "RecyclableTestViewProps".
+   */
+  struct JRecyclableTestViewProps final: public jni::JavaClass<JRecyclableTestViewProps> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/RecyclableTestViewProps;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RecyclableTestViewProps by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RecyclableTestViewProps toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIsBlue = clazz->getField<jboolean>("isBlue");
+      jboolean isBlue = this->getFieldValue(fieldIsBlue);
+      return RecyclableTestViewProps(
+        static_cast<bool>(isBlue)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JRecyclableTestViewProps::javaobject> fromCpp(const RecyclableTestViewProps& value) {
+      using JSignature = JRecyclableTestViewProps(jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.isBlue
+      );
+    }
+  };
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTestViewProps.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTestViewProps.hpp
new file mode 100644
index 0000000000..a4866c45d8
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTestViewProps.hpp
@@ -0,0 +1,66 @@
+///
+/// JTestViewProps.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "TestViewProps.hpp"
+
+#include "ColorScheme.hpp"
+#include "JColorScheme.hpp"
+
+namespace margelo::nitro::test {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TestViewProps" and the Kotlin data class "TestViewProps".
+   */
+  struct JTestViewProps final: public jni::JavaClass<JTestViewProps> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/TestViewProps;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TestViewProps by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TestViewProps toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIsBlue = clazz->getField<jboolean>("isBlue");
+      jboolean isBlue = this->getFieldValue(fieldIsBlue);
+      static const auto fieldHasBeenCalled = clazz->getField<jboolean>("hasBeenCalled");
+      jboolean hasBeenCalled = this->getFieldValue(fieldHasBeenCalled);
+      static const auto fieldColorScheme = clazz->getField<JColorScheme>("colorScheme");
+      jni::local_ref<JColorScheme> colorScheme = this->getFieldValue(fieldColorScheme);
+      return TestViewProps(
+        static_cast<bool>(isBlue),
+        static_cast<bool>(hasBeenCalled),
+        colorScheme->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JTestViewProps::javaobject> fromCpp(const TestViewProps& value) {
+      using JSignature = JTestViewProps(jboolean, jboolean, jni::alias_ref<JColorScheme>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.isBlue,
+        value.hasBeenCalled,
+        JColorScheme::fromCpp(value.colorScheme)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewMeasurer.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewMeasurer.hpp
new file mode 100644
index 0000000000..4c84cfd7cf
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewMeasurer.hpp
@@ -0,0 +1,75 @@
+///
+/// JHybridMeasuredViewMeasurer.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/conversions.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
+
+#include "JMeasuredViewProps.hpp"
+#include "views/HybridMeasuredViewComponent.hpp"
+
+namespace margelo::nitro::test::views {
+
+  using namespace facebook;
+
+  /**
+   * C++ <-> Kotlin bridge for the "MeasuredView" measurer. All `jclass`/method
+   * lookups are cached; the per-measure path is one cached static call.
+   */
+  struct JHybridMeasuredViewMeasurer final: public jni::JavaClass<JHybridMeasuredViewMeasurer> {
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/views/HybridMeasuredViewMeasurer;";
+
+    /** Whether the Kotlin impl's companion conforms to `MeasurableView`. */
+    static bool isMeasurable() {
+      static const auto method = javaClassStatic()->getStaticMethod<jboolean()>("isMeasurable");
+      return method(javaClassStatic());
+    }
+
+    /**
+     * Installs the lock-free measure function on the ShadowNode iff the impl is
+     * measurable. Called once at startup (JVM attached).
+     */
+    static void install() {
+      if (!isMeasurable()) {
+        return;
+      }
+      HybridMeasuredViewShadowNode::measureFunction.store(
+        [](const react::ViewProps& propsBase,
+           const react::LayoutContext& layoutContext,
+           const react::LayoutConstraints& layoutConstraints) -> react::Size {
+          // Attach this (Yoga/shadow) thread to the JVM for the call. fbjni
+          // no-ops if the thread is already attached (Fabric usually is).
+          jni::ThreadScope scope;
+          const auto& props = static_cast<const HybridMeasuredViewProps&>(propsBase);
+          margelo::nitro::test::MeasuredViewProps measureProps = margelo::nitro::test::MeasuredViewProps { props.text.value, props.fontSize.value };
+
+          // Kotlin returns the size packed into a jlong (width<<32 | height, each
+          // as raw float bits); `yogaMeassureToSize` unpacks it. No Size object is
+          // allocated across JNI - same scheme RN's own measure path uses.
+          static const auto measure = javaClassStatic()
+            ->getStaticMethod<jlong(jni::alias_ref<JMeasuredViewProps::javaobject>, jdouble, jboolean, jdouble, jdouble, jdouble, jdouble)>("measure");
+          jlong packed = measure(
+            javaClassStatic(),
+            JMeasuredViewProps::fromCpp(measureProps),
+            layoutContext.pointScaleFactor,
+            static_cast<jboolean>(layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft),
+            layoutConstraints.minimumSize.width,
+            layoutConstraints.minimumSize.height,
+            layoutConstraints.maximumSize.width,
+            layoutConstraints.maximumSize.height);
+          return react::yogaMeassureToSize(packed);
+        },
+        std::memory_order_release);
+    }
+  };
+
+} // namespace margelo::nitro::test::views
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewStateUpdater.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewStateUpdater.cpp
new file mode 100644
index 0000000000..2789f6f363
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewStateUpdater.cpp
@@ -0,0 +1,60 @@
+///
+/// JHybridMeasuredViewStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridMeasuredViewStateUpdater.hpp"
+#include "views/HybridMeasuredViewComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <react/fabric/StateWrapperImpl.h>
+
+namespace margelo::nitro::test::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridMeasuredViewState>;
+
+void JHybridMeasuredViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridMeasuredViewSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  std::shared_ptr<JHybridMeasuredViewSpec> hybridView = javaView->getJHybridMeasuredViewSpec();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::static_pointer_cast<const ConcreteStateData>(state);
+  const HybridMeasuredViewState& data = concreteState->getData();
+  const std::shared_ptr<HybridMeasuredViewProps>& props = data.getProps();
+  if (props == nullptr) [[unlikely]] {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridMeasuredViewState's data doesn't contain any props!");
+  }
+
+  // Update all props if they are dirty
+  if (props->text.isDirty) {
+    hybridView->setText(props->text.value);
+    props->text.isDirty = false;
+  }
+  if (props->fontSize.isDirty) {
+    hybridView->setFontSize(props->fontSize.value);
+    props->fontSize.isDirty = false;
+  }
+
+  // Update hybridRef if it changed
+  if (props->hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props->hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(hybridView);
+    }
+    props->hybridRef.isDirty = false;
+  }
+}
+
+} // namespace margelo::nitro::test::views
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewStateUpdater.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewStateUpdater.hpp
new file mode 100644
index 0000000000..bcfe906900
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridMeasuredViewStateUpdater.hpp
@@ -0,0 +1,52 @@
+///
+/// JHybridMeasuredViewStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error NitroTest was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridMeasuredViewSpec.hpp"
+#include "views/HybridMeasuredViewComponent.hpp"
+#include "views/JHybridMeasuredViewMeasurer.hpp"
+
+namespace margelo::nitro::test::views {
+
+using namespace facebook;
+
+class JHybridMeasuredViewStateUpdater final: public jni::JavaClass<JHybridMeasuredViewStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/views/HybridMeasuredViewStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridMeasuredViewSpec::JavaPart> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridMeasuredViewStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridMeasuredViewComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+    // Install lock-free self-measurement (no-op unless the impl conforms to MeasurableView)
+    JHybridMeasuredViewMeasurer::install();
+  }
+};
+
+} // namespace margelo::nitro::test::views
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridRecyclableTestViewMeasurer.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridRecyclableTestViewMeasurer.hpp
new file mode 100644
index 0000000000..50f0ab0b5c
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridRecyclableTestViewMeasurer.hpp
@@ -0,0 +1,75 @@
+///
+/// JHybridRecyclableTestViewMeasurer.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/conversions.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
+
+#include "JRecyclableTestViewProps.hpp"
+#include "views/HybridRecyclableTestViewComponent.hpp"
+
+namespace margelo::nitro::test::views {
+
+  using namespace facebook;
+
+  /**
+   * C++ <-> Kotlin bridge for the "RecyclableTestView" measurer. All `jclass`/method
+   * lookups are cached; the per-measure path is one cached static call.
+   */
+  struct JHybridRecyclableTestViewMeasurer final: public jni::JavaClass<JHybridRecyclableTestViewMeasurer> {
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/views/HybridRecyclableTestViewMeasurer;";
+
+    /** Whether the Kotlin impl's companion conforms to `MeasurableView`. */
+    static bool isMeasurable() {
+      static const auto method = javaClassStatic()->getStaticMethod<jboolean()>("isMeasurable");
+      return method(javaClassStatic());
+    }
+
+    /**
+     * Installs the lock-free measure function on the ShadowNode iff the impl is
+     * measurable. Called once at startup (JVM attached).
+     */
+    static void install() {
+      if (!isMeasurable()) {
+        return;
+      }
+      HybridRecyclableTestViewShadowNode::measureFunction.store(
+        [](const react::ViewProps& propsBase,
+           const react::LayoutContext& layoutContext,
+           const react::LayoutConstraints& layoutConstraints) -> react::Size {
+          // Attach this (Yoga/shadow) thread to the JVM for the call. fbjni
+          // no-ops if the thread is already attached (Fabric usually is).
+          jni::ThreadScope scope;
+          const auto& props = static_cast<const HybridRecyclableTestViewProps&>(propsBase);
+          margelo::nitro::test::RecyclableTestViewProps measureProps = margelo::nitro::test::RecyclableTestViewProps { props.isBlue.value };
+
+          // Kotlin returns the size packed into a jlong (width<<32 | height, each
+          // as raw float bits); `yogaMeassureToSize` unpacks it. No Size object is
+          // allocated across JNI - same scheme RN's own measure path uses.
+          static const auto measure = javaClassStatic()
+            ->getStaticMethod<jlong(jni::alias_ref<JRecyclableTestViewProps::javaobject>, jdouble, jboolean, jdouble, jdouble, jdouble, jdouble)>("measure");
+          jlong packed = measure(
+            javaClassStatic(),
+            JRecyclableTestViewProps::fromCpp(measureProps),
+            layoutContext.pointScaleFactor,
+            static_cast<jboolean>(layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft),
+            layoutConstraints.minimumSize.width,
+            layoutConstraints.minimumSize.height,
+            layoutConstraints.maximumSize.width,
+            layoutConstraints.maximumSize.height);
+          return react::yogaMeassureToSize(packed);
+        },
+        std::memory_order_release);
+    }
+  };
+
+} // namespace margelo::nitro::test::views
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridRecyclableTestViewStateUpdater.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridRecyclableTestViewStateUpdater.hpp
index 0bd9385b38..ad88e167b0 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridRecyclableTestViewStateUpdater.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridRecyclableTestViewStateUpdater.hpp
@@ -19,6 +19,7 @@
 #include <NitroModules/JStateWrapper.hpp>
 #include "JHybridRecyclableTestViewSpec.hpp"
 #include "views/HybridRecyclableTestViewComponent.hpp"
+#include "views/JHybridRecyclableTestViewMeasurer.hpp"
 
 namespace margelo::nitro::test::views {
 
@@ -43,6 +44,8 @@ class JHybridRecyclableTestViewStateUpdater final: public jni::JavaClass<JHybrid
     auto provider = react::concreteComponentDescriptorProvider<HybridRecyclableTestViewComponentDescriptor>();
     auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
     providerRegistry->add(provider);
+    // Install lock-free self-measurement (no-op unless the impl conforms to MeasurableView)
+    JHybridRecyclableTestViewMeasurer::install();
   }
 };
 
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewMeasurer.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewMeasurer.hpp
new file mode 100644
index 0000000000..ddc9ebb393
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewMeasurer.hpp
@@ -0,0 +1,75 @@
+///
+/// JHybridTestViewMeasurer.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/conversions.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
+
+#include "JTestViewProps.hpp"
+#include "views/HybridTestViewComponent.hpp"
+
+namespace margelo::nitro::test::views {
+
+  using namespace facebook;
+
+  /**
+   * C++ <-> Kotlin bridge for the "TestView" measurer. All `jclass`/method
+   * lookups are cached; the per-measure path is one cached static call.
+   */
+  struct JHybridTestViewMeasurer final: public jni::JavaClass<JHybridTestViewMeasurer> {
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/views/HybridTestViewMeasurer;";
+
+    /** Whether the Kotlin impl's companion conforms to `MeasurableView`. */
+    static bool isMeasurable() {
+      static const auto method = javaClassStatic()->getStaticMethod<jboolean()>("isMeasurable");
+      return method(javaClassStatic());
+    }
+
+    /**
+     * Installs the lock-free measure function on the ShadowNode iff the impl is
+     * measurable. Called once at startup (JVM attached).
+     */
+    static void install() {
+      if (!isMeasurable()) {
+        return;
+      }
+      HybridTestViewShadowNode::measureFunction.store(
+        [](const react::ViewProps& propsBase,
+           const react::LayoutContext& layoutContext,
+           const react::LayoutConstraints& layoutConstraints) -> react::Size {
+          // Attach this (Yoga/shadow) thread to the JVM for the call. fbjni
+          // no-ops if the thread is already attached (Fabric usually is).
+          jni::ThreadScope scope;
+          const auto& props = static_cast<const HybridTestViewProps&>(propsBase);
+          margelo::nitro::test::TestViewProps measureProps = margelo::nitro::test::TestViewProps { props.isBlue.value, props.hasBeenCalled.value, props.colorScheme.value };
+
+          // Kotlin returns the size packed into a jlong (width<<32 | height, each
+          // as raw float bits); `yogaMeassureToSize` unpacks it. No Size object is
+          // allocated across JNI - same scheme RN's own measure path uses.
+          static const auto measure = javaClassStatic()
+            ->getStaticMethod<jlong(jni::alias_ref<JTestViewProps::javaobject>, jdouble, jboolean, jdouble, jdouble, jdouble, jdouble)>("measure");
+          jlong packed = measure(
+            javaClassStatic(),
+            JTestViewProps::fromCpp(measureProps),
+            layoutContext.pointScaleFactor,
+            static_cast<jboolean>(layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft),
+            layoutConstraints.minimumSize.width,
+            layoutConstraints.minimumSize.height,
+            layoutConstraints.maximumSize.width,
+            layoutConstraints.maximumSize.height);
+          return react::yogaMeassureToSize(packed);
+        },
+        std::memory_order_release);
+    }
+  };
+
+} // namespace margelo::nitro::test::views
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.hpp
index b71ecbeb1f..1be795a43a 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.hpp
@@ -19,6 +19,7 @@
 #include <NitroModules/JStateWrapper.hpp>
 #include "JHybridTestViewSpec.hpp"
 #include "views/HybridTestViewComponent.hpp"
+#include "views/JHybridTestViewMeasurer.hpp"
 
 namespace margelo::nitro::test::views {
 
@@ -43,6 +44,8 @@ class JHybridTestViewStateUpdater final: public jni::JavaClass<JHybridTestViewSt
     auto provider = react::concreteComponentDescriptorProvider<HybridTestViewComponentDescriptor>();
     auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
     providerRegistry->add(provider);
+    // Install lock-free self-measurement (no-op unless the impl conforms to MeasurableView)
+    JHybridTestViewMeasurer::install();
   }
 };
 
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridMeasuredViewSpec.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridMeasuredViewSpec.kt
new file mode 100644
index 0000000000..43aab70c4d
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridMeasuredViewSpec.kt
@@ -0,0 +1,63 @@
+///
+/// HybridMeasuredViewSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.HybridObject
+import com.margelo.nitro.views.HybridView
+
+/**
+ * A Kotlin class representing the MeasuredView HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of MeasuredView.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridMeasuredViewSpec: HybridView() {
+  // Properties
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var text: String
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var fontSize: Double
+
+  // Methods
+  
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject MeasuredView]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridMeasuredViewSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridMeasuredViewSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridMeasuredViewSpec"
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/MeasuredViewProps.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/MeasuredViewProps.kt
new file mode 100644
index 0000000000..98b692d575
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/MeasuredViewProps.kt
@@ -0,0 +1,56 @@
+///
+/// MeasuredViewProps.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "MeasuredViewProps".
+ */
+@DoNotStrip
+@Keep
+data class MeasuredViewProps(
+  @DoNotStrip
+  @Keep
+  val text: String,
+  @DoNotStrip
+  @Keep
+  val fontSize: Double
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is MeasuredViewProps) return false
+    return Objects.deepEquals(this.text, other.text)
+      && Objects.deepEquals(this.fontSize, other.fontSize)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      text,
+      fontSize
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(text: String, fontSize: Double): MeasuredViewProps {
+      return MeasuredViewProps(text, fontSize)
+    }
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/RecyclableTestViewProps.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/RecyclableTestViewProps.kt
new file mode 100644
index 0000000000..2f48b72ef9
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/RecyclableTestViewProps.kt
@@ -0,0 +1,51 @@
+///
+/// RecyclableTestViewProps.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "RecyclableTestViewProps".
+ */
+@DoNotStrip
+@Keep
+data class RecyclableTestViewProps(
+  @DoNotStrip
+  @Keep
+  val isBlue: Boolean
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is RecyclableTestViewProps) return false
+    return Objects.deepEquals(this.isBlue, other.isBlue)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      isBlue
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(isBlue: Boolean): RecyclableTestViewProps {
+      return RecyclableTestViewProps(isBlue)
+    }
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TestViewProps.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TestViewProps.kt
new file mode 100644
index 0000000000..bb7aef1217
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TestViewProps.kt
@@ -0,0 +1,61 @@
+///
+/// TestViewProps.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "TestViewProps".
+ */
+@DoNotStrip
+@Keep
+data class TestViewProps(
+  @DoNotStrip
+  @Keep
+  val isBlue: Boolean,
+  @DoNotStrip
+  @Keep
+  val hasBeenCalled: Boolean,
+  @DoNotStrip
+  @Keep
+  val colorScheme: ColorScheme
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is TestViewProps) return false
+    return Objects.deepEquals(this.isBlue, other.isBlue)
+      && Objects.deepEquals(this.hasBeenCalled, other.hasBeenCalled)
+      && Objects.deepEquals(this.colorScheme, other.colorScheme)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      isBlue,
+      hasBeenCalled,
+      colorScheme
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(isBlue: Boolean, hasBeenCalled: Boolean, colorScheme: ColorScheme): TestViewProps {
+      return TestViewProps(isBlue, hasBeenCalled, colorScheme)
+    }
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewManager.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewManager.kt
new file mode 100644
index 0000000000..e4995c7110
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewManager.kt
@@ -0,0 +1,80 @@
+///
+/// HybridMeasuredViewManager.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test.views
+
+import android.view.View
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.R.id.associated_hybrid_view_tag
+import com.margelo.nitro.views.RecyclableView
+import com.margelo.nitro.test.*
+
+/**
+ * Represents the React Native `ViewManager` for the "MeasuredView" Nitro HybridView.
+ */
+public class HybridMeasuredViewManager: SimpleViewManager<View>() {
+  init {
+    if (RecyclableView::class.java.isAssignableFrom(HybridMeasuredView::class.java)) {
+      // Enable view recycling
+      super.setupViewRecycling()
+    }
+  }
+
+  override fun getName(): String {
+    return "MeasuredView"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): View {
+    val hybridView = HybridMeasuredView(reactContext)
+    val view = hybridView.view
+    view.setTag(associated_hybrid_view_tag, hybridView)
+    return view
+  }
+
+  override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+    val hybridView = getHybridView(view)
+      ?: throw Error("Couldn't find view $view in local views table!")
+
+    // 1. Update each prop individually
+    hybridView.beforeUpdate()
+    HybridMeasuredViewStateUpdater.updateViewProps(hybridView, stateWrapper)
+    hybridView.afterUpdate()
+
+    // 2. Continue in base View props
+    return super.updateState(view, props, stateWrapper)
+  }
+
+  override fun onDropViewInstance(view: View) {
+    val hybridView = getHybridView(view)
+    hybridView?.onDropView()
+    return super.onDropViewInstance(view)
+  }
+
+  protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
+    super.prepareToRecycleView(reactContext, view)
+    val hybridView = getHybridView(view)
+      ?: return null
+
+    @Suppress("USELESS_IS_CHECK")
+    if (hybridView is RecyclableView) {
+      // Recycle in it's implementation
+      hybridView.prepareForRecycle()
+
+      // Maybe update the view if it changed
+      return hybridView.view
+    } else {
+      return null
+    }
+  }
+
+  private fun getHybridView(view: View): HybridMeasuredView? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridMeasuredView
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewMeasurer.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewMeasurer.kt
new file mode 100644
index 0000000000..54ae7f13a1
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewMeasurer.kt
@@ -0,0 +1,66 @@
+///
+/// HybridMeasuredViewMeasurer.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test.views
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.views.LayoutConstraints
+import com.margelo.nitro.views.LayoutContext
+import com.margelo.nitro.views.MeasurableView
+import com.margelo.nitro.views.Size
+import com.margelo.nitro.test.*
+
+/**
+ * Bridges the C++ ShadowNode's `measureContent` to HybridMeasuredView's
+ * `MeasurableView<MeasuredViewProps>` companion. Do not call directly.
+ */
+@DoNotStrip
+object HybridMeasuredViewMeasurer {
+  // Resolved once (lazily, at first registration touch) and cached. The companion
+  // holds the pure, static measure function - no view instance, no Context, no
+  // main-thread construction. Reflection here is one-time; the per-measure path is
+  // a typed, direct virtual call (the `<MeasuredViewProps>` generic is what keeps
+  // it reflection-free).
+  @Suppress("UNCHECKED_CAST")
+  private val measurer: MeasurableView<MeasuredViewProps>? = run {
+    try {
+      val field = HybridMeasuredView::class.java.getDeclaredField("Companion")
+      field.isAccessible = true
+      field.get(null) as? MeasurableView<MeasuredViewProps>
+    } catch (e: NoSuchFieldException) {
+      null
+    }
+  }
+
+  @JvmStatic
+  @DoNotStrip
+  fun isMeasurable(): Boolean = measurer != null
+
+  // Returns the measured size packed into a Long - width in the high 32 bits,
+  // height in the low 32 bits, each as raw IEEE-754 float bits. This matches
+  // React Native's own measure path (`yogaMeassureToSize`) and avoids allocating
+  // a Size object across JNI on the measure hot-path.
+  @JvmStatic
+  @DoNotStrip
+  fun measure(props: MeasuredViewProps,
+              pointScaleFactor: Double,
+              isRTL: Boolean,
+              minWidth: Double,
+              minHeight: Double,
+              maxWidth: Double,
+              maxHeight: Double): Long {
+    val m = measurer ?: error("HybridMeasuredView must expose companion object : MeasurableView<MeasuredViewProps> before HybridMeasuredViewMeasurer.measure is called.")
+    val size = m.measureContent(
+      props,
+      LayoutContext(pointScaleFactor, isRTL),
+      LayoutConstraints(Size(minWidth, minHeight), Size(maxWidth, maxHeight))
+    )
+    val w = size.width.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    val h = size.height.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    return (w shl 32) or h
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewStateUpdater.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewStateUpdater.kt
new file mode 100644
index 0000000000..04b7d381bb
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridMeasuredViewStateUpdater.kt
@@ -0,0 +1,23 @@
+///
+/// HybridMeasuredViewStateUpdater.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test.views
+
+import com.facebook.react.uimanager.StateWrapper
+import com.margelo.nitro.test.*
+
+internal class HybridMeasuredViewStateUpdater {
+  companion object {
+    /**
+     * Updates the props for [view] through C++.
+     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     */
+    @Suppress("KotlinJniMissingFunction")
+    @JvmStatic
+    external fun updateViewProps(view: HybridMeasuredViewSpec, state: StateWrapper)
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridRecyclableTestViewMeasurer.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridRecyclableTestViewMeasurer.kt
new file mode 100644
index 0000000000..1e2fe6c2aa
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridRecyclableTestViewMeasurer.kt
@@ -0,0 +1,66 @@
+///
+/// HybridRecyclableTestViewMeasurer.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test.views
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.views.LayoutConstraints
+import com.margelo.nitro.views.LayoutContext
+import com.margelo.nitro.views.MeasurableView
+import com.margelo.nitro.views.Size
+import com.margelo.nitro.test.*
+
+/**
+ * Bridges the C++ ShadowNode's `measureContent` to HybridRecyclableTestView's
+ * `MeasurableView<RecyclableTestViewProps>` companion. Do not call directly.
+ */
+@DoNotStrip
+object HybridRecyclableTestViewMeasurer {
+  // Resolved once (lazily, at first registration touch) and cached. The companion
+  // holds the pure, static measure function - no view instance, no Context, no
+  // main-thread construction. Reflection here is one-time; the per-measure path is
+  // a typed, direct virtual call (the `<RecyclableTestViewProps>` generic is what keeps
+  // it reflection-free).
+  @Suppress("UNCHECKED_CAST")
+  private val measurer: MeasurableView<RecyclableTestViewProps>? = run {
+    try {
+      val field = HybridRecyclableTestView::class.java.getDeclaredField("Companion")
+      field.isAccessible = true
+      field.get(null) as? MeasurableView<RecyclableTestViewProps>
+    } catch (e: NoSuchFieldException) {
+      null
+    }
+  }
+
+  @JvmStatic
+  @DoNotStrip
+  fun isMeasurable(): Boolean = measurer != null
+
+  // Returns the measured size packed into a Long - width in the high 32 bits,
+  // height in the low 32 bits, each as raw IEEE-754 float bits. This matches
+  // React Native's own measure path (`yogaMeassureToSize`) and avoids allocating
+  // a Size object across JNI on the measure hot-path.
+  @JvmStatic
+  @DoNotStrip
+  fun measure(props: RecyclableTestViewProps,
+              pointScaleFactor: Double,
+              isRTL: Boolean,
+              minWidth: Double,
+              minHeight: Double,
+              maxWidth: Double,
+              maxHeight: Double): Long {
+    val m = measurer ?: error("HybridRecyclableTestView must expose companion object : MeasurableView<RecyclableTestViewProps> before HybridRecyclableTestViewMeasurer.measure is called.")
+    val size = m.measureContent(
+      props,
+      LayoutContext(pointScaleFactor, isRTL),
+      LayoutConstraints(Size(minWidth, minHeight), Size(maxWidth, maxHeight))
+    )
+    val w = size.width.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    val h = size.height.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    return (w shl 32) or h
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridTestViewMeasurer.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridTestViewMeasurer.kt
new file mode 100644
index 0000000000..2c44301443
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/views/HybridTestViewMeasurer.kt
@@ -0,0 +1,66 @@
+///
+/// HybridTestViewMeasurer.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test.views
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.views.LayoutConstraints
+import com.margelo.nitro.views.LayoutContext
+import com.margelo.nitro.views.MeasurableView
+import com.margelo.nitro.views.Size
+import com.margelo.nitro.test.*
+
+/**
+ * Bridges the C++ ShadowNode's `measureContent` to HybridTestView's
+ * `MeasurableView<TestViewProps>` companion. Do not call directly.
+ */
+@DoNotStrip
+object HybridTestViewMeasurer {
+  // Resolved once (lazily, at first registration touch) and cached. The companion
+  // holds the pure, static measure function - no view instance, no Context, no
+  // main-thread construction. Reflection here is one-time; the per-measure path is
+  // a typed, direct virtual call (the `<TestViewProps>` generic is what keeps
+  // it reflection-free).
+  @Suppress("UNCHECKED_CAST")
+  private val measurer: MeasurableView<TestViewProps>? = run {
+    try {
+      val field = HybridTestView::class.java.getDeclaredField("Companion")
+      field.isAccessible = true
+      field.get(null) as? MeasurableView<TestViewProps>
+    } catch (e: NoSuchFieldException) {
+      null
+    }
+  }
+
+  @JvmStatic
+  @DoNotStrip
+  fun isMeasurable(): Boolean = measurer != null
+
+  // Returns the measured size packed into a Long - width in the high 32 bits,
+  // height in the low 32 bits, each as raw IEEE-754 float bits. This matches
+  // React Native's own measure path (`yogaMeassureToSize`) and avoids allocating
+  // a Size object across JNI on the measure hot-path.
+  @JvmStatic
+  @DoNotStrip
+  fun measure(props: TestViewProps,
+              pointScaleFactor: Double,
+              isRTL: Boolean,
+              minWidth: Double,
+              minHeight: Double,
+              maxWidth: Double,
+              maxHeight: Double): Long {
+    val m = measurer ?: error("HybridTestView must expose companion object : MeasurableView<TestViewProps> before HybridTestViewMeasurer.measure is called.")
+    val size = m.measureContent(
+      props,
+      LayoutContext(pointScaleFactor, isRTL),
+      LayoutConstraints(Size(minWidth, minHeight), Size(maxWidth, maxHeight))
+    )
+    val w = size.width.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    val h = size.height.toFloat().toRawBits().toLong() and 0xFFFFFFFFL
+    return (w shl 32) or h
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.cpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.cpp
index ffd408054a..6a4d8f786c 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.cpp
@@ -10,6 +10,7 @@
 // Include C++ implementation defined types
 #include "HybridBaseSpecSwift.hpp"
 #include "HybridChildSpecSwift.hpp"
+#include "HybridMeasuredViewSpecSwift.hpp"
 #include "HybridPlatformObjectSpecSwift.hpp"
 #include "HybridRecyclableTestViewSpecSwift.hpp"
 #include "HybridTestObjectSwiftKotlinSpecSwift.hpp"
@@ -52,6 +53,22 @@ namespace margelo::nitro::test::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::shared_ptr<HybridMeasuredViewSpec>
+  std::shared_ptr<HybridMeasuredViewSpec> create_std__shared_ptr_HybridMeasuredViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    NitroTest::HybridMeasuredViewSpec_cxx swiftPart = NitroTest::HybridMeasuredViewSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::test::HybridMeasuredViewSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridMeasuredViewSpec_(std__shared_ptr_HybridMeasuredViewSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::test::HybridMeasuredViewSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::test::HybridMeasuredViewSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridMeasuredViewSpec\" is not implemented in Swift!");
+    }
+    #endif
+    NitroTest::HybridMeasuredViewSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridPlatformObjectSpec>
   std::shared_ptr<HybridPlatformObjectSpec> create_std__shared_ptr_HybridPlatformObjectSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     NitroTest::HybridPlatformObjectSpec_cxx swiftPart = NitroTest::HybridPlatformObjectSpec_cxx::fromUnsafe(swiftUnsafePointer);
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp
index 52d5cce021..fb3bc3aec3 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp
@@ -18,6 +18,8 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; }
 namespace margelo::nitro::test { class HybridBaseSpec; }
 // Forward declaration of `HybridChildSpec` to properly resolve imports.
 namespace margelo::nitro::test { class HybridChildSpec; }
+// Forward declaration of `HybridMeasuredViewSpec` to properly resolve imports.
+namespace margelo::nitro::test { class HybridMeasuredViewSpec; }
 // Forward declaration of `HybridPlatformObjectSpec` to properly resolve imports.
 namespace margelo::nitro::test { class HybridPlatformObjectSpec; }
 // Forward declaration of `HybridRecyclableTestViewSpec` to properly resolve imports.
@@ -56,6 +58,8 @@ namespace margelo::nitro::test { struct WrappedJsStruct; }
 namespace NitroTest { class HybridBaseSpec_cxx; }
 // Forward declaration of `HybridChildSpec_cxx` to properly resolve imports.
 namespace NitroTest { class HybridChildSpec_cxx; }
+// Forward declaration of `HybridMeasuredViewSpec_cxx` to properly resolve imports.
+namespace NitroTest { class HybridMeasuredViewSpec_cxx; }
 // Forward declaration of `HybridPlatformObjectSpec_cxx` to properly resolve imports.
 namespace NitroTest { class HybridPlatformObjectSpec_cxx; }
 // Forward declaration of `HybridRecyclableTestViewSpec_cxx` to properly resolve imports.
@@ -72,6 +76,7 @@ namespace NitroTest { class HybridTestViewSpec_cxx; }
 #include "ExternalObjectStruct.hpp"
 #include "HybridBaseSpec.hpp"
 #include "HybridChildSpec.hpp"
+#include "HybridMeasuredViewSpec.hpp"
 #include "HybridPlatformObjectSpec.hpp"
 #include "HybridRecyclableTestViewSpec.hpp"
 #include "HybridTestObjectSwiftKotlinSpec.hpp"
@@ -287,6 +292,18 @@ namespace margelo::nitro::test::bridge::swift {
     return Result<std::variant<std::string, Car>>::withError(error);
   }
   
+  // pragma MARK: std::shared_ptr<HybridMeasuredViewSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridMeasuredViewSpec>`.
+   */
+  using std__shared_ptr_HybridMeasuredViewSpec_ = std::shared_ptr<HybridMeasuredViewSpec>;
+  std::shared_ptr<HybridMeasuredViewSpec> create_std__shared_ptr_HybridMeasuredViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridMeasuredViewSpec_(std__shared_ptr_HybridMeasuredViewSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridMeasuredViewSpec>
+  using std__weak_ptr_HybridMeasuredViewSpec_ = std::weak_ptr<HybridMeasuredViewSpec>;
+  inline std__weak_ptr_HybridMeasuredViewSpec_ weakify_std__shared_ptr_HybridMeasuredViewSpec_(const std::shared_ptr<HybridMeasuredViewSpec>& strong) noexcept { return strong; }
+  
   // pragma MARK: std::shared_ptr<HybridPlatformObjectSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridPlatformObjectSpec>`.
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp
index 89a8b77d90..6fec20de52 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp
@@ -18,6 +18,8 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; }
 namespace margelo::nitro::test { class HybridBaseSpec; }
 // Forward declaration of `HybridChildSpec` to properly resolve imports.
 namespace margelo::nitro::test { class HybridChildSpec; }
+// Forward declaration of `HybridMeasuredViewSpec` to properly resolve imports.
+namespace margelo::nitro::test { class HybridMeasuredViewSpec; }
 // Forward declaration of `HybridPlatformObjectSpec` to properly resolve imports.
 namespace margelo::nitro::test { class HybridPlatformObjectSpec; }
 // Forward declaration of `HybridRecyclableTestViewSpec` to properly resolve imports.
@@ -30,8 +32,14 @@ namespace margelo::nitro::test { class HybridTestObjectSwiftKotlinSpec; }
 namespace margelo::nitro::test { class HybridTestViewSpec; }
 // Forward declaration of `JsStyleStruct` to properly resolve imports.
 namespace margelo::nitro::test { struct JsStyleStruct; }
+// Forward declaration of `LayoutConstraints` to properly resolve imports.
+namespace margelo::nitro::test { struct LayoutConstraints; }
+// Forward declaration of `LayoutContext` to properly resolve imports.
+namespace margelo::nitro::test { struct LayoutContext; }
 // Forward declaration of `MapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct MapWrapper; }
+// Forward declaration of `MeasuredViewProps` to properly resolve imports.
+namespace margelo::nitro::test { struct MeasuredViewProps; }
 // Forward declaration of `OldEnum` to properly resolve imports.
 namespace margelo::nitro::test { enum class OldEnum; }
 // Forward declaration of `OptionalCallback` to properly resolve imports.
@@ -46,8 +54,14 @@ namespace margelo::nitro::test { struct PartialPerson; }
 namespace margelo::nitro::test { struct Person; }
 // Forward declaration of `Powertrain` to properly resolve imports.
 namespace margelo::nitro::test { enum class Powertrain; }
+// Forward declaration of `RecyclableTestViewProps` to properly resolve imports.
+namespace margelo::nitro::test { struct RecyclableTestViewProps; }
 // Forward declaration of `SecondMapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct SecondMapWrapper; }
+// Forward declaration of `Size` to properly resolve imports.
+namespace margelo::nitro::test { struct Size; }
+// Forward declaration of `TestViewProps` to properly resolve imports.
+namespace margelo::nitro::test { struct TestViewProps; }
 // Forward declaration of `TruckPowertrain` to properly resolve imports.
 namespace margelo::nitro::test { enum class TruckPowertrain; }
 // Forward declaration of `WeirdNumbersEnum` to properly resolve imports.
@@ -61,12 +75,16 @@ namespace margelo::nitro::test { struct WrappedJsStruct; }
 #include "ExternalObjectStruct.hpp"
 #include "HybridBaseSpec.hpp"
 #include "HybridChildSpec.hpp"
+#include "HybridMeasuredViewSpec.hpp"
 #include "HybridPlatformObjectSpec.hpp"
 #include "HybridRecyclableTestViewSpec.hpp"
 #include "HybridTestObjectSwiftKotlinSpec.hpp"
 #include "HybridTestViewSpec.hpp"
 #include "JsStyleStruct.hpp"
+#include "LayoutConstraints.hpp"
+#include "LayoutContext.hpp"
 #include "MapWrapper.hpp"
+#include "MeasuredViewProps.hpp"
 #include "OldEnum.hpp"
 #include "OptionalCallback.hpp"
 #include "OptionalEnumWrapper.hpp"
@@ -74,7 +92,10 @@ namespace margelo::nitro::test { struct WrappedJsStruct; }
 #include "PartialPerson.hpp"
 #include "Person.hpp"
 #include "Powertrain.hpp"
+#include "RecyclableTestViewProps.hpp"
 #include "SecondMapWrapper.hpp"
+#include "Size.hpp"
+#include "TestViewProps.hpp"
 #include "TruckPowertrain.hpp"
 #include "WeirdNumbersEnum.hpp"
 #include "WrappedJsStruct.hpp"
@@ -108,6 +129,8 @@ namespace margelo::nitro::test { struct WrappedJsStruct; }
 namespace NitroTest { class HybridBaseSpec_cxx; }
 // Forward declaration of `HybridChildSpec_cxx` to properly resolve imports.
 namespace NitroTest { class HybridChildSpec_cxx; }
+// Forward declaration of `HybridMeasuredViewSpec_cxx` to properly resolve imports.
+namespace NitroTest { class HybridMeasuredViewSpec_cxx; }
 // Forward declaration of `HybridPlatformObjectSpec_cxx` to properly resolve imports.
 namespace NitroTest { class HybridPlatformObjectSpec_cxx; }
 // Forward declaration of `HybridRecyclableTestViewSpec_cxx` to properly resolve imports.
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.mm b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.mm
index 1a2b5b22c2..3174ebfc7a 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.mm
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.mm
@@ -17,6 +17,7 @@
 #include "HybridPlatformObjectSpecSwift.hpp"
 #include "HybridTestViewSpecSwift.hpp"
 #include "HybridRecyclableTestViewSpecSwift.hpp"
+#include "HybridMeasuredViewSpecSwift.hpp"
 
 @interface NitroTestAutolinking : NSObject
 @end
@@ -78,6 +79,13 @@ + (void) load {
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MeasuredView",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridMeasuredViewSpec> hybridObject = NitroTest::NitroTestAutolinking::createMeasuredView();
+      return hybridObject;
+    }
+  );
 }
 
 @end
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.swift
index 4e19db7c51..840d143cd1 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTestAutolinking.swift
@@ -83,4 +83,16 @@ public final class NitroTestAutolinking {
   public static func isRecyclableTestViewRecyclable() -> Bool {
     return HybridRecyclableTestView.self is any RecyclableView.Type
   }
+  
+  public static func createMeasuredView() -> bridge.std__shared_ptr_HybridMeasuredViewSpec_ {
+    let hybridObject = HybridMeasuredView()
+    return { () -> bridge.std__shared_ptr_HybridMeasuredViewSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isMeasuredViewRecyclable() -> Bool {
+    return HybridMeasuredView.self is any RecyclableView.Type
+  }
 }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridMeasuredViewSpecSwift.cpp b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridMeasuredViewSpecSwift.cpp
new file mode 100644
index 0000000000..907d758c99
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridMeasuredViewSpecSwift.cpp
@@ -0,0 +1,11 @@
+///
+/// HybridMeasuredViewSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMeasuredViewSpecSwift.hpp"
+
+namespace margelo::nitro::test {
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridMeasuredViewSpecSwift.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridMeasuredViewSpecSwift.hpp
new file mode 100644
index 0000000000..09780566b1
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridMeasuredViewSpecSwift.hpp
@@ -0,0 +1,87 @@
+///
+/// HybridMeasuredViewSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridMeasuredViewSpec.hpp"
+
+// Forward declaration of `HybridMeasuredViewSpec_cxx` to properly resolve imports.
+namespace NitroTest { class HybridMeasuredViewSpec_cxx; }
+
+
+
+#include <string>
+
+#include "NitroTest-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::test {
+
+  /**
+   * The C++ part of HybridMeasuredViewSpec_cxx.swift.
+   *
+   * HybridMeasuredViewSpecSwift (C++) accesses HybridMeasuredViewSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridMeasuredViewSpec_cxx can directly inherit from the C++ class HybridMeasuredViewSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridMeasuredViewSpecSwift: public virtual HybridMeasuredViewSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridMeasuredViewSpecSwift(const NitroTest::HybridMeasuredViewSpec_cxx& swiftPart):
+      HybridObject(HybridMeasuredViewSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroTest::HybridMeasuredViewSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridMeasuredViewSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::string getText() noexcept override {
+      auto __result = _swiftPart.getText();
+      return __result;
+    }
+    inline void setText(const std::string& text) noexcept override {
+      _swiftPart.setText(text);
+    }
+    inline double getFontSize() noexcept override {
+      return _swiftPart.getFontSize();
+    }
+    inline void setFontSize(double fontSize) noexcept override {
+      _swiftPart.setFontSize(std::forward<decltype(fontSize)>(fontSize));
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroTest::HybridMeasuredViewSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridMeasuredViewComponent.mm b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridMeasuredViewComponent.mm
new file mode 100644
index 0000000000..25b1bab485
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridMeasuredViewComponent.mm
@@ -0,0 +1,152 @@
+///
+/// HybridMeasuredViewComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import "HybridMeasuredViewComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridMeasuredViewSpecSwift.hpp"
+#import "NitroTest-Swift-Cxx-Umbrella.hpp"
+
+#if __has_include(<cxxreact/ReactNativeVersion.h>)
+#include <cxxreact/ReactNativeVersion.h>
+#if REACT_NATIVE_VERSION_MINOR >= 82
+#define ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+#endif
+#endif
+
+using namespace facebook;
+using namespace margelo::nitro::test;
+using namespace margelo::nitro::test::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "MeasuredView" HybridView.
+ */
+@interface HybridMeasuredViewComponent: RCTViewComponentView
++ (BOOL)shouldBeRecycled;
+@end
+
+@implementation HybridMeasuredViewComponent {
+  std::shared_ptr<HybridMeasuredViewSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridMeasuredViewComponent class]];
+
+  // Install self-measurement iff "MeasuredView" conforms to `MeasurableView`.
+  if (NitroTest::HybridMeasuredViewMeasurer::isMeasurable()) {
+    HybridMeasuredViewShadowNode::measureFunction.store(
+      +[](const react::ViewProps& propsBase,
+          const react::LayoutContext& layoutContext,
+          const react::LayoutConstraints& layoutConstraints) -> react::Size {
+        const auto& props = static_cast<const HybridMeasuredViewProps&>(propsBase);
+        margelo::nitro::test::MeasuredViewProps measureProps {
+          /* text */ props.text.value,
+          /* fontSize */ props.fontSize.value
+        };
+        margelo::nitro::test::LayoutContext measureContext {
+          /* pointScaleFactor */ layoutContext.pointScaleFactor,
+          /* isRTL */ layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft
+        };
+        margelo::nitro::test::LayoutConstraints measureConstraints {
+          /* minimumSize */ margelo::nitro::test::Size { layoutConstraints.minimumSize.width, layoutConstraints.minimumSize.height },
+          /* maximumSize */ margelo::nitro::test::Size { layoutConstraints.maximumSize.width, layoutConstraints.maximumSize.height }
+        };
+        auto size = NitroTest::HybridMeasuredViewMeasurer::measure(measureProps, measureContext, measureConstraints);
+        return react::Size { static_cast<react::Float>(size.width), static_cast<react::Float>(size.height) };
+      },
+      std::memory_order_release);
+  }
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridMeasuredViewComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridMeasuredViewSpec> hybridView = NitroTest::NitroTestAutolinking::createMeasuredView();
+    _hybridView = std::dynamic_pointer_cast<HybridMeasuredViewSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  NitroTest::HybridMeasuredViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridMeasuredViewProps const>(props);
+  auto& newViewProps = const_cast<HybridMeasuredViewProps&>(newViewPropsConst);
+  NitroTest::HybridMeasuredViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // text: string
+  if (newViewProps.text.isDirty) {
+    swiftPart.setText(newViewProps.text.value);
+    newViewProps.text.isDirty = false;
+  }
+  // fontSize: number
+  if (newViewProps.fontSize.isDirty) {
+    swiftPart.setFontSize(newViewProps.fontSize.value);
+    newViewProps.fontSize.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (BOOL)shouldBeRecycled {
+  return NitroTest::NitroTestAutolinking::isMeasuredViewRecyclable();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  NitroTest::HybridMeasuredViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.maybePrepareForRecycle();
+}
+
+#ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+- (void)invalidate {
+  NitroTest::HybridMeasuredViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  [super invalidate];
+}
+#endif
+
+@end
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridRecyclableTestViewComponent.mm b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridRecyclableTestViewComponent.mm
index 06ecc420d1..8c0af89de9 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridRecyclableTestViewComponent.mm
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridRecyclableTestViewComponent.mm
@@ -42,6 +42,30 @@ @implementation HybridRecyclableTestViewComponent {
 + (void) load {
   [super load];
   [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridRecyclableTestViewComponent class]];
+
+  // Install self-measurement iff "RecyclableTestView" conforms to `MeasurableView`.
+  if (NitroTest::HybridRecyclableTestViewMeasurer::isMeasurable()) {
+    HybridRecyclableTestViewShadowNode::measureFunction.store(
+      +[](const react::ViewProps& propsBase,
+          const react::LayoutContext& layoutContext,
+          const react::LayoutConstraints& layoutConstraints) -> react::Size {
+        const auto& props = static_cast<const HybridRecyclableTestViewProps&>(propsBase);
+        margelo::nitro::test::RecyclableTestViewProps measureProps {
+          /* isBlue */ props.isBlue.value
+        };
+        margelo::nitro::test::LayoutContext measureContext {
+          /* pointScaleFactor */ layoutContext.pointScaleFactor,
+          /* isRTL */ layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft
+        };
+        margelo::nitro::test::LayoutConstraints measureConstraints {
+          /* minimumSize */ margelo::nitro::test::Size { layoutConstraints.minimumSize.width, layoutConstraints.minimumSize.height },
+          /* maximumSize */ margelo::nitro::test::Size { layoutConstraints.maximumSize.width, layoutConstraints.maximumSize.height }
+        };
+        auto size = NitroTest::HybridRecyclableTestViewMeasurer::measure(measureProps, measureContext, measureConstraints);
+        return react::Size { static_cast<react::Float>(size.width), static_cast<react::Float>(size.height) };
+      },
+      std::memory_order_release);
+  }
 }
 
 + (react::ComponentDescriptorProvider) componentDescriptorProvider {
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm
index 191b76da7a..3824006f36 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/views/HybridTestViewComponent.mm
@@ -42,6 +42,32 @@ @implementation HybridTestViewComponent {
 + (void) load {
   [super load];
   [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridTestViewComponent class]];
+
+  // Install self-measurement iff "TestView" conforms to `MeasurableView`.
+  if (NitroTest::HybridTestViewMeasurer::isMeasurable()) {
+    HybridTestViewShadowNode::measureFunction.store(
+      +[](const react::ViewProps& propsBase,
+          const react::LayoutContext& layoutContext,
+          const react::LayoutConstraints& layoutConstraints) -> react::Size {
+        const auto& props = static_cast<const HybridTestViewProps&>(propsBase);
+        margelo::nitro::test::TestViewProps measureProps {
+          /* isBlue */ props.isBlue.value,
+          /* hasBeenCalled */ props.hasBeenCalled.value,
+          /* colorScheme */ props.colorScheme.value
+        };
+        margelo::nitro::test::LayoutContext measureContext {
+          /* pointScaleFactor */ layoutContext.pointScaleFactor,
+          /* isRTL */ layoutConstraints.layoutDirection == react::LayoutDirection::RightToLeft
+        };
+        margelo::nitro::test::LayoutConstraints measureConstraints {
+          /* minimumSize */ margelo::nitro::test::Size { layoutConstraints.minimumSize.width, layoutConstraints.minimumSize.height },
+          /* maximumSize */ margelo::nitro::test::Size { layoutConstraints.maximumSize.width, layoutConstraints.maximumSize.height }
+        };
+        auto size = NitroTest::HybridTestViewMeasurer::measure(measureProps, measureContext, measureConstraints);
+        return react::Size { static_cast<react::Float>(size.width), static_cast<react::Float>(size.height) };
+      },
+      std::memory_order_release);
+  }
 }
 
 + (react::ComponentDescriptorProvider) componentDescriptorProvider {
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridMeasuredViewSpec.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridMeasuredViewSpec.swift
new file mode 100644
index 0000000000..4e696ce376
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridMeasuredViewSpec.swift
@@ -0,0 +1,56 @@
+///
+/// HybridMeasuredViewSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// See ``HybridMeasuredViewSpec``
+public protocol HybridMeasuredViewSpec_protocol: HybridObject, HybridView {
+  // Properties
+  var text: String { get set }
+  var fontSize: Double { get set }
+
+  // Methods
+  
+}
+
+public extension HybridMeasuredViewSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject MeasuredView]"
+  }
+}
+
+/// See ``HybridMeasuredViewSpec``
+open class HybridMeasuredViewSpec_base {
+  private weak var cxxWrapper: HybridMeasuredViewSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridMeasuredViewSpec_cxx {
+  #if DEBUG
+    guard self is any HybridMeasuredViewSpec else {
+      fatalError("`self` is not a `HybridMeasuredViewSpec`! Did you accidentally inherit from `HybridMeasuredViewSpec_base` instead of `HybridMeasuredViewSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridMeasuredViewSpec_cxx(self as! any HybridMeasuredViewSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the MeasuredView HybridObject.
+ * Implement this protocol to create Swift-based instances of MeasuredView.
+ * ```swift
+ * class HybridMeasuredView : HybridMeasuredViewSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridMeasuredViewSpec = HybridMeasuredViewSpec_protocol & HybridMeasuredViewSpec_base
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridMeasuredViewSpec_cxx.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridMeasuredViewSpec_cxx.swift
new file mode 100644
index 0000000000..88301020b4
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridMeasuredViewSpec_cxx.swift
@@ -0,0 +1,167 @@
+///
+/// HybridMeasuredViewSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridMeasuredViewSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridMeasuredViewSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::test::bridge::swift`)
+   * from `NitroTest-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridMeasuredViewSpec` Swift protocol.
+   */
+  private var __implementation: any HybridMeasuredViewSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridMeasuredViewSpec_
+
+  /**
+   * Create a new `HybridMeasuredViewSpec_cxx` that wraps the given `HybridMeasuredViewSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridMeasuredViewSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridMeasuredViewSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridMeasuredViewSpec() -> any HybridMeasuredViewSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridMeasuredViewSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridMeasuredViewSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridMeasuredViewSpec_cxx {
+    return Unmanaged<HybridMeasuredViewSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridMeasuredViewSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridMeasuredViewSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridMeasuredViewSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridMeasuredViewSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridMeasuredViewSpec_cxx) -> Bool {
+    return self.__implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var text: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.text)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.text = String(newValue)
+    }
+  }
+  
+  public final var fontSize: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.fontSize
+    }
+    @inline(__always)
+    set {
+      self.__implementation.fontSize = newValue
+    }
+  }
+
+  // Methods
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+  
+  public final func maybePrepareForRecycle() {
+    guard let recyclable = __implementation as? any RecyclableView else { return }
+    recyclable.prepareForRecycle()
+  }
+  
+  public final func onDropView() {
+    __implementation.onDropView()
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/LayoutConstraints.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/LayoutConstraints.swift
new file mode 100644
index 0000000000..8379ed9618
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/LayoutConstraints.swift
@@ -0,0 +1,34 @@
+///
+/// LayoutConstraints.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `LayoutConstraints`, backed by a C++ struct.
+ */
+public typealias LayoutConstraints = margelo.nitro.test.LayoutConstraints
+
+public extension LayoutConstraints {
+  private typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Create a new instance of `LayoutConstraints`.
+   */
+  init(minimumSize: Size, maximumSize: Size) {
+    self.init(minimumSize, maximumSize)
+  }
+
+  @inline(__always)
+  var minimumSize: Size {
+    return self.__minimumSize
+  }
+  
+  @inline(__always)
+  var maximumSize: Size {
+    return self.__maximumSize
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/LayoutContext.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/LayoutContext.swift
new file mode 100644
index 0000000000..511b0a61a7
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/LayoutContext.swift
@@ -0,0 +1,34 @@
+///
+/// LayoutContext.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `LayoutContext`, backed by a C++ struct.
+ */
+public typealias LayoutContext = margelo.nitro.test.LayoutContext
+
+public extension LayoutContext {
+  private typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Create a new instance of `LayoutContext`.
+   */
+  init(pointScaleFactor: Double, isRTL: Bool) {
+    self.init(pointScaleFactor, isRTL)
+  }
+
+  @inline(__always)
+  var pointScaleFactor: Double {
+    return self.__pointScaleFactor
+  }
+  
+  @inline(__always)
+  var isRTL: Bool {
+    return self.__isRTL
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/MeasuredViewProps.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/MeasuredViewProps.swift
new file mode 100644
index 0000000000..4e497b6f93
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/MeasuredViewProps.swift
@@ -0,0 +1,34 @@
+///
+/// MeasuredViewProps.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `MeasuredViewProps`, backed by a C++ struct.
+ */
+public typealias MeasuredViewProps = margelo.nitro.test.MeasuredViewProps
+
+public extension MeasuredViewProps {
+  private typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Create a new instance of `MeasuredViewProps`.
+   */
+  init(text: String, fontSize: Double) {
+    self.init(std.string(text), fontSize)
+  }
+
+  @inline(__always)
+  var text: String {
+    return String(self.__text)
+  }
+  
+  @inline(__always)
+  var fontSize: Double {
+    return self.__fontSize
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/RecyclableTestViewProps.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/RecyclableTestViewProps.swift
new file mode 100644
index 0000000000..c5e7811652
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/RecyclableTestViewProps.swift
@@ -0,0 +1,29 @@
+///
+/// RecyclableTestViewProps.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `RecyclableTestViewProps`, backed by a C++ struct.
+ */
+public typealias RecyclableTestViewProps = margelo.nitro.test.RecyclableTestViewProps
+
+public extension RecyclableTestViewProps {
+  private typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Create a new instance of `RecyclableTestViewProps`.
+   */
+  init(isBlue: Bool) {
+    self.init(isBlue)
+  }
+
+  @inline(__always)
+  var isBlue: Bool {
+    return self.__isBlue
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Size.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Size.swift
new file mode 100644
index 0000000000..c33d81e0fd
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Size.swift
@@ -0,0 +1,34 @@
+///
+/// Size.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `Size`, backed by a C++ struct.
+ */
+public typealias Size = margelo.nitro.test.Size
+
+public extension Size {
+  private typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Create a new instance of `Size`.
+   */
+  init(width: Double, height: Double) {
+    self.init(width, height)
+  }
+
+  @inline(__always)
+  var width: Double {
+    return self.__width
+  }
+  
+  @inline(__always)
+  var height: Double {
+    return self.__height
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TestViewProps.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TestViewProps.swift
new file mode 100644
index 0000000000..d276b86fc4
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TestViewProps.swift
@@ -0,0 +1,39 @@
+///
+/// TestViewProps.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `TestViewProps`, backed by a C++ struct.
+ */
+public typealias TestViewProps = margelo.nitro.test.TestViewProps
+
+public extension TestViewProps {
+  private typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Create a new instance of `TestViewProps`.
+   */
+  init(isBlue: Bool, hasBeenCalled: Bool, colorScheme: ColorScheme) {
+    self.init(isBlue, hasBeenCalled, colorScheme)
+  }
+
+  @inline(__always)
+  var isBlue: Bool {
+    return self.__isBlue
+  }
+  
+  @inline(__always)
+  var hasBeenCalled: Bool {
+    return self.__hasBeenCalled
+  }
+  
+  @inline(__always)
+  var colorScheme: ColorScheme {
+    return self.__colorScheme
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridMeasuredViewMeasurer.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridMeasuredViewMeasurer.swift
new file mode 100644
index 0000000000..92c374ade5
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridMeasuredViewMeasurer.swift
@@ -0,0 +1,44 @@
+///
+/// HybridMeasuredViewMeasurer.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+extension HybridMeasuredView {
+  static func measureContent<Props, LayoutContext, LayoutConstraints, Size>(
+    props: Props,
+    layoutContext: LayoutContext,
+    layoutConstraints: LayoutConstraints
+  ) -> Size {
+    fatalError("HybridMeasuredView cannot be measured because it does not implement the generated measureContent(props:layoutContext:layoutConstraints:) signature.")
+  }
+}
+
+/// Generated trampoline bridging the C++ ShadowNode's `measureContent` to
+/// HybridMeasuredView's `MeasurableView.measureContent(...)`. Do not call directly.
+///
+/// All four boundary types are Nitro structs, so each crosses the Swift<->C++
+/// boundary as a single value.
+public final class HybridMeasuredViewMeasurer {
+  /// The conformance is resolved once and cached - the per-measure path then
+  /// avoids re-checking against the metatype on every layout pass.
+  private static let isMeasurableView: Bool = HybridMeasuredView.self is any MeasurableView.Type
+
+  /// Type-level conformance check - no instance required.
+  public static func isMeasurable() -> Bool {
+    return isMeasurableView
+  }
+
+  public static func measure(props: MeasuredViewProps,
+                             layoutContext: LayoutContext,
+                             layoutConstraints: LayoutConstraints) -> Size {
+    return HybridMeasuredView.measureContent(
+      props: props,
+      layoutContext: layoutContext,
+      layoutConstraints: layoutConstraints
+    )
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridRecyclableTestViewMeasurer.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridRecyclableTestViewMeasurer.swift
new file mode 100644
index 0000000000..4b12705694
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridRecyclableTestViewMeasurer.swift
@@ -0,0 +1,44 @@
+///
+/// HybridRecyclableTestViewMeasurer.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+extension HybridRecyclableTestView {
+  static func measureContent<Props, LayoutContext, LayoutConstraints, Size>(
+    props: Props,
+    layoutContext: LayoutContext,
+    layoutConstraints: LayoutConstraints
+  ) -> Size {
+    fatalError("HybridRecyclableTestView cannot be measured because it does not implement the generated measureContent(props:layoutContext:layoutConstraints:) signature.")
+  }
+}
+
+/// Generated trampoline bridging the C++ ShadowNode's `measureContent` to
+/// HybridRecyclableTestView's `MeasurableView.measureContent(...)`. Do not call directly.
+///
+/// All four boundary types are Nitro structs, so each crosses the Swift<->C++
+/// boundary as a single value.
+public final class HybridRecyclableTestViewMeasurer {
+  /// The conformance is resolved once and cached - the per-measure path then
+  /// avoids re-checking against the metatype on every layout pass.
+  private static let isMeasurableView: Bool = HybridRecyclableTestView.self is any MeasurableView.Type
+
+  /// Type-level conformance check - no instance required.
+  public static func isMeasurable() -> Bool {
+    return isMeasurableView
+  }
+
+  public static func measure(props: RecyclableTestViewProps,
+                             layoutContext: LayoutContext,
+                             layoutConstraints: LayoutConstraints) -> Size {
+    return HybridRecyclableTestView.measureContent(
+      props: props,
+      layoutContext: layoutContext,
+      layoutConstraints: layoutConstraints
+    )
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridTestViewMeasurer.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridTestViewMeasurer.swift
new file mode 100644
index 0000000000..f039647a53
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/views/HybridTestViewMeasurer.swift
@@ -0,0 +1,44 @@
+///
+/// HybridTestViewMeasurer.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+extension HybridTestView {
+  static func measureContent<Props, LayoutContext, LayoutConstraints, Size>(
+    props: Props,
+    layoutContext: LayoutContext,
+    layoutConstraints: LayoutConstraints
+  ) -> Size {
+    fatalError("HybridTestView cannot be measured because it does not implement the generated measureContent(props:layoutContext:layoutConstraints:) signature.")
+  }
+}
+
+/// Generated trampoline bridging the C++ ShadowNode's `measureContent` to
+/// HybridTestView's `MeasurableView.measureContent(...)`. Do not call directly.
+///
+/// All four boundary types are Nitro structs, so each crosses the Swift<->C++
+/// boundary as a single value.
+public final class HybridTestViewMeasurer {
+  /// The conformance is resolved once and cached - the per-measure path then
+  /// avoids re-checking against the metatype on every layout pass.
+  private static let isMeasurableView: Bool = HybridTestView.self is any MeasurableView.Type
+
+  /// Type-level conformance check - no instance required.
+  public static func isMeasurable() -> Bool {
+    return isMeasurableView
+  }
+
+  public static func measure(props: TestViewProps,
+                             layoutContext: LayoutContext,
+                             layoutConstraints: LayoutConstraints) -> Size {
+    return HybridTestView.measureContent(
+      props: props,
+      layoutContext: layoutContext,
+      layoutConstraints: layoutConstraints
+    )
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridMeasuredViewSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridMeasuredViewSpec.cpp
new file mode 100644
index 0000000000..748ba963eb
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridMeasuredViewSpec.cpp
@@ -0,0 +1,24 @@
+///
+/// HybridMeasuredViewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMeasuredViewSpec.hpp"
+
+namespace margelo::nitro::test {
+
+  void HybridMeasuredViewSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("text", &HybridMeasuredViewSpec::getText);
+      prototype.registerHybridSetter("text", &HybridMeasuredViewSpec::setText);
+      prototype.registerHybridGetter("fontSize", &HybridMeasuredViewSpec::getFontSize);
+      prototype.registerHybridSetter("fontSize", &HybridMeasuredViewSpec::setFontSize);
+    });
+  }
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridMeasuredViewSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridMeasuredViewSpec.hpp
new file mode 100644
index 0000000000..676032d72e
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridMeasuredViewSpec.hpp
@@ -0,0 +1,65 @@
+///
+/// HybridMeasuredViewSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::test {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MeasuredView`
+   * Inherit this class to create instances of `HybridMeasuredViewSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMeasuredView: public HybridMeasuredViewSpec {
+   * public:
+   *   HybridMeasuredView(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMeasuredViewSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMeasuredViewSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMeasuredViewSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getText() = 0;
+      virtual void setText(const std::string& text) = 0;
+      virtual double getFontSize() = 0;
+      virtual void setFontSize(double fontSize) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MeasuredView";
+  };
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/LayoutConstraints.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/LayoutConstraints.hpp
new file mode 100644
index 0000000000..067293f48d
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/LayoutConstraints.hpp
@@ -0,0 +1,88 @@
+///
+/// LayoutConstraints.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `Size` to properly resolve imports.
+namespace margelo::nitro::test { struct Size; }
+
+#include "Size.hpp"
+
+namespace margelo::nitro::test {
+
+  /**
+   * A struct which can be represented as a JavaScript object (LayoutConstraints).
+   */
+  struct LayoutConstraints final {
+  public:
+    Size minimumSize     SWIFT_PRIVATE;
+    Size maximumSize     SWIFT_PRIVATE;
+
+  public:
+    LayoutConstraints() = default;
+    explicit LayoutConstraints(Size minimumSize, Size maximumSize): minimumSize(minimumSize), maximumSize(maximumSize) {}
+
+  public:
+    friend bool operator==(const LayoutConstraints& lhs, const LayoutConstraints& rhs) = default;
+  };
+
+} // namespace margelo::nitro::test
+
+namespace margelo::nitro {
+
+  // C++ LayoutConstraints <> JS LayoutConstraints (object)
+  template <>
+  struct JSIConverter<margelo::nitro::test::LayoutConstraints> final {
+    static inline margelo::nitro::test::LayoutConstraints fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::test::LayoutConstraints(
+        JSIConverter<margelo::nitro::test::Size>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "minimumSize"))),
+        JSIConverter<margelo::nitro::test::Size>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "maximumSize")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::LayoutConstraints& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "minimumSize"), JSIConverter<margelo::nitro::test::Size>::toJSI(runtime, arg.minimumSize));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "maximumSize"), JSIConverter<margelo::nitro::test::Size>::toJSI(runtime, arg.maximumSize));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<margelo::nitro::test::Size>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "minimumSize")))) return false;
+      if (!JSIConverter<margelo::nitro::test::Size>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "maximumSize")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/LayoutContext.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/LayoutContext.hpp
new file mode 100644
index 0000000000..840645e58a
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/LayoutContext.hpp
@@ -0,0 +1,87 @@
+///
+/// LayoutContext.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::test {
+
+  /**
+   * A struct which can be represented as a JavaScript object (LayoutContext).
+   */
+  struct LayoutContext final {
+  public:
+    double pointScaleFactor     SWIFT_PRIVATE;
+    bool isRTL     SWIFT_PRIVATE;
+
+  public:
+    LayoutContext() = default;
+    explicit LayoutContext(double pointScaleFactor, bool isRTL): pointScaleFactor(pointScaleFactor), isRTL(isRTL) {}
+
+  public:
+    friend bool operator==(const LayoutContext& lhs, const LayoutContext& rhs) = default;
+  };
+
+} // namespace margelo::nitro::test
+
+namespace margelo::nitro {
+
+  // C++ LayoutContext <> JS LayoutContext (object)
+  template <>
+  struct JSIConverter<margelo::nitro::test::LayoutContext> final {
+    static inline margelo::nitro::test::LayoutContext fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::test::LayoutContext(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pointScaleFactor"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isRTL")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::LayoutContext& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "pointScaleFactor"), JSIConverter<double>::toJSI(runtime, arg.pointScaleFactor));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isRTL"), JSIConverter<bool>::toJSI(runtime, arg.isRTL));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pointScaleFactor")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isRTL")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/MeasuredViewProps.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/MeasuredViewProps.hpp
new file mode 100644
index 0000000000..6d3c23f654
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/MeasuredViewProps.hpp
@@ -0,0 +1,87 @@
+///
+/// MeasuredViewProps.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::test {
+
+  /**
+   * A struct which can be represented as a JavaScript object (MeasuredViewProps).
+   */
+  struct MeasuredViewProps final {
+  public:
+    std::string text     SWIFT_PRIVATE;
+    double fontSize     SWIFT_PRIVATE;
+
+  public:
+    MeasuredViewProps() = default;
+    explicit MeasuredViewProps(std::string text, double fontSize): text(text), fontSize(fontSize) {}
+
+  public:
+    friend bool operator==(const MeasuredViewProps& lhs, const MeasuredViewProps& rhs) = default;
+  };
+
+} // namespace margelo::nitro::test
+
+namespace margelo::nitro {
+
+  // C++ MeasuredViewProps <> JS MeasuredViewProps (object)
+  template <>
+  struct JSIConverter<margelo::nitro::test::MeasuredViewProps> final {
+    static inline margelo::nitro::test::MeasuredViewProps fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::test::MeasuredViewProps(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "text"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fontSize")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::MeasuredViewProps& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "text"), JSIConverter<std::string>::toJSI(runtime, arg.text));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "fontSize"), JSIConverter<double>::toJSI(runtime, arg.fontSize));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "text")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fontSize")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/RecyclableTestViewProps.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/RecyclableTestViewProps.hpp
new file mode 100644
index 0000000000..4c30a14f20
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/RecyclableTestViewProps.hpp
@@ -0,0 +1,83 @@
+///
+/// RecyclableTestViewProps.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::test {
+
+  /**
+   * A struct which can be represented as a JavaScript object (RecyclableTestViewProps).
+   */
+  struct RecyclableTestViewProps final {
+  public:
+    bool isBlue     SWIFT_PRIVATE;
+
+  public:
+    RecyclableTestViewProps() = default;
+    explicit RecyclableTestViewProps(bool isBlue): isBlue(isBlue) {}
+
+  public:
+    friend bool operator==(const RecyclableTestViewProps& lhs, const RecyclableTestViewProps& rhs) = default;
+  };
+
+} // namespace margelo::nitro::test
+
+namespace margelo::nitro {
+
+  // C++ RecyclableTestViewProps <> JS RecyclableTestViewProps (object)
+  template <>
+  struct JSIConverter<margelo::nitro::test::RecyclableTestViewProps> final {
+    static inline margelo::nitro::test::RecyclableTestViewProps fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::test::RecyclableTestViewProps(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isBlue")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::RecyclableTestViewProps& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isBlue"), JSIConverter<bool>::toJSI(runtime, arg.isBlue));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isBlue")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/Size.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/Size.hpp
new file mode 100644
index 0000000000..ab2a8f64a5
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/Size.hpp
@@ -0,0 +1,87 @@
+///
+/// Size.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::test {
+
+  /**
+   * A struct which can be represented as a JavaScript object (Size).
+   */
+  struct Size final {
+  public:
+    double width     SWIFT_PRIVATE;
+    double height     SWIFT_PRIVATE;
+
+  public:
+    Size() = default;
+    explicit Size(double width, double height): width(width), height(height) {}
+
+  public:
+    friend bool operator==(const Size& lhs, const Size& rhs) = default;
+  };
+
+} // namespace margelo::nitro::test
+
+namespace margelo::nitro {
+
+  // C++ Size <> JS Size (object)
+  template <>
+  struct JSIConverter<margelo::nitro::test::Size> final {
+    static inline margelo::nitro::test::Size fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::test::Size(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::Size& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "width"), JSIConverter<double>::toJSI(runtime, arg.width));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<double>::toJSI(runtime, arg.height));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TestViewProps.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TestViewProps.hpp
new file mode 100644
index 0000000000..aac2edbbcd
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TestViewProps.hpp
@@ -0,0 +1,92 @@
+///
+/// TestViewProps.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ColorScheme` to properly resolve imports.
+namespace margelo::nitro::test { enum class ColorScheme; }
+
+#include "ColorScheme.hpp"
+
+namespace margelo::nitro::test {
+
+  /**
+   * A struct which can be represented as a JavaScript object (TestViewProps).
+   */
+  struct TestViewProps final {
+  public:
+    bool isBlue     SWIFT_PRIVATE;
+    bool hasBeenCalled     SWIFT_PRIVATE;
+    ColorScheme colorScheme     SWIFT_PRIVATE;
+
+  public:
+    TestViewProps() = default;
+    explicit TestViewProps(bool isBlue, bool hasBeenCalled, ColorScheme colorScheme): isBlue(isBlue), hasBeenCalled(hasBeenCalled), colorScheme(colorScheme) {}
+
+  public:
+    friend bool operator==(const TestViewProps& lhs, const TestViewProps& rhs) = default;
+  };
+
+} // namespace margelo::nitro::test
+
+namespace margelo::nitro {
+
+  // C++ TestViewProps <> JS TestViewProps (object)
+  template <>
+  struct JSIConverter<margelo::nitro::test::TestViewProps> final {
+    static inline margelo::nitro::test::TestViewProps fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::test::TestViewProps(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isBlue"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hasBeenCalled"))),
+        JSIConverter<margelo::nitro::test::ColorScheme>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "colorScheme")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::TestViewProps& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isBlue"), JSIConverter<bool>::toJSI(runtime, arg.isBlue));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "hasBeenCalled"), JSIConverter<bool>::toJSI(runtime, arg.hasBeenCalled));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "colorScheme"), JSIConverter<margelo::nitro::test::ColorScheme>::toJSI(runtime, arg.colorScheme));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isBlue")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hasBeenCalled")))) return false;
+      if (!JSIConverter<margelo::nitro::test::ColorScheme>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "colorScheme")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridMeasuredViewComponent.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridMeasuredViewComponent.cpp
new file mode 100644
index 0000000000..b1ccd2ba2d
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridMeasuredViewComponent.cpp
@@ -0,0 +1,94 @@
+///
+/// HybridMeasuredViewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMeasuredViewComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <NitroModules/PropNameIDCache.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::test::views {
+
+  extern const char HybridMeasuredViewComponentName[] = "MeasuredView";
+
+  HybridMeasuredViewProps::HybridMeasuredViewProps(const react::PropsParserContext& context,
+                                                   const HybridMeasuredViewProps& sourceProps,
+                                                   const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    text([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("text", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.text;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.text);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("MeasuredView.text: ") + exc.what());
+      }
+    }()),
+    fontSize([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("fontSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.fontSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.fontSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("MeasuredView.fontSize: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridMeasuredViewSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridMeasuredViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("MeasuredView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  bool HybridMeasuredViewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("text"): return true;
+      case hashString("fontSize"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridMeasuredViewComponentDescriptor::HybridMeasuredViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser()) {}
+
+  std::shared_ptr<const react::Props> HybridMeasuredViewComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                        const std::shared_ptr<const react::Props>& props,
+                                                                                        react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridMeasuredViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridMeasuredViewComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = static_cast<HybridMeasuredViewShadowNode&>(shadowNode);
+    const std::shared_ptr<const HybridMeasuredViewProps>& constProps = concreteShadowNode.getConcreteSharedProps();
+    const std::shared_ptr<HybridMeasuredViewProps>& props = std::const_pointer_cast<HybridMeasuredViewProps>(constProps);
+    HybridMeasuredViewState state{props};
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::test::views
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridMeasuredViewComponent.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridMeasuredViewComponent.hpp
new file mode 100644
index 0000000000..0eb5e769a8
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridMeasuredViewComponent.hpp
@@ -0,0 +1,165 @@
+///
+/// HybridMeasuredViewComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <atomic>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
+
+#include <string>
+#include <memory>
+#include "HybridMeasuredViewSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::test::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridMeasuredViewComponentName[];
+
+  /**
+   * Props for the "MeasuredView" View.
+   */
+  class HybridMeasuredViewProps final: public react::ViewProps {
+  public:
+    HybridMeasuredViewProps() = default;
+    HybridMeasuredViewProps(const react::PropsParserContext& context,
+                            const HybridMeasuredViewProps& sourceProps,
+                            const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::string> text;
+    CachedProp<double> fontSize;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridMeasuredViewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "MeasuredView" View.
+   */
+  class HybridMeasuredViewState final {
+  public:
+    HybridMeasuredViewState() = default;
+    explicit HybridMeasuredViewState(const std::shared_ptr<HybridMeasuredViewProps>& props):
+      _props(props) {}
+
+  public:
+    [[nodiscard]]
+    const std::shared_ptr<HybridMeasuredViewProps>& getProps() const {
+      return _props;
+    }
+
+  public:
+#ifdef ANDROID
+  HybridMeasuredViewState(const HybridMeasuredViewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridMeasuredViewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridMeasuredViewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::shared_ptr<HybridMeasuredViewProps> _props;
+  };
+
+  /**
+   * The base Shadow Node for the "MeasuredView" View.
+   */
+  using HybridMeasuredViewShadowNodeBase = react::ConcreteViewShadowNode<HybridMeasuredViewComponentName /* "HybridMeasuredView" */,
+                                                                         HybridMeasuredViewProps /* custom props */,
+                                                                         react::ViewEventEmitter /* default */,
+                                                                         HybridMeasuredViewState /* custom state */>;
+
+  /**
+   * The Shadow Node for the "MeasuredView" View.
+   *
+   * Self-measurement is opt-in: when the native implementation conforms to
+   * `MeasurableView`, the platform layer installs `measureFunction` once during
+   * view registration and this becomes a measurable Yoga leaf that sizes itself
+   * from its props. Otherwise it stays a normal container whose React children
+   * are laid out by flexbox.
+   */
+  class HybridMeasuredViewShadowNode final: public HybridMeasuredViewShadowNodeBase {
+  public:
+    // Inherit both the create- and clone-constructors.
+    using HybridMeasuredViewShadowNodeBase::HybridMeasuredViewShadowNodeBase;
+
+    /**
+     * A pure (props + constraints) -> size function, run on the Yoga/shadow thread.
+     */
+    using MeasureFunction = react::Size (*)(const react::ViewProps& props,
+                                            const react::LayoutContext& layoutContext,
+                                            const react::LayoutConstraints& layoutConstraints);
+
+    /**
+     * Installed exactly once during view registration (before the first layout
+     * pass), iff the native implementation conforms to `MeasurableView`. Read
+     * lock-free on the shadow thread - no map lookup, locking or allocation on
+     * the measure hot-path.
+     */
+    inline static std::atomic<MeasureFunction> measureFunction{nullptr};
+
+    static react::ShadowNodeTraits BaseTraits() {
+      auto traits = HybridMeasuredViewShadowNodeBase::BaseTraits();
+      if (measureFunction.load(std::memory_order_acquire) != nullptr) {
+        traits.set(react::ShadowNodeTraits::Trait::LeafYogaNode);
+        traits.set(react::ShadowNodeTraits::Trait::MeasurableYogaNode);
+      }
+      return traits;
+    }
+
+    react::Size measureContent(const react::LayoutContext& layoutContext,
+                               const react::LayoutConstraints& layoutConstraints) const override {
+      const MeasureFunction measure = measureFunction.load(std::memory_order_acquire);
+      if (measure == nullptr) [[unlikely]] {
+        return react::Size{0, 0};
+      }
+      return measure(getConcreteProps(), layoutContext, layoutConstraints);
+    }
+  };
+
+  /**
+   * The Component Descriptor for the "MeasuredView" View.
+   */
+  class HybridMeasuredViewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridMeasuredViewShadowNode> {
+  public:
+    explicit HybridMeasuredViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridMeasuredViewProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "MeasuredView" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::test::views
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridRecyclableTestViewComponent.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridRecyclableTestViewComponent.hpp
index f5fa26f1c9..6221bcfe31 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridRecyclableTestViewComponent.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridRecyclableTestViewComponent.hpp
@@ -10,11 +10,16 @@
 #include <optional>
 #include <NitroModules/NitroDefines.hpp>
 #include <NitroModules/NitroHash.hpp>
+#include <atomic>
 #include <NitroModules/CachedProp.hpp>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
 
 #include <memory>
 #include "HybridRecyclableTestViewSpec.hpp"
@@ -78,13 +83,61 @@ namespace margelo::nitro::test::views {
     std::shared_ptr<HybridRecyclableTestViewProps> _props;
   };
 
+  /**
+   * The base Shadow Node for the "RecyclableTestView" View.
+   */
+  using HybridRecyclableTestViewShadowNodeBase = react::ConcreteViewShadowNode<HybridRecyclableTestViewComponentName /* "HybridRecyclableTestView" */,
+                                                                               HybridRecyclableTestViewProps /* custom props */,
+                                                                               react::ViewEventEmitter /* default */,
+                                                                               HybridRecyclableTestViewState /* custom state */>;
+
   /**
    * The Shadow Node for the "RecyclableTestView" View.
+   *
+   * Self-measurement is opt-in: when the native implementation conforms to
+   * `MeasurableView`, the platform layer installs `measureFunction` once during
+   * view registration and this becomes a measurable Yoga leaf that sizes itself
+   * from its props. Otherwise it stays a normal container whose React children
+   * are laid out by flexbox.
    */
-  using HybridRecyclableTestViewShadowNode = react::ConcreteViewShadowNode<HybridRecyclableTestViewComponentName /* "HybridRecyclableTestView" */,
-                                                                           HybridRecyclableTestViewProps /* custom props */,
-                                                                           react::ViewEventEmitter /* default */,
-                                                                           HybridRecyclableTestViewState /* custom state */>;
+  class HybridRecyclableTestViewShadowNode final: public HybridRecyclableTestViewShadowNodeBase {
+  public:
+    // Inherit both the create- and clone-constructors.
+    using HybridRecyclableTestViewShadowNodeBase::HybridRecyclableTestViewShadowNodeBase;
+
+    /**
+     * A pure (props + constraints) -> size function, run on the Yoga/shadow thread.
+     */
+    using MeasureFunction = react::Size (*)(const react::ViewProps& props,
+                                            const react::LayoutContext& layoutContext,
+                                            const react::LayoutConstraints& layoutConstraints);
+
+    /**
+     * Installed exactly once during view registration (before the first layout
+     * pass), iff the native implementation conforms to `MeasurableView`. Read
+     * lock-free on the shadow thread - no map lookup, locking or allocation on
+     * the measure hot-path.
+     */
+    inline static std::atomic<MeasureFunction> measureFunction{nullptr};
+
+    static react::ShadowNodeTraits BaseTraits() {
+      auto traits = HybridRecyclableTestViewShadowNodeBase::BaseTraits();
+      if (measureFunction.load(std::memory_order_acquire) != nullptr) {
+        traits.set(react::ShadowNodeTraits::Trait::LeafYogaNode);
+        traits.set(react::ShadowNodeTraits::Trait::MeasurableYogaNode);
+      }
+      return traits;
+    }
+
+    react::Size measureContent(const react::LayoutContext& layoutContext,
+                               const react::LayoutConstraints& layoutConstraints) const override {
+      const MeasureFunction measure = measureFunction.load(std::memory_order_acquire);
+      if (measure == nullptr) [[unlikely]] {
+        return react::Size{0, 0};
+      }
+      return measure(getConcreteProps(), layoutContext, layoutConstraints);
+    }
+  };
 
   /**
    * The Component Descriptor for the "RecyclableTestView" View.
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp
index 2e2f681b1d..1598cf78e3 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/views/HybridTestViewComponent.hpp
@@ -10,11 +10,16 @@
 #include <optional>
 #include <NitroModules/NitroDefines.hpp>
 #include <NitroModules/NitroHash.hpp>
+#include <atomic>
 #include <NitroModules/CachedProp.hpp>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Size.h>
 
 #include "ColorScheme.hpp"
 #include <functional>
@@ -82,13 +87,61 @@ namespace margelo::nitro::test::views {
     std::shared_ptr<HybridTestViewProps> _props;
   };
 
+  /**
+   * The base Shadow Node for the "TestView" View.
+   */
+  using HybridTestViewShadowNodeBase = react::ConcreteViewShadowNode<HybridTestViewComponentName /* "HybridTestView" */,
+                                                                     HybridTestViewProps /* custom props */,
+                                                                     react::ViewEventEmitter /* default */,
+                                                                     HybridTestViewState /* custom state */>;
+
   /**
    * The Shadow Node for the "TestView" View.
+   *
+   * Self-measurement is opt-in: when the native implementation conforms to
+   * `MeasurableView`, the platform layer installs `measureFunction` once during
+   * view registration and this becomes a measurable Yoga leaf that sizes itself
+   * from its props. Otherwise it stays a normal container whose React children
+   * are laid out by flexbox.
    */
-  using HybridTestViewShadowNode = react::ConcreteViewShadowNode<HybridTestViewComponentName /* "HybridTestView" */,
-                                                                 HybridTestViewProps /* custom props */,
-                                                                 react::ViewEventEmitter /* default */,
-                                                                 HybridTestViewState /* custom state */>;
+  class HybridTestViewShadowNode final: public HybridTestViewShadowNodeBase {
+  public:
+    // Inherit both the create- and clone-constructors.
+    using HybridTestViewShadowNodeBase::HybridTestViewShadowNodeBase;
+
+    /**
+     * A pure (props + constraints) -> size function, run on the Yoga/shadow thread.
+     */
+    using MeasureFunction = react::Size (*)(const react::ViewProps& props,
+                                            const react::LayoutContext& layoutContext,
+                                            const react::LayoutConstraints& layoutConstraints);
+
+    /**
+     * Installed exactly once during view registration (before the first layout
+     * pass), iff the native implementation conforms to `MeasurableView`. Read
+     * lock-free on the shadow thread - no map lookup, locking or allocation on
+     * the measure hot-path.
+     */
+    inline static std::atomic<MeasureFunction> measureFunction{nullptr};
+
+    static react::ShadowNodeTraits BaseTraits() {
+      auto traits = HybridTestViewShadowNodeBase::BaseTraits();
+      if (measureFunction.load(std::memory_order_acquire) != nullptr) {
+        traits.set(react::ShadowNodeTraits::Trait::LeafYogaNode);
+        traits.set(react::ShadowNodeTraits::Trait::MeasurableYogaNode);
+      }
+      return traits;
+    }
+
+    react::Size measureContent(const react::LayoutContext& layoutContext,
+                               const react::LayoutConstraints& layoutConstraints) const override {
+      const MeasureFunction measure = measureFunction.load(std::memory_order_acquire);
+      if (measure == nullptr) [[unlikely]] {
+        return react::Size{0, 0};
+      }
+      return measure(getConcreteProps(), layoutContext, layoutConstraints);
+    }
+  };
 
   /**
    * The Component Descriptor for the "TestView" View.
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/json/MeasuredViewConfig.json b/packages/react-native-nitro-test/nitrogen/generated/shared/json/MeasuredViewConfig.json
new file mode 100644
index 0000000000..1dd1762b1f
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/json/MeasuredViewConfig.json
@@ -0,0 +1,11 @@
+{
+  "uiViewClassName": "MeasuredView",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "text": true,
+    "fontSize": true,
+    "hybridRef": true
+  }
+}
diff --git a/packages/react-native-nitro-test/src/index.ts b/packages/react-native-nitro-test/src/index.ts
index 6d4b6070d4..91c376cb67 100644
--- a/packages/react-native-nitro-test/src/index.ts
+++ b/packages/react-native-nitro-test/src/index.ts
@@ -13,6 +13,7 @@ export * from './specs/Child.nitro'
 export * from './specs/PlatformObject.nitro'
 export * from './specs/TestObject.nitro'
 export * from './specs/TestView.nitro'
+export * from './specs/MeasuredView.nitro'
 
 // Export all HybridObject singleton instances
 export const HybridTestObjectCpp =
@@ -32,3 +33,4 @@ export {
   RecyclableTestView,
   type RecyclableTestViewRef,
 } from './views/RecyclableTestView'
+export { MeasuredView, type MeasuredViewRef } from './views/MeasuredView'
diff --git a/packages/react-native-nitro-test/src/specs/MeasuredView.nitro.ts b/packages/react-native-nitro-test/src/specs/MeasuredView.nitro.ts
new file mode 100644
index 0000000000..fd7e897994
--- /dev/null
+++ b/packages/react-native-nitro-test/src/specs/MeasuredView.nitro.ts
@@ -0,0 +1,18 @@
+import type {
+  HybridView,
+  HybridViewMethods,
+  HybridViewProps,
+} from 'react-native-nitro-modules'
+
+export interface MeasuredViewProps extends HybridViewProps {
+  text: string
+  fontSize: number
+}
+
+export interface MeasuredViewMethods extends HybridViewMethods {}
+
+export type MeasuredView = HybridView<
+  MeasuredViewProps,
+  MeasuredViewMethods,
+  { ios: 'swift'; android: 'kotlin' }
+>
diff --git a/packages/react-native-nitro-test/src/views/MeasuredView.ts b/packages/react-native-nitro-test/src/views/MeasuredView.ts
new file mode 100644
index 0000000000..17aa05a98d
--- /dev/null
+++ b/packages/react-native-nitro-test/src/views/MeasuredView.ts
@@ -0,0 +1,13 @@
+import { getHostComponent, type HybridRef } from 'react-native-nitro-modules'
+import MeasuredViewConfig from '../../nitrogen/generated/shared/json/MeasuredViewConfig.json'
+import type {
+  MeasuredViewMethods,
+  MeasuredViewProps,
+} from '../specs/MeasuredView.nitro'
+
+export const MeasuredView = getHostComponent<
+  MeasuredViewProps,
+  MeasuredViewMethods
+>('MeasuredView', () => MeasuredViewConfig)
+
+export type MeasuredViewRef = HybridRef<MeasuredViewProps, MeasuredViewMethods>