nitrogen 0.35.0 → 0.35.1-beta.0

package/lib/autolinking/android/createHybridObjectInitializer.js

@@ -19,25 +19,34 @@ export function createHybridObjectIntializer() {
     const cppRegistrations = [];
     const cppDefinitions = [];
     for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
-        const config = autolinkedHybridObjects[hybridObjectName];
-        if (config?.cpp != null) {
-            // Autolink a C++ HybridObject!
-            const { cppCode, requiredImports } = createCppHybridObjectRegistration({
-                hybridObjectName: hybridObjectName,
-                cppClassName: config.cpp,
-            });
-            cppHybridObjectImports.push(...requiredImports);
-            cppRegistrations.push(cppCode);
+        const implementation = NitroConfig.current.getAndroidAutolinkedImplementation(hybridObjectName);
+        if (implementation == null) {
+            continue;
         }
-        if (config?.kotlin != null) {
-            // Autolink a Kotlin HybridObject through JNI/C++!
-            const { cppCode, cppDefinition, requiredImports } = createJNIHybridObjectRegistration({
-                hybridObjectName: hybridObjectName,
-                jniClassName: config.kotlin,
-            });
-            cppHybridObjectImports.push(...requiredImports);
-            cppDefinitions.push(cppDefinition);
-            cppRegistrations.push(cppCode);
+        switch (implementation.language) {
+            case 'cpp': {
+                // Autolink a C++ HybridObject!
+                const { cppCode, requiredImports } = createCppHybridObjectRegistration({
+                    hybridObjectName: hybridObjectName,
+                    cppClassName: implementation.implementationClassName,
+                });
+                cppHybridObjectImports.push(...requiredImports);
+                cppRegistrations.push(cppCode);
+                break;
+            }
+            case 'kotlin': {
+                // Autolink a Kotlin HybridObject through JNI/C++!
+                const { cppCode, cppDefinition, requiredImports } = createJNIHybridObjectRegistration({
+                    hybridObjectName: hybridObjectName,
+                    jniClassName: implementation.implementationClassName,
+                });
+                cppHybridObjectImports.push(...requiredImports);
+                cppDefinitions.push(cppDefinition);
+                cppRegistrations.push(cppCode);
+                break;
+            }
+            default:
+                throw new Error(`The HybridObject "${hybridObjectName}" cannot be autolinked on Android - Language "${implementation.language}" is not supported on Android!`);
         }
     }
     const buildingWithDefinition = getBuildingWithGeneratedCmakeDefinition();

package/lib/autolinking/ios/createHybridObjectInitializer.js

@@ -15,26 +15,35 @@ export function createHybridObjectIntializer() {
     const cppImports = [];
     let containsSwiftObjects = false;
     for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
-        const config = autolinkedHybridObjects[hybridObjectName];
-        if (config?.cpp != null) {
-            // Autolink a C++ HybridObject!
-            const { cppCode, requiredImports } = createCppHybridObjectRegistration({
-                hybridObjectName: hybridObjectName,
-                cppClassName: config.cpp,
-            });
-            cppImports.push(...requiredImports);
-            cppRegistrations.push(cppCode);
+        const implementation = NitroConfig.current.getIosAutolinkedImplementation(hybridObjectName);
+        if (implementation == null) {
+            continue;
         }
-        if (config?.swift != null) {
-            // Autolink a Swift HybridObject!
-            containsSwiftObjects = true;
-            const { cppCode, requiredImports, swiftRegistrationMethods } = createSwiftHybridObjectRegistration({
-                hybridObjectName: hybridObjectName,
-                swiftClassName: config.swift,
-            });
-            cppImports.push(...requiredImports);
-            cppRegistrations.push(cppCode);
-            swiftRegistrations.push(swiftRegistrationMethods);
+        switch (implementation.language) {
+            case 'cpp': {
+                // Autolink a C++ HybridObject!
+                const { cppCode, requiredImports } = createCppHybridObjectRegistration({
+                    hybridObjectName: hybridObjectName,
+                    cppClassName: implementation.implementationClassName,
+                });
+                cppImports.push(...requiredImports);
+                cppRegistrations.push(cppCode);
+                break;
+            }
+            case 'swift': {
+                // Autolink a Swift HybridObject!
+                containsSwiftObjects = true;
+                const { cppCode, requiredImports, swiftRegistrationMethods } = createSwiftHybridObjectRegistration({
+                    hybridObjectName: hybridObjectName,
+                    swiftClassName: implementation.implementationClassName,
+                });
+                cppImports.push(...requiredImports);
+                cppRegistrations.push(cppCode);
+                swiftRegistrations.push(swiftRegistrationMethods);
+                break;
+            }
+            default:
+                throw new Error(`The HybridObject "${hybridObjectName}" cannot be autolinked on iOS - Language "${implementation.language}" is not supported on iOS!`);
         }
     }
     if (cppRegistrations.length === 0) {

package/lib/config/NitroConfig.d.ts

@@ -1,4 +1,4 @@
-import type { NitroUserConfig } from './NitroUserConfig.js';
+import type { AutolinkingAndroidImplementation, AutolinkingIOSImplementation, AutolinkingPlatformImplementation, NitroUserConfig } from './NitroUserConfig.js';
 /**
  * Represents the properly parsed `nitro.json` config of the current executing directory.
  */
@@ -40,6 +40,9 @@ export declare class NitroConfig {
      * Those will be generated and default-constructed.
      */
     getAutolinkedHybridObjects(): NitroUserConfig['autolinking'];
+    getPlatformAutolinkedImplementation(hybridObjectName: string, platform: string): AutolinkingPlatformImplementation | undefined;
+    getIosAutolinkedImplementation(hybridObjectName: string): AutolinkingIOSImplementation | undefined;
+    getAndroidAutolinkedImplementation(hybridObjectName: string): AutolinkingAndroidImplementation | undefined;
     /**
      * Get the paths that will be ignored when loading the TypeScript project.
      * In most cases, this just contains `node_modules/`.

package/lib/config/NitroConfig.js

@@ -88,6 +88,38 @@ export class NitroConfig {
     getAutolinkedHybridObjects() {
         return this.config.autolinking;
     }
+    getPlatformAutolinkedImplementation(hybridObjectName, platform) {
+        const objectConfig = this.config.autolinking[hybridObjectName];
+        if (objectConfig == null) {
+            return undefined;
+        }
+        // "all" applies to every platform and should automatically include
+        // future platforms without having to expand explicit key lists here.
+        if (objectConfig.all != null) {
+            return objectConfig.all;
+        }
+        return objectConfig[platform];
+    }
+    getIosAutolinkedImplementation(hybridObjectName) {
+        const objectConfig = this.config.autolinking[hybridObjectName];
+        if (objectConfig == null) {
+            return undefined;
+        }
+        if (objectConfig.all != null) {
+            return objectConfig.all;
+        }
+        return objectConfig.ios;
+    }
+    getAndroidAutolinkedImplementation(hybridObjectName) {
+        const objectConfig = this.config.autolinking[hybridObjectName];
+        if (objectConfig == null) {
+            return undefined;
+        }
+        if (objectConfig.all != null) {
+            return objectConfig.all;
+        }
+        return objectConfig.android;
+    }
     /**
      * Get the paths that will be ignored when loading the TypeScript project.
      * In most cases, this just contains `node_modules/`.

package/lib/config/NitroUserConfig.d.ts

@@ -1,4 +1,87 @@
 import { z } from 'zod';
+declare const autolinkingAllImplementationSchema: z.ZodObject<{
+    language: z.ZodLiteral<"cpp">;
+    implementationClassName: z.ZodString;
+}, z.core.$strip>;
+declare const autolinkingIOSImplementationSchema: z.ZodObject<{
+    language: z.ZodEnum<{
+        cpp: "cpp";
+        swift: "swift";
+    }>;
+    implementationClassName: z.ZodString;
+}, z.core.$strip>;
+declare const autolinkingAndroidImplementationSchema: z.ZodObject<{
+    language: z.ZodEnum<{
+        cpp: "cpp";
+        kotlin: "kotlin";
+    }>;
+    implementationClassName: z.ZodString;
+}, z.core.$strip>;
+declare const autolinkingPlatformImplementationSchema: z.ZodObject<{
+    language: z.ZodEnum<{
+        cpp: "cpp";
+        swift: "swift";
+        kotlin: "kotlin";
+    }>;
+    implementationClassName: z.ZodString;
+}, z.core.$strip>;
+declare const autolinkingHybridObjectSchema: z.ZodUnion<readonly [z.ZodObject<{
+    all: z.ZodOptional<z.ZodObject<{
+        language: z.ZodLiteral<"cpp">;
+        implementationClassName: z.ZodString;
+    }, z.core.$strip>>;
+    ios: z.ZodOptional<z.ZodObject<{
+        language: z.ZodEnum<{
+            cpp: "cpp";
+            swift: "swift";
+        }>;
+        implementationClassName: z.ZodString;
+    }, z.core.$strip>>;
+    android: z.ZodOptional<z.ZodObject<{
+        language: z.ZodEnum<{
+            cpp: "cpp";
+            kotlin: "kotlin";
+        }>;
+        implementationClassName: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$catchall<z.ZodObject<{
+    language: z.ZodEnum<{
+        cpp: "cpp";
+        swift: "swift";
+        kotlin: "kotlin";
+    }>;
+    implementationClassName: z.ZodString;
+}, z.core.$strip>>>, z.ZodPipe<z.ZodObject<{
+    cpp: z.ZodOptional<z.ZodString>;
+    swift: z.ZodOptional<z.ZodString>;
+    kotlin: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    [x: string]: {
+        language: "cpp" | "swift" | "kotlin";
+        implementationClassName: string;
+    };
+    all?: {
+        language: "cpp";
+        implementationClassName: string;
+    } | undefined;
+    ios?: {
+        language: "cpp" | "swift";
+        implementationClassName: string;
+    } | undefined;
+    android?: {
+        language: "cpp" | "kotlin";
+        implementationClassName: string;
+    } | undefined;
+}, {
+    cpp?: string | undefined;
+    swift?: string | undefined;
+    kotlin?: string | undefined;
+}>>]>;
+export type AutolinkingAllImplementation = z.infer<typeof autolinkingAllImplementationSchema>;
+export type AutolinkingIOSImplementation = z.infer<typeof autolinkingIOSImplementationSchema>;
+export type AutolinkingAndroidImplementation = z.infer<typeof autolinkingAndroidImplementationSchema>;
+export type AutolinkingPlatformImplementation = z.infer<typeof autolinkingPlatformImplementationSchema>;
+export type AutolinkingHybridObject = z.infer<typeof autolinkingHybridObjectSchema>;
 export declare const NitroUserConfigSchema: z.ZodObject<{
     cxxNamespace: z.ZodArray<z.ZodString>;
     ios: z.ZodObject<{
@@ -8,11 +91,58 @@ export declare const NitroUserConfigSchema: z.ZodObject<{
         androidNamespace: z.ZodArray<z.ZodString>;
         androidCxxLibName: z.ZodString;
     }, z.core.$strip>;
-    autolinking: z.ZodRecord<z.ZodString, z.ZodObject<{
+    autolinking: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        all: z.ZodOptional<z.ZodObject<{
+            language: z.ZodLiteral<"cpp">;
+            implementationClassName: z.ZodString;
+        }, z.core.$strip>>;
+        ios: z.ZodOptional<z.ZodObject<{
+            language: z.ZodEnum<{
+                cpp: "cpp";
+                swift: "swift";
+            }>;
+            implementationClassName: z.ZodString;
+        }, z.core.$strip>>;
+        android: z.ZodOptional<z.ZodObject<{
+            language: z.ZodEnum<{
+                cpp: "cpp";
+                kotlin: "kotlin";
+            }>;
+            implementationClassName: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$catchall<z.ZodObject<{
+        language: z.ZodEnum<{
+            cpp: "cpp";
+            swift: "swift";
+            kotlin: "kotlin";
+        }>;
+        implementationClassName: z.ZodString;
+    }, z.core.$strip>>>, z.ZodPipe<z.ZodObject<{
         cpp: z.ZodOptional<z.ZodString>;
         swift: z.ZodOptional<z.ZodString>;
         kotlin: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        [x: string]: {
+            language: "cpp" | "swift" | "kotlin";
+            implementationClassName: string;
+        };
+        all?: {
+            language: "cpp";
+            implementationClassName: string;
+        } | undefined;
+        ios?: {
+            language: "cpp" | "swift";
+            implementationClassName: string;
+        } | undefined;
+        android?: {
+            language: "cpp" | "kotlin";
+            implementationClassName: string;
+        } | undefined;
+    }, {
+        cpp?: string | undefined;
+        swift?: string | undefined;
+        kotlin?: string | undefined;
+    }>>]>>;
     ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     gitAttributesGeneratedFlag: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strip>;
@@ -20,3 +150,4 @@ export declare const NitroUserConfigSchema: z.ZodObject<{
  * Represents the structure of a `nitro.json` config file.
  */
 export type NitroUserConfig = z.infer<typeof NitroUserConfigSchema>;
+export {};

package/lib/config/NitroUserConfig.js

@@ -5,6 +5,98 @@ const isNotReservedKeyword = (val) => !['core', 'nitro', 'NitroModules'].include
 const isReservedKeywordError = {
     message: `This value is reserved and cannot be used!`,
 };
+const autolinkingLanguageSchema = z.enum(['cpp', 'swift', 'kotlin']);
+const autolinkingAllImplementationSchema = z.object({
+    language: z.literal('cpp'),
+    implementationClassName: z.string(),
+});
+const autolinkingIOSImplementationSchema = z.object({
+    language: z.enum(['cpp', 'swift']),
+    implementationClassName: z.string(),
+});
+const autolinkingAndroidImplementationSchema = z.object({
+    language: z.enum(['cpp', 'kotlin']),
+    implementationClassName: z.string(),
+});
+const autolinkingPlatformImplementationSchema = z.object({
+    language: autolinkingLanguageSchema,
+    implementationClassName: z.string(),
+});
+const autolinkingModernHybridObjectSchema = z
+    .object({
+    all: autolinkingAllImplementationSchema.optional(),
+    ios: autolinkingIOSImplementationSchema.optional(),
+    android: autolinkingAndroidImplementationSchema.optional(),
+})
+    .catchall(autolinkingPlatformImplementationSchema)
+    .superRefine((value, ctx) => {
+    const hasAll = value.all != null;
+    const platformCount = Object.keys(value).filter((key) => key !== 'all').length;
+    if (hasAll && platformCount > 0) {
+        ctx.addIssue({
+            code: 'custom',
+            message: '"all" cannot be combined with platform-specific entries.',
+        });
+    }
+    if (!hasAll && platformCount === 0) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Each autolinking entry must declare either "all" or at least one platform.',
+        });
+    }
+});
+const autolinkingLegacyHybridObjectSchema = z
+    .object({
+    cpp: z.string().optional(),
+    swift: z.string().optional(),
+    kotlin: z.string().optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const hasCpp = value.cpp != null;
+    const hasSwift = value.swift != null;
+    const hasKotlin = value.kotlin != null;
+    if (!hasCpp && !hasSwift && !hasKotlin) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Each autolinking entry must declare at least one implementation.',
+        });
+    }
+    if (hasCpp && (hasSwift || hasKotlin)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Legacy autolinking entries cannot mix "cpp" with "swift"/"kotlin".',
+        });
+    }
+});
+function normalizeLegacyAutolinkingHybridObject(value) {
+    if (value.cpp != null) {
+        return {
+            all: {
+                language: 'cpp',
+                implementationClassName: value.cpp,
+            },
+        };
+    }
+    const normalized = {};
+    if (value.swift != null) {
+        normalized.ios = {
+            language: 'swift',
+            implementationClassName: value.swift,
+        };
+    }
+    if (value.kotlin != null) {
+        normalized.android = {
+            language: 'kotlin',
+            implementationClassName: value.kotlin,
+        };
+    }
+    return normalized;
+}
+const autolinkingHybridObjectSchema = z.union([
+    autolinkingModernHybridObjectSchema,
+    autolinkingLegacyHybridObjectSchema.transform(normalizeLegacyAutolinkingHybridObject),
+]);
 export const NitroUserConfigSchema = z.object({
     /**
      * Represents the C++ namespace of the module that will be generated.
@@ -65,14 +157,10 @@ export const NitroUserConfigSchema = z.object({
      * Configures the code that gets generated for autolinking (registering)
      * Hybrid Object constructors.
      *
-     * Each class listed here needs to have a default constructor/initializer that takes
-     * zero arguments.
+     * Each class listed here needs to have a default constructor/initializer
+     * that takes zero arguments.
      */
-    autolinking: z.record(z.string(), z.object({
-        cpp: z.string().optional(),
-        swift: z.string().optional(),
-        kotlin: z.string().optional(),
-    })),
+    autolinking: z.record(z.string(), autolinkingHybridObjectSchema),
     /**
      * A list of paths relative to the project directory that should be ignored by nitrogen.
      * Nitrogen will not look for `.nitro.ts` files in these directories.

package/lib/config/getConfig.js

@@ -2,6 +2,34 @@ import { ZodError } from 'zod';
 import fs from 'fs';
 import { NitroUserConfigSchema, } from './NitroUserConfig.js';
 import chalk from 'chalk';
+function isObject(value) {
+    return typeof value === 'object' && value != null && !Array.isArray(value);
+}
+function getLegacyAutolinkingEntries(config) {
+    if (!isObject(config))
+        return [];
+    const autolinking = config.autolinking;
+    if (!isObject(autolinking))
+        return [];
+    const entries = [];
+    for (const [hybridObjectName, entry] of Object.entries(autolinking)) {
+        if (!isObject(entry))
+            continue;
+        const hasLegacySyntax = 'cpp' in entry || 'swift' in entry || 'kotlin' in entry;
+        if (hasLegacySyntax) {
+            entries.push(hybridObjectName);
+        }
+    }
+    return entries;
+}
+// TODO: Remove this once users have migrated to new `nitro.json`
+function logLegacyAutolinkingDeprecation(config) {
+    const legacyEntries = getLegacyAutolinkingEntries(config);
+    if (legacyEntries.length === 0)
+        return;
+    console.warn(chalk.yellow(`Warning: nitro.json uses deprecated autolinking syntax ("cpp"/"swift"/"kotlin") for [${legacyEntries.join(', ')}]. ` +
+        `Use "all"/"ios"/"android" entries with { language, implementationClassName } instead.`));
+}
 function readFile(configPath) {
     try {
         return fs.readFileSync(configPath, 'utf8');
@@ -52,6 +80,7 @@ function parseConfig(json) {
         });
     }
     try {
+        logLegacyAutolinkingDeprecation(object);
         return NitroUserConfigSchema.parse(object);
     }
     catch (error) {

package/lib/syntax/kotlin/FbjniHybridObject.js

@@ -84,11 +84,11 @@ namespace ${cxxNamespace} {
   class ${name.JHybridTSpec}: public virtual ${name.HybridTSpec}, public virtual ${cppBaseClass} {
   public:
     struct JavaPart: public jni::JavaClass<JavaPart, ${javaPartBaseClass}> {
-      static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+      static constexpr auto 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 constexpr auto kJavaDescriptor = "L${cxxPartJniClassDescriptor};";
       static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
       static void registerNatives();
       using HybridBase::HybridBase;

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

@@ -8,8 +8,8 @@ export declare class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'
     get hasType(): boolean;
     get canBePassedByReference(): boolean;
     get needsSpecialHandling(): boolean;
-    getRequiredImports(language: Language): SourceImport[];
-    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language, visited?: Set<Type>): SourceImport[];
+    getExtraFiles(visited?: Set<Type>): SourceFile[];
     asJniReferenceType(referenceType?: 'alias' | 'local' | 'global'): string;
     getTypeCode(language: 'kotlin' | 'c++', isBoxed?: boolean): string;
     parse(parameterName: string, from: 'c++' | 'kotlin', to: 'kotlin' | 'c++', inLanguage: 'kotlin' | 'c++'): string;

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -56,7 +56,10 @@ export class KotlinCxxBridgedType {
         // no special handling needed
         return false;
     }
-    getRequiredImports(language) {
+    getRequiredImports(language, visited = new Set()) {
+        if (visited.has(this.type))
+            return [];
+        visited.add(this.type);
         const imports = this.type.getRequiredImports(language);
         if (language === 'c++') {
             // All C++ imports we need for the JNI bridge
@@ -168,17 +171,16 @@ export class KotlinCxxBridgedType {
         }
         // Recursively look into referenced types (e.g. the `T` of a `optional<T>`, or `T` of a `T[]`)
         const referencedTypes = getReferencedTypes(this.type);
-        referencedTypes.forEach((t) => {
-            if (t === this.type) {
-                // break a recursion - we already know this type
-                return;
-            }
+        for (const t of referencedTypes) {
             const bridged = new KotlinCxxBridgedType(t);
-            imports.push(...bridged.getRequiredImports(language));
-        });
+            imports.push(...bridged.getRequiredImports(language, visited));
+        }
         return imports;
     }
-    getExtraFiles() {
+    getExtraFiles(visited = new Set()) {
+        if (visited.has(this.type))
+            return [];
+        visited.add(this.type);
         const files = [];
         switch (this.type.kind) {
             case 'enum':
@@ -204,14 +206,10 @@ export class KotlinCxxBridgedType {
         }
         // Recursively look into referenced types (e.g. the `T` of a `optional<T>`, or `T` of a `T[]`)
         const referencedTypes = getReferencedTypes(this.type);
-        referencedTypes.forEach((t) => {
-            if (t === this.type) {
-                // break a recursion - we already know this type
-                return;
-            }
+        for (const t of referencedTypes) {
             const bridged = new KotlinCxxBridgedType(t);
-            files.push(...bridged.getExtraFiles());
-        });
+            files.push(...bridged.getExtraFiles(visited));
+        }
         return files;
     }
     asJniReferenceType(referenceType = 'alias') {

package/lib/syntax/kotlin/KotlinEnum.js

@@ -44,7 +44,7 @@ namespace ${cxxNamespace} {
    */
   struct J${enumType.enumName} final: public jni::JavaClass<J${enumType.enumName}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
 
   public:
     /**

package/lib/syntax/kotlin/KotlinFunction.js

@@ -180,7 +180,7 @@ namespace ${cxxNamespace} {
    */
   struct J${name}: public jni::JavaClass<J${name}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniInterfaceDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniInterfaceDescriptor};";
 
   public:
     /**
@@ -215,7 +215,7 @@ namespace ${cxxNamespace} {
     }
 
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
     static void registerNatives() {
       registerHybrid({makeNativeMethod("invoke_cxx", J${name}_cxx::invoke_cxx)});
     }

package/lib/syntax/kotlin/KotlinHybridObjectRegistration.js

@@ -14,9 +14,9 @@ export function createJNIHybridObjectRegistration({ hybridObjectName, jniClassNa
         ],
         cppDefinition: `
 struct ${JHybridTSpec}Impl: public jni::JavaClass<${JHybridTSpec}Impl, ${JHybridTSpec}::JavaPart> {
-  static auto constexpr kJavaDescriptor = "L${jniNamespace};";
+  static constexpr auto kJavaDescriptor = "L${jniNamespace};";
   static std::shared_ptr<${JHybridTSpec}> create() {
-    static auto constructorFn = javaClassStatic()->getConstructor<${JHybridTSpec}Impl::javaobject()>();
+    static const auto constructorFn = javaClassStatic()->getConstructor<${JHybridTSpec}Impl::javaobject()>();
     jni::local_ref<${JHybridTSpec}::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
     return javaPart->get${JHybridTSpec}();
   }

package/lib/syntax/kotlin/KotlinStruct.js

@@ -96,7 +96,7 @@ namespace ${cxxNamespace} {
    */
   struct J${structType.structName} final: public jni::JavaClass<J${structType.structName}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
 
   public:
     /**

package/lib/syntax/kotlin/KotlinVariant.js

@@ -127,7 +127,7 @@ if (isInstanceOf(${namespace}::${innerName}::javaClassStatic())) {
         return `
 class ${innerName} final: public jni::JavaClass<${innerName}, J${kotlinName}> {
 public:
-  static auto constexpr kJavaDescriptor = "L${descriptor};";
+  static constexpr auto kJavaDescriptor = "L${descriptor};";
 
   [[nodiscard]] ${bridge.asJniReferenceType('local')} getValue() const {
     static const auto field = javaClassStatic()->getField<${bridge.getTypeCode('c++')}>("value");
@@ -160,7 +160,7 @@ namespace ${cxxNamespace} {
    */
   class J${kotlinName}: public jni::JavaClass<J${kotlinName}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
 
     ${indent(cppCreateFuncs.join('\n'), '    ')}
 

package/lib/views/kotlin/KotlinHybridViewManager.js

@@ -11,11 +11,11 @@ export function createKotlinHybridViewManager(spec) {
     const { JHybridTSpec, HybridTSpec } = getHybridObjectName(spec.name);
     const { manager, stateClassName, component, propsClassName, descriptorClassName, } = getViewComponentNames(spec);
     const stateUpdaterName = `${stateClassName}Updater`;
-    const autolinking = spec.config.getAutolinkedHybridObjects();
-    const viewImplementation = autolinking[spec.name]?.kotlin;
-    if (viewImplementation == null) {
-        throw new Error(`Cannot create Kotlin HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`);
+    const implementation = spec.config.getAndroidAutolinkedImplementation(spec.name);
+    if (implementation?.language !== 'kotlin') {
+        throw new Error(`Cannot create Kotlin HybridView ViewManager for ${spec.name} - it must be autolinked with a Kotlin Android implementation in nitro.json!`);
     }
+    const viewImplementation = implementation.implementationClassName;
     const viewManagerCode = `
 ${createFileMetadataString(`${manager}.kt`)}
 

package/lib/views/swift/SwiftHybridViewManager.js

@@ -11,10 +11,9 @@ export function createSwiftHybridViewManager(spec) {
     const swiftNamespace = spec.config.getIosModuleName();
     const { HybridTSpec, HybridTSpecSwift, HybridTSpecCxx } = getHybridObjectName(spec.name);
     const { component, descriptorClassName, propsClassName } = getViewComponentNames(spec);
-    const autolinking = spec.config.getAutolinkedHybridObjects();
-    const viewImplementation = autolinking[spec.name]?.swift;
-    if (viewImplementation == null) {
-        throw new Error(`Cannot create Swift HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`);
+    const implementation = spec.config.getIosAutolinkedImplementation(spec.name);
+    if (implementation?.language !== 'swift') {
+        throw new Error(`Cannot create Swift HybridView ViewManager for ${spec.name} - it must be autolinked with a Swift iOS implementation in nitro.json!`);
     }
     const propAssignments = spec.properties.map((p) => {
         const name = escapeCppName(p.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.35.0",
+  "version": "0.35.1-beta.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.35.0",
+    "react-native-nitro-modules": "^0.35.1-beta.0",
     "ts-morph": "^27.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.0.5"

package/src/autolinking/android/createHybridObjectInitializer.ts

@@ -28,27 +28,39 @@ export function createHybridObjectIntializer(): SourceFile[] {
   const cppRegistrations: string[] = []
   const cppDefinitions: string[] = []
   for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
-    const config = autolinkedHybridObjects[hybridObjectName]
-
-    if (config?.cpp != null) {
-      // Autolink a C++ HybridObject!
-      const { cppCode, requiredImports } = createCppHybridObjectRegistration({
-        hybridObjectName: hybridObjectName,
-        cppClassName: config.cpp,
-      })
-      cppHybridObjectImports.push(...requiredImports)
-      cppRegistrations.push(cppCode)
+    const implementation =
+      NitroConfig.current.getAndroidAutolinkedImplementation(hybridObjectName)
+    if (implementation == null) {
+      continue
     }
-    if (config?.kotlin != null) {
-      // Autolink a Kotlin HybridObject through JNI/C++!
-      const { cppCode, cppDefinition, requiredImports } =
-        createJNIHybridObjectRegistration({
+
+    switch (implementation.language) {
+      case 'cpp': {
+        // Autolink a C++ HybridObject!
+        const { cppCode, requiredImports } = createCppHybridObjectRegistration({
           hybridObjectName: hybridObjectName,
-          jniClassName: config.kotlin,
+          cppClassName: implementation.implementationClassName,
         })
-      cppHybridObjectImports.push(...requiredImports)
-      cppDefinitions.push(cppDefinition)
-      cppRegistrations.push(cppCode)
+        cppHybridObjectImports.push(...requiredImports)
+        cppRegistrations.push(cppCode)
+        break
+      }
+      case 'kotlin': {
+        // Autolink a Kotlin HybridObject through JNI/C++!
+        const { cppCode, cppDefinition, requiredImports } =
+          createJNIHybridObjectRegistration({
+            hybridObjectName: hybridObjectName,
+            jniClassName: implementation.implementationClassName,
+          })
+        cppHybridObjectImports.push(...requiredImports)
+        cppDefinitions.push(cppDefinition)
+        cppRegistrations.push(cppCode)
+        break
+      }
+      default:
+        throw new Error(
+          `The HybridObject "${hybridObjectName}" cannot be autolinked on Android - Language "${implementation.language}" is not supported on Android!`
+        )
     }
   }
 

package/src/autolinking/ios/createHybridObjectInitializer.ts

@@ -23,28 +23,40 @@ export function createHybridObjectIntializer(): [ObjcFile, SwiftFile] | [] {
   const cppImports: SourceImport[] = []
   let containsSwiftObjects = false
   for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
-    const config = autolinkedHybridObjects[hybridObjectName]
-
-    if (config?.cpp != null) {
-      // Autolink a C++ HybridObject!
-      const { cppCode, requiredImports } = createCppHybridObjectRegistration({
-        hybridObjectName: hybridObjectName,
-        cppClassName: config.cpp,
-      })
-      cppImports.push(...requiredImports)
-      cppRegistrations.push(cppCode)
+    const implementation =
+      NitroConfig.current.getIosAutolinkedImplementation(hybridObjectName)
+    if (implementation == null) {
+      continue
     }
-    if (config?.swift != null) {
-      // Autolink a Swift HybridObject!
-      containsSwiftObjects = true
-      const { cppCode, requiredImports, swiftRegistrationMethods } =
-        createSwiftHybridObjectRegistration({
+
+    switch (implementation.language) {
+      case 'cpp': {
+        // Autolink a C++ HybridObject!
+        const { cppCode, requiredImports } = createCppHybridObjectRegistration({
           hybridObjectName: hybridObjectName,
-          swiftClassName: config.swift,
+          cppClassName: implementation.implementationClassName,
         })
-      cppImports.push(...requiredImports)
-      cppRegistrations.push(cppCode)
-      swiftRegistrations.push(swiftRegistrationMethods)
+        cppImports.push(...requiredImports)
+        cppRegistrations.push(cppCode)
+        break
+      }
+      case 'swift': {
+        // Autolink a Swift HybridObject!
+        containsSwiftObjects = true
+        const { cppCode, requiredImports, swiftRegistrationMethods } =
+          createSwiftHybridObjectRegistration({
+            hybridObjectName: hybridObjectName,
+            swiftClassName: implementation.implementationClassName,
+          })
+        cppImports.push(...requiredImports)
+        cppRegistrations.push(cppCode)
+        swiftRegistrations.push(swiftRegistrationMethods)
+        break
+      }
+      default:
+        throw new Error(
+          `The HybridObject "${hybridObjectName}" cannot be autolinked on iOS - Language "${implementation.language}" is not supported on iOS!`
+        )
     }
   }
 

package/src/config/NitroConfig.ts

@@ -1,6 +1,11 @@
 import chalk from 'chalk'
 import { readUserConfig } from './getConfig.js'
-import type { NitroUserConfig } from './NitroUserConfig.js'
+import type {
+  AutolinkingAndroidImplementation,
+  AutolinkingIOSImplementation,
+  AutolinkingPlatformImplementation,
+  NitroUserConfig,
+} from './NitroUserConfig.js'
 
 const CXX_BASE_NAMESPACE = ['margelo', 'nitro']
 const ANDROID_BASE_NAMESPACE = ['com', 'margelo', 'nitro']
@@ -109,6 +114,49 @@ export class NitroConfig {
     return this.config.autolinking
   }
 
+  getPlatformAutolinkedImplementation(
+    hybridObjectName: string,
+    platform: string
+  ): AutolinkingPlatformImplementation | undefined {
+    const objectConfig = this.config.autolinking[hybridObjectName]
+    if (objectConfig == null) {
+      return undefined
+    }
+
+    // "all" applies to every platform and should automatically include
+    // future platforms without having to expand explicit key lists here.
+    if (objectConfig.all != null) {
+      return objectConfig.all
+    }
+    return objectConfig[platform]
+  }
+
+  getIosAutolinkedImplementation(
+    hybridObjectName: string
+  ): AutolinkingIOSImplementation | undefined {
+    const objectConfig = this.config.autolinking[hybridObjectName]
+    if (objectConfig == null) {
+      return undefined
+    }
+    if (objectConfig.all != null) {
+      return objectConfig.all
+    }
+    return objectConfig.ios
+  }
+
+  getAndroidAutolinkedImplementation(
+    hybridObjectName: string
+  ): AutolinkingAndroidImplementation | undefined {
+    const objectConfig = this.config.autolinking[hybridObjectName]
+    if (objectConfig == null) {
+      return undefined
+    }
+    if (objectConfig.all != null) {
+      return objectConfig.all
+    }
+    return objectConfig.android
+  }
+
   /**
    * Get the paths that will be ignored when loading the TypeScript project.
    * In most cases, this just contains `node_modules/`.

package/src/config/NitroUserConfig.ts

@@ -9,6 +9,137 @@ const isReservedKeywordError = {
   message: `This value is reserved and cannot be used!`,
 }
 
+const autolinkingLanguageSchema = z.enum(['cpp', 'swift', 'kotlin'])
+
+const autolinkingAllImplementationSchema = z.object({
+  language: z.literal('cpp'),
+  implementationClassName: z.string(),
+})
+
+const autolinkingIOSImplementationSchema = z.object({
+  language: z.enum(['cpp', 'swift']),
+  implementationClassName: z.string(),
+})
+
+const autolinkingAndroidImplementationSchema = z.object({
+  language: z.enum(['cpp', 'kotlin']),
+  implementationClassName: z.string(),
+})
+
+const autolinkingPlatformImplementationSchema = z.object({
+  language: autolinkingLanguageSchema,
+  implementationClassName: z.string(),
+})
+
+const autolinkingModernHybridObjectSchema = z
+  .object({
+    all: autolinkingAllImplementationSchema.optional(),
+    ios: autolinkingIOSImplementationSchema.optional(),
+    android: autolinkingAndroidImplementationSchema.optional(),
+  })
+  .catchall(autolinkingPlatformImplementationSchema)
+  .superRefine((value, ctx) => {
+    const hasAll = value.all != null
+    const platformCount = Object.keys(value).filter(
+      (key) => key !== 'all'
+    ).length
+
+    if (hasAll && platformCount > 0) {
+      ctx.addIssue({
+        code: 'custom',
+        message: '"all" cannot be combined with platform-specific entries.',
+      })
+    }
+
+    if (!hasAll && platformCount === 0) {
+      ctx.addIssue({
+        code: 'custom',
+        message:
+          'Each autolinking entry must declare either "all" or at least one platform.',
+      })
+    }
+  })
+
+const autolinkingLegacyHybridObjectSchema = z
+  .object({
+    cpp: z.string().optional(),
+    swift: z.string().optional(),
+    kotlin: z.string().optional(),
+  })
+  .strict()
+  .superRefine((value, ctx) => {
+    const hasCpp = value.cpp != null
+    const hasSwift = value.swift != null
+    const hasKotlin = value.kotlin != null
+
+    if (!hasCpp && !hasSwift && !hasKotlin) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          'Each autolinking entry must declare at least one implementation.',
+      })
+    }
+
+    if (hasCpp && (hasSwift || hasKotlin)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          'Legacy autolinking entries cannot mix "cpp" with "swift"/"kotlin".',
+      })
+    }
+  })
+
+function normalizeLegacyAutolinkingHybridObject(
+  value: z.infer<typeof autolinkingLegacyHybridObjectSchema>
+): z.infer<typeof autolinkingModernHybridObjectSchema> {
+  if (value.cpp != null) {
+    return {
+      all: {
+        language: 'cpp',
+        implementationClassName: value.cpp,
+      },
+    }
+  }
+
+  const normalized: z.infer<typeof autolinkingModernHybridObjectSchema> = {}
+  if (value.swift != null) {
+    normalized.ios = {
+      language: 'swift',
+      implementationClassName: value.swift,
+    }
+  }
+  if (value.kotlin != null) {
+    normalized.android = {
+      language: 'kotlin',
+      implementationClassName: value.kotlin,
+    }
+  }
+  return normalized
+}
+
+const autolinkingHybridObjectSchema = z.union([
+  autolinkingModernHybridObjectSchema,
+  autolinkingLegacyHybridObjectSchema.transform(
+    normalizeLegacyAutolinkingHybridObject
+  ),
+])
+
+export type AutolinkingAllImplementation = z.infer<
+  typeof autolinkingAllImplementationSchema
+>
+export type AutolinkingIOSImplementation = z.infer<
+  typeof autolinkingIOSImplementationSchema
+>
+export type AutolinkingAndroidImplementation = z.infer<
+  typeof autolinkingAndroidImplementationSchema
+>
+export type AutolinkingPlatformImplementation = z.infer<
+  typeof autolinkingPlatformImplementationSchema
+>
+export type AutolinkingHybridObject = z.infer<
+  typeof autolinkingHybridObjectSchema
+>
+
 export const NitroUserConfigSchema = z.object({
   /**
    * Represents the C++ namespace of the module that will be generated.
@@ -74,17 +205,10 @@ export const NitroUserConfigSchema = z.object({
    * Configures the code that gets generated for autolinking (registering)
    * Hybrid Object constructors.
    *
-   * Each class listed here needs to have a default constructor/initializer that takes
-   * zero arguments.
+   * Each class listed here needs to have a default constructor/initializer
+   * that takes zero arguments.
    */
-  autolinking: z.record(
-    z.string(),
-    z.object({
-      cpp: z.string().optional(),
-      swift: z.string().optional(),
-      kotlin: z.string().optional(),
-    })
-  ),
+  autolinking: z.record(z.string(), autolinkingHybridObjectSchema),
   /**
    * A list of paths relative to the project directory that should be ignored by nitrogen.
    * Nitrogen will not look for `.nitro.ts` files in these directories.

package/src/config/getConfig.ts

@@ -6,6 +6,43 @@ import {
 } from './NitroUserConfig.js'
 import chalk from 'chalk'
 
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value != null && !Array.isArray(value)
+}
+
+function getLegacyAutolinkingEntries(config: unknown): string[] {
+  if (!isObject(config)) return []
+
+  const autolinking = config.autolinking
+  if (!isObject(autolinking)) return []
+
+  const entries: string[] = []
+  for (const [hybridObjectName, entry] of Object.entries(autolinking)) {
+    if (!isObject(entry)) continue
+
+    const hasLegacySyntax =
+      'cpp' in entry || 'swift' in entry || 'kotlin' in entry
+    if (hasLegacySyntax) {
+      entries.push(hybridObjectName)
+    }
+  }
+
+  return entries
+}
+
+// TODO: Remove this once users have migrated to new `nitro.json`
+function logLegacyAutolinkingDeprecation(config: unknown): void {
+  const legacyEntries = getLegacyAutolinkingEntries(config)
+  if (legacyEntries.length === 0) return
+
+  console.warn(
+    chalk.yellow(
+      `Warning: nitro.json uses deprecated autolinking syntax ("cpp"/"swift"/"kotlin") for [${legacyEntries.join(', ')}]. ` +
+        `Use "all"/"ios"/"android" entries with { language, implementationClassName } instead.`
+    )
+  )
+}
+
 function readFile(configPath: string): string {
   try {
     return fs.readFileSync(configPath, 'utf8')
@@ -58,6 +95,7 @@ function parseConfig(json: string): NitroUserConfig {
   }
 
   try {
+    logLegacyAutolinkingDeprecation(object)
     return NitroUserConfigSchema.parse(object)
   } catch (error) {
     if (error instanceof ZodError) {

package/src/syntax/kotlin/FbjniHybridObject.ts

@@ -103,11 +103,11 @@ namespace ${cxxNamespace} {
   class ${name.JHybridTSpec}: public virtual ${name.HybridTSpec}, public virtual ${cppBaseClass} {
   public:
     struct JavaPart: public jni::JavaClass<JavaPart, ${javaPartBaseClass}> {
-      static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+      static constexpr auto 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 constexpr auto kJavaDescriptor = "L${cxxPartJniClassDescriptor};";
       static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
       static void registerNatives();
       using HybridBase::HybridBase;

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -66,7 +66,13 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
     return false
   }
 
-  getRequiredImports(language: Language): SourceImport[] {
+  getRequiredImports(
+    language: Language,
+    visited: Set<Type> = new Set()
+  ): SourceImport[] {
+    if (visited.has(this.type)) return []
+    visited.add(this.type)
+
     const imports = this.type.getRequiredImports(language)
 
     if (language === 'c++') {
@@ -179,19 +185,17 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
 
     // Recursively look into referenced types (e.g. the `T` of a `optional<T>`, or `T` of a `T[]`)
     const referencedTypes = getReferencedTypes(this.type)
-    referencedTypes.forEach((t) => {
-      if (t === this.type) {
-        // break a recursion - we already know this type
-        return
-      }
+    for (const t of referencedTypes) {
       const bridged = new KotlinCxxBridgedType(t)
-      imports.push(...bridged.getRequiredImports(language))
-    })
+      imports.push(...bridged.getRequiredImports(language, visited))
+    }
 
     return imports
   }
 
-  getExtraFiles(): SourceFile[] {
+  getExtraFiles(visited: Set<Type> = new Set()): SourceFile[] {
+    if (visited.has(this.type)) return []
+    visited.add(this.type)
     const files: SourceFile[] = []
 
     switch (this.type.kind) {
@@ -219,14 +223,10 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
 
     // Recursively look into referenced types (e.g. the `T` of a `optional<T>`, or `T` of a `T[]`)
     const referencedTypes = getReferencedTypes(this.type)
-    referencedTypes.forEach((t) => {
-      if (t === this.type) {
-        // break a recursion - we already know this type
-        return
-      }
+    for (const t of referencedTypes) {
       const bridged = new KotlinCxxBridgedType(t)
-      files.push(...bridged.getExtraFiles())
-    })
+      files.push(...bridged.getExtraFiles(visited))
+    }
 
     return files
   }

package/src/syntax/kotlin/KotlinEnum.ts

@@ -53,7 +53,7 @@ namespace ${cxxNamespace} {
    */
   struct J${enumType.enumName} final: public jni::JavaClass<J${enumType.enumName}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
 
   public:
     /**

package/src/syntax/kotlin/KotlinFunction.ts

@@ -201,7 +201,7 @@ namespace ${cxxNamespace} {
    */
   struct J${name}: public jni::JavaClass<J${name}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniInterfaceDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniInterfaceDescriptor};";
 
   public:
     /**
@@ -236,7 +236,7 @@ namespace ${cxxNamespace} {
     }
 
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
     static void registerNatives() {
       registerHybrid({makeNativeMethod("invoke_cxx", J${name}_cxx::invoke_cxx)});
     }

package/src/syntax/kotlin/KotlinHybridObjectRegistration.ts

@@ -40,9 +40,9 @@ export function createJNIHybridObjectRegistration({
     ],
     cppDefinition: `
 struct ${JHybridTSpec}Impl: public jni::JavaClass<${JHybridTSpec}Impl, ${JHybridTSpec}::JavaPart> {
-  static auto constexpr kJavaDescriptor = "L${jniNamespace};";
+  static constexpr auto kJavaDescriptor = "L${jniNamespace};";
   static std::shared_ptr<${JHybridTSpec}> create() {
-    static auto constructorFn = javaClassStatic()->getConstructor<${JHybridTSpec}Impl::javaobject()>();
+    static const auto constructorFn = javaClassStatic()->getConstructor<${JHybridTSpec}Impl::javaobject()>();
     jni::local_ref<${JHybridTSpec}::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
     return javaPart->get${JHybridTSpec}();
   }

package/src/syntax/kotlin/KotlinStruct.ts

@@ -117,7 +117,7 @@ namespace ${cxxNamespace} {
    */
   struct J${structType.structName} final: public jni::JavaClass<J${structType.structName}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
 
   public:
     /**

package/src/syntax/kotlin/KotlinVariant.ts

@@ -145,7 +145,7 @@ if (isInstanceOf(${namespace}::${innerName}::javaClassStatic())) {
     return `
 class ${innerName} final: public jni::JavaClass<${innerName}, J${kotlinName}> {
 public:
-  static auto constexpr kJavaDescriptor = "L${descriptor};";
+  static constexpr auto kJavaDescriptor = "L${descriptor};";
 
   [[nodiscard]] ${bridge.asJniReferenceType('local')} getValue() const {
     static const auto field = javaClassStatic()->getField<${bridge.getTypeCode('c++')}>("value");
@@ -180,7 +180,7 @@ namespace ${cxxNamespace} {
    */
   class J${kotlinName}: public jni::JavaClass<J${kotlinName}> {
   public:
-    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static constexpr auto kJavaDescriptor = "L${jniClassDescriptor};";
 
     ${indent(cppCreateFuncs.join('\n'), '    ')}
 

package/src/views/kotlin/KotlinHybridViewManager.ts

@@ -28,13 +28,15 @@ export function createKotlinHybridViewManager(
     descriptorClassName,
   } = getViewComponentNames(spec)
   const stateUpdaterName = `${stateClassName}Updater`
-  const autolinking = spec.config.getAutolinkedHybridObjects()
-  const viewImplementation = autolinking[spec.name]?.kotlin
-  if (viewImplementation == null) {
+  const implementation = spec.config.getAndroidAutolinkedImplementation(
+    spec.name
+  )
+  if (implementation?.language !== 'kotlin') {
     throw new Error(
-      `Cannot create Kotlin HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`
+      `Cannot create Kotlin HybridView ViewManager for ${spec.name} - it must be autolinked with a Kotlin Android implementation in nitro.json!`
     )
   }
+  const viewImplementation = implementation.implementationClassName
 
   const viewManagerCode = `
 ${createFileMetadataString(`${manager}.kt`)}

package/src/views/swift/SwiftHybridViewManager.ts

@@ -28,11 +28,10 @@ export function createSwiftHybridViewManager(
   )
   const { component, descriptorClassName, propsClassName } =
     getViewComponentNames(spec)
-  const autolinking = spec.config.getAutolinkedHybridObjects()
-  const viewImplementation = autolinking[spec.name]?.swift
-  if (viewImplementation == null) {
+  const implementation = spec.config.getIosAutolinkedImplementation(spec.name)
+  if (implementation?.language !== 'swift') {
     throw new Error(
-      `Cannot create Swift HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`
+      `Cannot create Swift HybridView ViewManager for ${spec.name} - it must be autolinked with a Swift iOS implementation in nitro.json!`
     )
   }