nitrogen 0.34.1 → 0.35.0

package/lib/autolinking/android/createHybridObjectInitializer.js

@@ -17,6 +17,7 @@ export function createHybridObjectIntializer() {
     const autolinkedHybridObjects = NitroConfig.current.getAutolinkedHybridObjects();
     const cppHybridObjectImports = [];
     const cppRegistrations = [];
+    const cppDefinitions = [];
     for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
         const config = autolinkedHybridObjects[hybridObjectName];
         if (config?.cpp != null) {
@@ -30,11 +31,12 @@ export function createHybridObjectIntializer() {
         }
         if (config?.kotlin != null) {
             // Autolink a Kotlin HybridObject through JNI/C++!
-            const { cppCode, requiredImports } = createJNIHybridObjectRegistration({
+            const { cppCode, cppDefinition, requiredImports } = createJNIHybridObjectRegistration({
                 hybridObjectName: hybridObjectName,
                 jniClassName: config.kotlin,
             });
             cppHybridObjectImports.push(...requiredImports);
+            cppDefinitions.push(cppDefinition);
             cppRegistrations.push(cppCode);
         }
     }
@@ -100,6 +102,8 @@ int initialize(JavaVM* vm) {
   });
 }
 
+${cppDefinitions.join('\n')}
+
 void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace ${cxxNamespace};

package/lib/syntax/kotlin/FbjniHybridObject.js

@@ -1,4 +1,4 @@
-import { createIndentation, indent } from '../../utils.js';
+import { indent } from '../../utils.js';
 import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
 import { includeHeader } from '../c++/includeNitroHeader.js';
 import { getAllTypes } from '../getAllTypes.js';
@@ -25,19 +25,29 @@ export function createFbjniHybridObject(spec) {
         .map((p) => p.getCode('c++', { override: true }))
         .join('\n');
     const jniClassDescriptor = spec.config.getAndroidPackage('c++/jni', name.HybridTSpec);
+    const cxxPartJniClassDescriptor = `${jniClassDescriptor}$CxxPart`;
     const cxxNamespace = spec.config.getCxxNamespace('c++');
-    const spaces = createIndentation(name.JHybridTSpec.length);
-    let cppBase = 'JHybridObject';
+    let cppBaseClass = 'JHybridObject';
+    let javaPartBaseClass = 'JHybridObject::JavaPart';
+    let cxxPartBaseClass = 'JHybridObject::CxxPart';
+    const constructorCalls = [
+        `HybridObject(${name.HybridTSpec}::TAG)`,
+        `JHybridObject(javaPart)`,
+    ];
     if (spec.baseTypes.length > 0) {
         if (spec.baseTypes.length > 1) {
             throw new Error(`${name.T}: Inheriting from multiple HybridObject bases is not yet supported on Kotlin!`);
         }
         const base = spec.baseTypes[0];
-        cppBase = getHybridObjectName(base.name).JHybridTSpec;
+        let baseTypename = getHybridObjectName(base.name).JHybridTSpec;
         if (base.config.isExternalConfig) {
             // It's an external type we inherit from - we have to prefix the namespace
-            cppBase = base.config.getCxxNamespace('c++', cppBase);
+            baseTypename = base.config.getCxxNamespace('c++', baseTypename);
         }
+        cppBaseClass = baseTypename;
+        javaPartBaseClass = `${baseTypename}::JavaPart`;
+        cxxPartBaseClass = `${baseTypename}::CxxPart`;
+        constructorCalls.push(`${baseTypename}(javaPart)`);
     }
     const cppImports = [];
     for (const base of spec.baseTypes) {
@@ -71,34 +81,32 @@ namespace ${cxxNamespace} {
 
   using namespace facebook;
 
-  class ${name.JHybridTSpec}: public jni::HybridClass<${name.JHybridTSpec}, ${cppBase}>,
-${spaces}          public virtual ${name.HybridTSpec} {
+  class ${name.JHybridTSpec}: public virtual ${name.HybridTSpec}, public virtual ${cppBaseClass} {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
-    static void registerNatives();
-
-  protected:
-    // C++ constructor (called from Java via \`initHybrid()\`)
-    explicit ${name.JHybridTSpec}(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(${name.HybridTSpec}::TAG),
-      HybridBase(jThis),
-      _javaPart(jni::make_global(jThis)) {}
+    struct JavaPart: public jni::JavaClass<JavaPart, ${javaPartBaseClass}> {
+      static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+      std::shared_ptr<${name.JHybridTSpec}> get${name.JHybridTSpec}();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, ${cxxPartBaseClass}> {
+      static auto constexpr kJavaDescriptor = "L${cxxPartJniClassDescriptor};";
+      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 ${name.JHybridTSpec}(const jni::local_ref<${name.JHybridTSpec}::JavaPart>& javaPart):
+      ${indent(constructorCalls.join(',\n'), '      ')},
+      _javaPart(jni::make_global(javaPart)) {}
     ~${name.JHybridTSpec}() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
 
   public:
-    size_t getExternalMemorySize() noexcept override;
-    bool equals(const std::shared_ptr<HybridObject>& other) override;
-    void dispose() noexcept override;
-    std::string toString() override;
-
-  public:
-    inline const jni::global_ref<${name.JHybridTSpec}::javaobject>& getJavaPart() const noexcept {
+    inline const jni::global_ref<${name.JHybridTSpec}::JavaPart>& getJavaPart() const noexcept {
       return _javaPart;
     }
 
@@ -111,9 +119,7 @@ ${spaces}          public virtual ${name.HybridTSpec} {
     ${indent(methodsDecl, '    ')}
 
   private:
-    friend HybridBase;
-    using HybridBase::HybridBase;
-    jni::global_ref<${name.JHybridTSpec}::javaobject> _javaPart;
+    jni::global_ref<${name.JHybridTSpec}::JavaPart> _javaPart;
   };
 
 } // namespace ${cxxNamespace}
@@ -121,7 +127,7 @@ ${spaces}          public virtual ${name.HybridTSpec} {
     // Make sure we register all native JNI methods on app startup
     addJNINativeRegistration({
         namespace: cxxNamespace,
-        className: `${name.JHybridTSpec}`,
+        className: `${name.JHybridTSpec}::CxxPart`,
         import: {
             name: `${name.JHybridTSpec}.hpp`,
             space: 'user',
@@ -158,37 +164,31 @@ ${cppIncludes.join('\n')}
 
 namespace ${cxxNamespace} {
 
-  jni::local_ref<${name.JHybridTSpec}::jhybriddata> ${name.JHybridTSpec}::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
-  }
-
-  void ${name.JHybridTSpec}::registerNatives() {
-    registerHybrid({
-      makeNativeMethod("initHybrid", ${name.JHybridTSpec}::initHybrid),
-    });
+  std::shared_ptr<${name.JHybridTSpec}> ${name.JHybridTSpec}::JavaPart::get${name.JHybridTSpec}() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<${name.JHybridTSpec}>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to ${name.JHybridTSpec}!");
+    }
+    return castHybridObject;
   }
 
-  size_t ${name.JHybridTSpec}::getExternalMemorySize() noexcept {
-    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
-    return method(_javaPart);
+  jni::local_ref<${name.JHybridTSpec}::CxxPart::jhybriddata> ${name.JHybridTSpec}::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
   }
 
-  bool ${name.JHybridTSpec}::equals(const std::shared_ptr<HybridObject>& other) {
-    if (auto otherCast = std::dynamic_pointer_cast<${name.JHybridTSpec}>(other)) {
-      return _javaPart == otherCast->_javaPart;
+  std::shared_ptr<JHybridObject> ${name.JHybridTSpec}::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<${name.JHybridTSpec}::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to ${name.JHybridTSpec}::JavaPart!");
     }
-    return false;
+    return std::make_shared<${name.JHybridTSpec}>(castJavaPart);
   }
 
-  void ${name.JHybridTSpec}::dispose() noexcept {
-    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
-    method(_javaPart);
-  }
-
-  std::string ${name.JHybridTSpec}::toString() {
-    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
-    auto javaString = method(_javaPart);
-    return javaString->toStdString();
+  void ${name.JHybridTSpec}::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", ${name.JHybridTSpec}::CxxPart::initHybrid),
+    });
   }
 
   // Properties
@@ -242,7 +242,7 @@ function getFbjniMethodForwardImplementation(spec, method, jniMethodName) {
     if (returnJNI.hasType) {
         // return something - we need to parse it
         body = `
-static const auto method = javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
+static const auto method = _javaPart->javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
 auto __result = method(${paramsForward.join(', ')});
 return ${returnJNI.parse('__result', 'kotlin', 'c++', 'c++')};
     `;
@@ -250,7 +250,7 @@ return ${returnJNI.parse('__result', 'kotlin', 'c++', 'c++')};
     else {
         // void method. no return
         body = `
-static const auto method = javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
+static const auto method = _javaPart->javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
 method(${paramsForward.join(', ')});
    `;
     }

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -343,7 +343,7 @@ export class KotlinCxxBridgedType {
                     case 'c++':
                         const hybridObjectType = getTypeAs(this.type, HybridObjectType);
                         const fullName = this.getFullJHybridObjectName(hybridObjectType);
-                        return `${fullName}::javaobject`;
+                        return `${fullName}::JavaPart`;
                     default:
                         return this.type.getCode(language);
                 }
@@ -445,7 +445,6 @@ export class KotlinCxxBridgedType {
             // any jni::HybridClass needs to be dereferenced to jobject with .get()
             case 'array-buffer':
             case 'function':
-            case 'hybrid-object':
             case 'hybrid-object-base':
             case 'map':
             case 'promise':
@@ -805,9 +804,9 @@ export class KotlinCxxBridgedType {
             case 'hybrid-object': {
                 switch (language) {
                     case 'c++':
-                        const hybrid = getTypeAs(this.type, HybridObjectType);
-                        const fullName = this.getFullJHybridObjectName(hybrid);
-                        return `${parameterName}->cthis()->shared_cast<${fullName}>()`;
+                        const hybridObject = getTypeAs(this.type, HybridObjectType);
+                        const { JHybridTSpec } = getHybridObjectName(hybridObject.hybridObjectName);
+                        return `${parameterName}->get${JHybridTSpec}()`;
                     default:
                         return parameterName;
                 }

package/lib/syntax/kotlin/KotlinHybridObject.js

@@ -20,6 +20,11 @@ export function createKotlinHybridObject(spec) {
         ...spec.properties.flatMap((p) => p.getRequiredImports('kotlin')),
         ...spec.methods.flatMap((m) => m.getRequiredImports('kotlin')),
         ...spec.baseTypes.flatMap((b) => new HybridObjectType(b).getRequiredImports('kotlin')),
+        {
+            name: 'com.margelo.nitro.core.HybridObject',
+            space: 'system',
+            language: 'kotlin',
+        },
     ];
     if (spec.isHybridView) {
         extraImports.push({
@@ -28,14 +33,8 @@ export function createKotlinHybridObject(spec) {
             language: 'kotlin',
         });
     }
-    else {
-        extraImports.push({
-            name: 'com.margelo.nitro.core.HybridObject',
-            space: 'system',
-            language: 'kotlin',
-        });
-    }
     let kotlinBase = spec.isHybridView ? 'HybridView' : 'HybridObject';
+    let cxxPartBase = 'HybridObject.CxxPart';
     if (spec.baseTypes.length > 0) {
         if (spec.baseTypes.length > 1) {
             throw new Error(`${name.T}: Inheriting from multiple HybridObject bases is not yet supported in Kotlin!`);
@@ -43,6 +42,7 @@ export function createKotlinHybridObject(spec) {
         const base = spec.baseTypes[0];
         const baseHybrid = new HybridObjectType(base);
         kotlinBase = baseHybrid.getCode('kotlin');
+        cxxPartBase = `${kotlinBase}.CxxPart`;
     }
     const imports = extraImports
         .map((i) => `import ${i.name}`)
@@ -71,30 +71,27 @@ ${imports.join('\n')}
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
 abstract class ${name.HybridTSpec}: ${kotlinBase}() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    super.updateNative(mHybridData)
-  }
+  // Properties
+  ${indent(properties, '  ')}
 
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-    super.updateNative(hybridData)
-  }
+  // Methods
+  ${indent(methods, '  ')}
 
   // Default implementation of \`HybridObject.toString()\`
   override fun toString(): String {
     return "[HybridObject ${name.T}]"
   }
 
-  // Properties
-  ${indent(properties, '  ')}
-
-  // Methods
-  ${indent(methods, '  ')}
-
-  private external fun initHybrid(): HybridData
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: ${name.HybridTSpec}): ${cxxPartBase}(javaPart) {
+    // C++ ${name.JHybridTSpec}::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
 
   companion object {
     protected const val TAG = "${name.HybridTSpec}"

package/lib/syntax/kotlin/KotlinHybridObjectRegistration.d.ts

@@ -11,6 +11,7 @@ interface Props {
 }
 interface JNIHybridObjectRegistration {
     cppCode: string;
+    cppDefinition: string;
     requiredImports: SourceImport[];
 }
 export declare function createJNIHybridObjectRegistration({ hybridObjectName, jniClassName, }: Props): JNIHybridObjectRegistration;

package/lib/syntax/kotlin/KotlinHybridObjectRegistration.js

@@ -12,13 +12,21 @@ export function createJNIHybridObjectRegistration({ hybridObjectName, jniClassNa
                 space: 'system',
             },
         ],
+        cppDefinition: `
+struct ${JHybridTSpec}Impl: public jni::JavaClass<${JHybridTSpec}Impl, ${JHybridTSpec}::JavaPart> {
+  static auto constexpr kJavaDescriptor = "L${jniNamespace};";
+  static std::shared_ptr<${JHybridTSpec}> create() {
+    static auto constructorFn = javaClassStatic()->getConstructor<${JHybridTSpec}Impl::javaobject()>();
+    jni::local_ref<${JHybridTSpec}::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->get${JHybridTSpec}();
+  }
+};
+    `.trim(),
         cppCode: `
 HybridObjectRegistry::registerHybridObjectConstructor(
   "${hybridObjectName}",
   []() -> std::shared_ptr<HybridObject> {
-    static DefaultConstructableObject<${JHybridTSpec}::javaobject> object("${jniNamespace}");
-    auto instance = object.create();
-    return instance->cthis()->shared();
+    return ${JHybridTSpec}Impl::create();
   }
 );
       `.trim(),

package/lib/syntax/kotlin/KotlinVariant.js

@@ -22,10 +22,6 @@ data class ${innerName}(@DoNotStrip val value: ${bridge.getTypeCode('kotlin')}):
       `.trim();
     });
     const packageName = NitroConfig.current.getAndroidPackage('java/kotlin');
-    const getterCases = variant.cases.map(([label]) => {
-        const innerName = capitalizeName(label);
-        return `is ${innerName} -> value as? T`;
-    });
     const isFunctions = variant.cases.map(([label]) => {
         const innerName = capitalizeName(label);
         return `
@@ -83,11 +79,6 @@ ${extraImports.join('\n')}
 sealed class ${kotlinName} {
   ${indent(innerClasses.join('\n'), '  ')}
 
-  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
-  inline fun <reified T> getAs(): T? = when (this) {
-    ${indent(getterCases.join('\n'), '    ')}
-  }
-
   ${indent(isFunctions.join('\n'), '  ')}
 
   ${indent(asFunctions.join('\n'), '  ')}

package/lib/views/kotlin/KotlinHybridViewManager.js

@@ -132,7 +132,7 @@ public:
 
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                              jni::alias_ref<${JHybridTSpec}::javaobject> view,
+                              jni::alias_ref<${JHybridTSpec}::JavaPart> view,
                               jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
 
 public:
@@ -155,7 +155,7 @@ public:
         const setter = p.getSetterName('other');
         return `
 if (props->${name}.isDirty) {
-  view->${setter}(props->${name}.value);
+  hybridView->${setter}(props->${name}.value);
   props->${name}.isDirty = false;
 }
     `.trim();
@@ -174,9 +174,9 @@ using namespace facebook;
 using ConcreteStateData = react::ConcreteState<${stateClassName}>;
 
 void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<${JHybridTSpec}::javaobject> javaView,
+                                           jni::alias_ref<${JHybridTSpec}::JavaPart> javaView,
                                            jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  ${JHybridTSpec}* view = javaView->cthis();
+  std::shared_ptr<${JHybridTSpec}> hybridView = javaView->get${JHybridTSpec}();
 
   // Get concrete StateWrapperImpl from passed StateWrapper interface object
   jobject rawStateWrapper = stateWrapperInterface.get();
@@ -202,8 +202,7 @@ void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class
     // hybridRef changed - call it with new this
     const auto& maybeFunc = props->hybridRef.value;
     if (maybeFunc.has_value()) {
-      std::shared_ptr<${JHybridTSpec}> shared = javaView->cthis()->shared_cast<${JHybridTSpec}>();
-      maybeFunc.value()(shared);
+      maybeFunc.value()(hybridView);
     }
     props->hybridRef.isDirty = false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.34.1",
+  "version": "0.35.0",
   "description": "The code-generator for react-native-nitro-modules.",
   "main": "lib/index",
   "types": "lib/index.d.ts",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "react-native-nitro-modules": "^0.34.1",
+    "react-native-nitro-modules": "^0.35.0",
     "ts-morph": "^27.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.0.5"

package/src/autolinking/android/createHybridObjectInitializer.ts

@@ -26,6 +26,7 @@ export function createHybridObjectIntializer(): SourceFile[] {
 
   const cppHybridObjectImports: SourceImport[] = []
   const cppRegistrations: string[] = []
+  const cppDefinitions: string[] = []
   for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
     const config = autolinkedHybridObjects[hybridObjectName]
 
@@ -40,11 +41,13 @@ export function createHybridObjectIntializer(): SourceFile[] {
     }
     if (config?.kotlin != null) {
       // Autolink a Kotlin HybridObject through JNI/C++!
-      const { cppCode, requiredImports } = createJNIHybridObjectRegistration({
-        hybridObjectName: hybridObjectName,
-        jniClassName: config.kotlin,
-      })
+      const { cppCode, cppDefinition, requiredImports } =
+        createJNIHybridObjectRegistration({
+          hybridObjectName: hybridObjectName,
+          jniClassName: config.kotlin,
+        })
       cppHybridObjectImports.push(...requiredImports)
+      cppDefinitions.push(cppDefinition)
       cppRegistrations.push(cppCode)
     }
   }
@@ -113,6 +116,8 @@ int initialize(JavaVM* vm) {
   });
 }
 
+${cppDefinitions.join('\n')}
+
 void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace ${cxxNamespace};

package/src/syntax/kotlin/FbjniHybridObject.ts

@@ -1,4 +1,4 @@
-import { createIndentation, indent } from '../../utils.js'
+import { indent } from '../../utils.js'
 import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
 import { includeHeader } from '../c++/includeNitroHeader.js'
 import { getAllTypes } from '../getAllTypes.js'
@@ -35,10 +35,16 @@ export function createFbjniHybridObject(spec: HybridObjectSpec): SourceFile[] {
     'c++/jni',
     name.HybridTSpec
   )
+  const cxxPartJniClassDescriptor = `${jniClassDescriptor}$CxxPart`
   const cxxNamespace = spec.config.getCxxNamespace('c++')
-  const spaces = createIndentation(name.JHybridTSpec.length)
 
-  let cppBase = 'JHybridObject'
+  let cppBaseClass = 'JHybridObject'
+  let javaPartBaseClass = 'JHybridObject::JavaPart'
+  let cxxPartBaseClass = 'JHybridObject::CxxPart'
+  const constructorCalls = [
+    `HybridObject(${name.HybridTSpec}::TAG)`,
+    `JHybridObject(javaPart)`,
+  ]
   if (spec.baseTypes.length > 0) {
     if (spec.baseTypes.length > 1) {
       throw new Error(
@@ -46,11 +52,15 @@ export function createFbjniHybridObject(spec: HybridObjectSpec): SourceFile[] {
       )
     }
     const base = spec.baseTypes[0]!
-    cppBase = getHybridObjectName(base.name).JHybridTSpec
+    let baseTypename = getHybridObjectName(base.name).JHybridTSpec
     if (base.config.isExternalConfig) {
       // It's an external type we inherit from - we have to prefix the namespace
-      cppBase = base.config.getCxxNamespace('c++', cppBase)
+      baseTypename = base.config.getCxxNamespace('c++', baseTypename)
     }
+    cppBaseClass = baseTypename
+    javaPartBaseClass = `${baseTypename}::JavaPart`
+    cxxPartBaseClass = `${baseTypename}::CxxPart`
+    constructorCalls.push(`${baseTypename}(javaPart)`)
   }
   const cppImports: SourceImport[] = []
   for (const base of spec.baseTypes) {
@@ -90,34 +100,32 @@ namespace ${cxxNamespace} {
 
   using namespace facebook;
 
-  class ${name.JHybridTSpec}: public jni::HybridClass<${name.JHybridTSpec}, ${cppBase}>,
-${spaces}          public virtual ${name.HybridTSpec} {
+  class ${name.JHybridTSpec}: public virtual ${name.HybridTSpec}, public virtual ${cppBaseClass} {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
-    static void registerNatives();
-
-  protected:
-    // C++ constructor (called from Java via \`initHybrid()\`)
-    explicit ${name.JHybridTSpec}(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(${name.HybridTSpec}::TAG),
-      HybridBase(jThis),
-      _javaPart(jni::make_global(jThis)) {}
+    struct JavaPart: public jni::JavaClass<JavaPart, ${javaPartBaseClass}> {
+      static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+      std::shared_ptr<${name.JHybridTSpec}> get${name.JHybridTSpec}();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, ${cxxPartBaseClass}> {
+      static auto constexpr kJavaDescriptor = "L${cxxPartJniClassDescriptor};";
+      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 ${name.JHybridTSpec}(const jni::local_ref<${name.JHybridTSpec}::JavaPart>& javaPart):
+      ${indent(constructorCalls.join(',\n'), '      ')},
+      _javaPart(jni::make_global(javaPart)) {}
     ~${name.JHybridTSpec}() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
 
   public:
-    size_t getExternalMemorySize() noexcept override;
-    bool equals(const std::shared_ptr<HybridObject>& other) override;
-    void dispose() noexcept override;
-    std::string toString() override;
-
-  public:
-    inline const jni::global_ref<${name.JHybridTSpec}::javaobject>& getJavaPart() const noexcept {
+    inline const jni::global_ref<${name.JHybridTSpec}::JavaPart>& getJavaPart() const noexcept {
       return _javaPart;
     }
 
@@ -130,9 +138,7 @@ ${spaces}          public virtual ${name.HybridTSpec} {
     ${indent(methodsDecl, '    ')}
 
   private:
-    friend HybridBase;
-    using HybridBase::HybridBase;
-    jni::global_ref<${name.JHybridTSpec}::javaobject> _javaPart;
+    jni::global_ref<${name.JHybridTSpec}::JavaPart> _javaPart;
   };
 
 } // namespace ${cxxNamespace}
@@ -141,7 +147,7 @@ ${spaces}          public virtual ${name.HybridTSpec} {
   // Make sure we register all native JNI methods on app startup
   addJNINativeRegistration({
     namespace: cxxNamespace,
-    className: `${name.JHybridTSpec}`,
+    className: `${name.JHybridTSpec}::CxxPart`,
     import: {
       name: `${name.JHybridTSpec}.hpp`,
       space: 'user',
@@ -180,37 +186,31 @@ ${cppIncludes.join('\n')}
 
 namespace ${cxxNamespace} {
 
-  jni::local_ref<${name.JHybridTSpec}::jhybriddata> ${name.JHybridTSpec}::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
-  }
-
-  void ${name.JHybridTSpec}::registerNatives() {
-    registerHybrid({
-      makeNativeMethod("initHybrid", ${name.JHybridTSpec}::initHybrid),
-    });
+  std::shared_ptr<${name.JHybridTSpec}> ${name.JHybridTSpec}::JavaPart::get${name.JHybridTSpec}() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<${name.JHybridTSpec}>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to ${name.JHybridTSpec}!");
+    }
+    return castHybridObject;
   }
 
-  size_t ${name.JHybridTSpec}::getExternalMemorySize() noexcept {
-    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
-    return method(_javaPart);
+  jni::local_ref<${name.JHybridTSpec}::CxxPart::jhybriddata> ${name.JHybridTSpec}::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
   }
 
-  bool ${name.JHybridTSpec}::equals(const std::shared_ptr<HybridObject>& other) {
-    if (auto otherCast = std::dynamic_pointer_cast<${name.JHybridTSpec}>(other)) {
-      return _javaPart == otherCast->_javaPart;
+  std::shared_ptr<JHybridObject> ${name.JHybridTSpec}::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<${name.JHybridTSpec}::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to ${name.JHybridTSpec}::JavaPart!");
     }
-    return false;
+    return std::make_shared<${name.JHybridTSpec}>(castJavaPart);
   }
 
-  void ${name.JHybridTSpec}::dispose() noexcept {
-    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
-    method(_javaPart);
-  }
-
-  std::string ${name.JHybridTSpec}::toString() {
-    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
-    auto javaString = method(_javaPart);
-    return javaString->toStdString();
+  void ${name.JHybridTSpec}::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", ${name.JHybridTSpec}::CxxPart::initHybrid),
+    });
   }
 
   // Properties
@@ -275,14 +275,14 @@ function getFbjniMethodForwardImplementation(
   if (returnJNI.hasType) {
     // return something - we need to parse it
     body = `
-static const auto method = javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
+static const auto method = _javaPart->javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
 auto __result = method(${paramsForward.join(', ')});
 return ${returnJNI.parse('__result', 'kotlin', 'c++', 'c++')};
     `
   } else {
     // void method. no return
     body = `
-static const auto method = javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
+static const auto method = _javaPart->javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
 method(${paramsForward.join(', ')});
    `
   }

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -363,7 +363,7 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
           case 'c++':
             const hybridObjectType = getTypeAs(this.type, HybridObjectType)
             const fullName = this.getFullJHybridObjectName(hybridObjectType)
-            return `${fullName}::javaobject`
+            return `${fullName}::JavaPart`
           default:
             return this.type.getCode(language)
         }
@@ -472,7 +472,6 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
       // any jni::HybridClass needs to be dereferenced to jobject with .get()
       case 'array-buffer':
       case 'function':
-      case 'hybrid-object':
       case 'hybrid-object-base':
       case 'map':
       case 'promise':
@@ -849,9 +848,11 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
       case 'hybrid-object': {
         switch (language) {
           case 'c++':
-            const hybrid = getTypeAs(this.type, HybridObjectType)
-            const fullName = this.getFullJHybridObjectName(hybrid)
-            return `${parameterName}->cthis()->shared_cast<${fullName}>()`
+            const hybridObject = getTypeAs(this.type, HybridObjectType)
+            const { JHybridTSpec } = getHybridObjectName(
+              hybridObject.hybridObjectName
+            )
+            return `${parameterName}->get${JHybridTSpec}()`
           default:
             return parameterName
         }

package/src/syntax/kotlin/KotlinHybridObject.ts

@@ -26,6 +26,11 @@ export function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[] {
     ...spec.baseTypes.flatMap((b) =>
       new HybridObjectType(b).getRequiredImports('kotlin')
     ),
+    {
+      name: 'com.margelo.nitro.core.HybridObject',
+      space: 'system',
+      language: 'kotlin',
+    },
   ]
   if (spec.isHybridView) {
     extraImports.push({
@@ -33,15 +38,10 @@ export function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[] {
       space: 'system',
       language: 'kotlin',
     })
-  } else {
-    extraImports.push({
-      name: 'com.margelo.nitro.core.HybridObject',
-      space: 'system',
-      language: 'kotlin',
-    })
   }
 
   let kotlinBase = spec.isHybridView ? 'HybridView' : 'HybridObject'
+  let cxxPartBase = 'HybridObject.CxxPart'
   if (spec.baseTypes.length > 0) {
     if (spec.baseTypes.length > 1) {
       throw new Error(
@@ -51,6 +51,7 @@ export function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[] {
     const base = spec.baseTypes[0]!
     const baseHybrid = new HybridObjectType(base)
     kotlinBase = baseHybrid.getCode('kotlin')
+    cxxPartBase = `${kotlinBase}.CxxPart`
   }
 
   const imports = extraImports
@@ -82,30 +83,27 @@ ${imports.join('\n')}
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
 abstract class ${name.HybridTSpec}: ${kotlinBase}() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    super.updateNative(mHybridData)
-  }
+  // Properties
+  ${indent(properties, '  ')}
 
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-    super.updateNative(hybridData)
-  }
+  // Methods
+  ${indent(methods, '  ')}
 
   // Default implementation of \`HybridObject.toString()\`
   override fun toString(): String {
     return "[HybridObject ${name.T}]"
   }
 
-  // Properties
-  ${indent(properties, '  ')}
-
-  // Methods
-  ${indent(methods, '  ')}
-
-  private external fun initHybrid(): HybridData
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: ${name.HybridTSpec}): ${cxxPartBase}(javaPart) {
+    // C++ ${name.JHybridTSpec}::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
 
   companion object {
     protected const val TAG = "${name.HybridTSpec}"

package/src/syntax/kotlin/KotlinHybridObjectRegistration.ts

@@ -15,6 +15,7 @@ interface Props {
 
 interface JNIHybridObjectRegistration {
   cppCode: string
+  cppDefinition: string
   requiredImports: SourceImport[]
 }
 
@@ -37,13 +38,21 @@ export function createJNIHybridObjectRegistration({
         space: 'system',
       },
     ],
+    cppDefinition: `
+struct ${JHybridTSpec}Impl: public jni::JavaClass<${JHybridTSpec}Impl, ${JHybridTSpec}::JavaPart> {
+  static auto constexpr kJavaDescriptor = "L${jniNamespace};";
+  static std::shared_ptr<${JHybridTSpec}> create() {
+    static auto constructorFn = javaClassStatic()->getConstructor<${JHybridTSpec}Impl::javaobject()>();
+    jni::local_ref<${JHybridTSpec}::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->get${JHybridTSpec}();
+  }
+};
+    `.trim(),
     cppCode: `
 HybridObjectRegistry::registerHybridObjectConstructor(
   "${hybridObjectName}",
   []() -> std::shared_ptr<HybridObject> {
-    static DefaultConstructableObject<${JHybridTSpec}::javaobject> object("${jniNamespace}");
-    auto instance = object.create();
-    return instance->cthis()->shared();
+    return ${JHybridTSpec}Impl::create();
   }
 );
       `.trim(),

package/src/syntax/kotlin/KotlinVariant.ts

@@ -30,10 +30,6 @@ data class ${innerName}(@DoNotStrip val value: ${bridge.getTypeCode('kotlin')}):
   })
 
   const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
-  const getterCases = variant.cases.map(([label]) => {
-    const innerName = capitalizeName(label)
-    return `is ${innerName} -> value as? T`
-  })
   const isFunctions = variant.cases.map(([label]) => {
     const innerName = capitalizeName(label)
     return `
@@ -94,11 +90,6 @@ ${extraImports.join('\n')}
 sealed class ${kotlinName} {
   ${indent(innerClasses.join('\n'), '  ')}
 
-  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
-  inline fun <reified T> getAs(): T? = when (this) {
-    ${indent(getterCases.join('\n'), '    ')}
-  }
-
   ${indent(isFunctions.join('\n'), '  ')}
 
   ${indent(asFunctions.join('\n'), '  ')}

package/src/views/kotlin/KotlinHybridViewManager.ts

@@ -158,7 +158,7 @@ public:
 
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                              jni::alias_ref<${JHybridTSpec}::javaobject> view,
+                              jni::alias_ref<${JHybridTSpec}::JavaPart> view,
                               jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
 
 public:
@@ -182,7 +182,7 @@ public:
     const setter = p.getSetterName('other')
     return `
 if (props->${name}.isDirty) {
-  view->${setter}(props->${name}.value);
+  hybridView->${setter}(props->${name}.value);
   props->${name}.isDirty = false;
 }
     `.trim()
@@ -201,9 +201,9 @@ using namespace facebook;
 using ConcreteStateData = react::ConcreteState<${stateClassName}>;
 
 void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<${JHybridTSpec}::javaobject> javaView,
+                                           jni::alias_ref<${JHybridTSpec}::JavaPart> javaView,
                                            jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  ${JHybridTSpec}* view = javaView->cthis();
+  std::shared_ptr<${JHybridTSpec}> hybridView = javaView->get${JHybridTSpec}();
 
   // Get concrete StateWrapperImpl from passed StateWrapper interface object
   jobject rawStateWrapper = stateWrapperInterface.get();
@@ -229,8 +229,7 @@ void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class
     // hybridRef changed - call it with new this
     const auto& maybeFunc = props->hybridRef.value;
     if (maybeFunc.has_value()) {
-      std::shared_ptr<${JHybridTSpec}> shared = javaView->cthis()->shared_cast<${JHybridTSpec}>();
-      maybeFunc.value()(shared);
+      maybeFunc.value()(hybridView);
     }
     props->hybridRef.isDirty = false;
   }