react-native-sherpa-onnx 0.2.0 → 0.3.0

package/SherpaOnnx.podspec

@@ -1,11 +1,41 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-
-# Compute absolute paths
 pod_root = __dir__
-ios_include_path = File.join(pod_root, 'ios', 'include')
-framework_path = File.join(pod_root, 'ios', 'Frameworks', 'sherpa_onnx.xcframework')
+# Prefer libarchive_prebuilt layout (output of third_party/libarchive_prebuilt/build_libarchive_ios.sh).
+# Fallback: download via setup-ios-libarchive.sh to ios/Downloads/libarchive (e.g. when using SDK from npm).
+libarchive_prebuilt = File.join(pod_root, "third_party", "libarchive_prebuilt", "libarchive-ios-layout")
+libarchive_downloads = File.join(pod_root, "ios", "Downloads", "libarchive")
+unless File.directory?(libarchive_prebuilt) && Dir.glob(File.join(libarchive_prebuilt, "*.c")).any?
+  libarchive_script = File.join(pod_root, "ios", "scripts", "setup-ios-libarchive.sh")
+  if File.exist?(libarchive_script)
+    unless system("bash", libarchive_script)
+      abort("[SherpaOnnx] setup-ios-libarchive.sh failed. Check that third_party/libarchive_prebuilt/IOS_RELEASE_TAG exists and the release is available (network). Run the script manually: bash #{libarchive_script}")
+    end
+  end
+end
+libarchive_dir = (File.directory?(libarchive_prebuilt) && Dir.glob(File.join(libarchive_prebuilt, "*.c")).any?) ? libarchive_prebuilt : libarchive_downloads
+# Patch libarchive .c files (copy to ios/patched_libarchive with stdio.h/unistd.h added) so we don't modify the submodule.
+patched_dir = File.join(pod_root, "ios", "patched_libarchive")
+patch_script = File.join(pod_root, "ios", "scripts", "patch-libarchive-includes.sh")
+if File.directory?(libarchive_dir) && File.exist?(patch_script)
+  unless system("bash", patch_script, libarchive_dir)
+    abort("[SherpaOnnx] patch-libarchive-includes.sh failed. Check that #{libarchive_dir} contains libarchive .c/.h files.")
+  end
+end
+# Libarchive C sources: use patched copies (same exclude as before: test, windows, linux, sunos, freebsd).
+libarchive_sources = if File.directory?(patched_dir)
+  Dir.glob(File.join(patched_dir, "*.c")).reject { |f|
+    base = File.basename(f, ".c")
+    File.basename(f) =~ /^test\./ || base.include?("windows") || base.include?("linux") || base.include?("sunos") || base.include?("freebsd")
+  }.map { |f| Pathname.new(f).relative_path_from(Pathname.new(pod_root)).to_s.gsub("\\", "/") }
+else
+  []
+end
+
+if libarchive_sources.empty?
+  abort("[SherpaOnnx] Libarchive sources missing. Ensure third_party/libarchive_prebuilt/libarchive-ios-layout exists (run third_party/libarchive_prebuilt/build_libarchive_ios.sh) or ios/scripts/setup-ios-libarchive.sh has run, and that ios/scripts/patch-libarchive-includes.sh succeeds. Check pod install logs for patch script errors.")
+end
 
 Pod::Spec.new do |s|
   s.name         = "SherpaOnnx"
@@ -17,68 +47,42 @@ Pod::Spec.new do |s|
 
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/XDcobra/react-native-sherpa-onnx.git", :tag => "#{s.version}" }
-  
-  # Source files (implementation)
-  # Include .cc for cxx-api.cc (C++ wrapper around C API)
-  s.source_files = "ios/**/*.{h,m,mm,swift,cpp,cc}"
-  
-  # Private headers (our wrapper headers)
-  s.private_header_files = [
-    "ios/*.h",
-    "ios/include/**/*.h"
-  ]
-  
-  # Link with required frameworks and libraries
-  # CoreML is required by ONNX Runtime's CoreML execution provider
-  s.frameworks = 'Foundation', 'Accelerate', 'CoreML'
-  s.libraries = 'c++'
-  
-  # Note: Header files and framework are set up by postinstall script (yarn setup-assets)
-  # This runs automatically after yarn/npm install and handles all setup tasks
-  
-  # Verify XCFramework exists
-  unless File.exist?(framework_path)
-    raise <<~MSG
-      [SherpaOnnx] ERROR: iOS Framework not found.
-      
-      The sherpa-onnx XCFramework should have been downloaded automatically during pod install.
-      If the automatic download failed, you can manually download it by running:
-      
-      yarn download-ios-framework
-      
-      Or download from GitHub Releases:
-      https://github.com/XDcobra/react-native-sherpa-onnx/releases?q=framework
-      
-      Then extract to: #{framework_path}
-    MSG
-  end
-  
-  # Log paths for debugging (visible during pod install)
-  puts "[SherpaOnnx] Pod root: #{pod_root}"
-  puts "[SherpaOnnx] Include path: #{ios_include_path}"
-  puts "[SherpaOnnx] Framework path: #{framework_path}"
-  framework_version = File.read(File.join(pod_root, 'ios', 'Frameworks', '.framework-version')).strip rescue 'unknown'
-  puts "[SherpaOnnx] Framework version: #{framework_version}"
-  
-  # Use vendored_frameworks for the XCFramework
-  s.vendored_frameworks = 'ios/Frameworks/sherpa_onnx.xcframework'
-  
-  # Preserve headers and config files
-  s.preserve_paths = [
-    'ios/SherpaOnnx.xcconfig',
-    'ios/include/**/*'
-  ]
-  
+
+  # Download sherpa-onnx XCFramework from GitHub Releases before pod install (uses IOS_RELEASE_TAG for pinned version).
+  setup_script = File.join(pod_root, "scripts", "setup-ios-framework.sh")
+  s.prepare_command = "bash \"#{setup_script}\""
+
+  s.source_files = ["ios/**/*.{h,m,mm,swift,cpp}", *libarchive_sources]
+  s.private_header_files = "ios/**/*.h"
+
+  s.frameworks = "Foundation", "Accelerate", "CoreML"
+  s.vendored_frameworks = "ios/Frameworks/sherpa_onnx.xcframework"
+  # Absolute paths so headers are found regardless of PODS_TARGET_SRCROOT (e.g. when building via React Native CLI).
+  xcframework_root = File.join(pod_root, "ios", "Frameworks", "sherpa_onnx.xcframework")
+  simulator_headers = File.join(xcframework_root, "ios-arm64_x86_64-simulator", "Headers")
+  device_headers = File.join(xcframework_root, "ios-arm64", "Headers")
+  simulator_slice = File.join(xcframework_root, "ios-arm64_x86_64-simulator")
+  device_slice = File.join(xcframework_root, "ios-arm64")
+
   s.pod_target_xcconfig = {
-    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
-    'CLANG_CXX_LIBRARY' => 'libc++',
-    'HEADER_SEARCH_PATHS' => "$(inherited) \"#{ios_include_path}\"",
+    "HEADER_SEARCH_PATHS" => "$(inherited) \"#{pod_root}/ios\" \"#{pod_root}/ios/archive\" \"#{pod_root}/ios/model_detect\" \"#{pod_root}/ios/stt\" \"#{pod_root}/ios/tts\" \"#{libarchive_dir}\" \"#{device_headers}\" \"#{simulator_headers}\"",
+    "GCC_PREPROCESSOR_DEFINITIONS" => '$(inherited) PLATFORM_CONFIG_H=\\"libarchive_darwin_config.h\\"',
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+    "CLANG_CXX_LIBRARY" => "libc++",
+    "LIBRARY_SEARCH_PATHS[sdk=iphoneos*]" => "$(inherited) \"#{device_slice}\"",
+    "LIBRARY_SEARCH_PATHS[sdk=iphonesimulator*]" => "$(inherited) \"#{simulator_slice}\"",
+    "OTHER_LDFLAGS" => "$(inherited) -lsherpa-onnx"
   }
-  
+
   s.user_target_xcconfig = {
-    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
-    'CLANG_CXX_LIBRARY' => 'libc++',
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+    "CLANG_CXX_LIBRARY" => "libc++",
+    "LIBRARY_SEARCH_PATHS[sdk=iphoneos*]" => "$(inherited) \"#{device_slice}\"",
+    "LIBRARY_SEARCH_PATHS[sdk=iphonesimulator*]" => "$(inherited) \"#{simulator_slice}\"",
+    "OTHER_LDFLAGS" => "$(inherited) -lsherpa-onnx"
   }
-  
+
+  s.libraries = "c++", "z"
+
   install_modules_dependencies(s)
-end
+end

package/android/build.gradle

@@ -1,193 +1,183 @@
-// Configurable sherpa-onnx version (default: 1.12.23)
-def sherpaOnnxVersion = project.hasProperty('sherpaOnnxVersion') ? project.sherpaOnnxVersion : '1.12.23'
-
-buildscript {
-  ext.SherpaOnnx = [
-    kotlinVersion: "2.0.21",
-    minSdkVersion: 24,
-    compileSdkVersion: 36,
-    targetSdkVersion: 36
-  ]
-
-  ext.getExtOrDefault = { prop ->
-    if (rootProject.ext.has(prop)) {
-      return rootProject.ext.get(prop)
-    }
-
-    return SherpaOnnx[prop]
-  }
-
-  repositories {
-    google()
-    mavenCentral()
-  }
-
-  dependencies {
-    classpath "com.android.tools.build:gradle:8.7.2"
-    // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
-  }
-}
-
-
-apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
-
-apply plugin: "com.facebook.react"
-
-android {
-  namespace "com.sherpaonnx"
-
-  compileSdkVersion getExtOrDefault("compileSdkVersion")
-
-  defaultConfig {
-    minSdkVersion getExtOrDefault("minSdkVersion")
-    targetSdkVersion getExtOrDefault("targetSdkVersion")
-
-    // NDK configuration
-    ndkVersion getExtOrDefault("ndkVersion")
-    externalNativeBuild {
-      cmake {
-        cppFlags "-std=c++17", "-Wall", "-Wextra", "-fvisibility=hidden"
-        arguments "-DANDROID_STL=c++_shared"
-      }
-    }
-
-    // Supported ABIs
-    ndk {
-      abiFilters "arm64-v8a", "armeabi-v7a", "x86", "x86_64"
-    }
-  }
-
-  buildFeatures {
-    buildConfig true
-  }
-
-  // CMake configuration
-  externalNativeBuild {
-    cmake {
-      path "src/main/cpp/CMakeLists.txt"
-      version "3.22.1"
-    }
-  }
-
-  buildTypes {
-    release {
-      minifyEnabled false
-    }
-  }
-
-  lint {
-    disable "GradleCompatible"
-  }
-
-  compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
-  }
-}
-
-
-repositories {
-  mavenCentral()
-  google()
-  maven { url 'https://jitpack.io' }
-}
-
-def kotlin_version = getExtOrDefault("kotlinVersion")
-
-dependencies {
-  implementation "com.facebook.react:react-android"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  
-  // sherpa-onnx prebuilt AAR from JitPack
-  // This includes the native .so libraries for all ABIs
-  implementation "com.github.k2-fsa:sherpa-onnx:v${sherpaOnnxVersion}"
-}
-
-// Create resolvable configuration for extraction
-configurations {
-  extractNativeLibs {
-    canBeResolved = true
-    canBeConsumed = false
-  }
-}
-
-dependencies {
-  extractNativeLibs "com.github.k2-fsa:sherpa-onnx:v${sherpaOnnxVersion}"
-}
-
-// Extract native libraries from AAR before CMake runs
-def extractNativeLibs = tasks.register("extractNativeLibs") {
-  doLast {
-    def extractedLibsDir = file("${buildDir}/extracted_native_libs")
-    extractedLibsDir.mkdirs()
-    
-    def resolvedConfig = configurations.extractNativeLibs.resolvedConfiguration
-    def foundAar = false
-    
-    resolvedConfig.resolvedArtifacts.each { artifact ->
-      def aarFile = artifact.file
-      println "Checking artifact: ${aarFile.name} (exists: ${aarFile.exists()})"
-      
-      if (aarFile.exists() && (aarFile.name.endsWith(".aar") || aarFile.name.endsWith(".jar"))) {
-        foundAar = true
-        println "Extracting native libraries from: ${aarFile.name}"
-        
-        copy {
-          from(zipTree(aarFile)) {
-            include "jni/**/*.so"
-          }
-          into extractedLibsDir
-        }
-        
-        // Verify extraction succeeded
-        def extractedFiles = fileTree(extractedLibsDir).matching { include "**/*.so" }
-        if (extractedFiles.isEmpty()) {
-          println "WARNING: No .so files extracted from ${aarFile.name}"
-          println "Contents of AAR:"
-          zipTree(aarFile).each { entry ->
-            if (entry.name.contains("jni") || entry.name.endsWith(".so")) {
-              println "  ${entry.name}"
-            }
-          }
-        }
-      }
-    }
-    
-    if (!foundAar) {
-      throw new RuntimeException("No AAR file found for sherpa-onnx. Check if the dependency is correctly resolved.")
-    }
-  }
-}
-
-// NOTE: Header files are now set up by postinstall script (yarn setup-assets)
-// This runs automatically after yarn/npm install and handles copying headers
-// We no longer need a Gradle task for this - headers will be present when build starts
-
-// Task to check and log header source before CMake runs
-def checkHeaderSource = tasks.register("checkHeaderSource") {
-  doLast {
-    def cppDir = file("src/main/cpp")
-    def bundledHeaderPath = file("${cppDir}/include/sherpa-onnx/c-api/cxx-api.h")
-    
-    if (bundledHeaderPath.exists()) {
-      println "[SherpaOnnx] Header files present"
-    } else {
-      println "[SherpaOnnx] ERROR: Header files not found at ${bundledHeaderPath.absolutePath}"
-      throw new RuntimeException("Header files not found. Run 'yarn setup-assets' or 'yarn copy-headers'")
-    }
-  }
-}
-
-// Make CMake depend on extraction and header verification - ensure they run before any CMake task
-afterEvaluate {
-  tasks.matching { it.name.contains("configureCMake") || it.name.contains("externalNativeBuild") }.configureEach {
-    dependsOn extractNativeLibs
-    dependsOn checkHeaderSource
-  }
-  
-  // Also ensure all extraction and verification tasks run before preBuild
-  preBuild.dependsOn extractNativeLibs
-  preBuild.dependsOn checkHeaderSource
+// Prebuilt versions (sherpa-onnx, FFmpeg, libarchive) from prebuilt-versions.gradle.
+// Resolution: env → ANDROID_RELEASE_TAG files → project property → default.
+apply from: file("${project.projectDir}/prebuilt-versions.gradle")
+
+// Used by dependencies below and by prebuilt-download.gradle (extractSherpaOnnxClasses, downloadNativeLibsIfNeeded).
+def sherpaOnnxClassesDir = file("${buildDir}/sherpa-onnx-classes")
+
+buildscript {
+  ext.SherpaOnnx = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return SherpaOnnx[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+    maven { url 'https://plugins.gradle.org/m2/' }
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+    // Node Gradle plugin for running node/npx reliably from Gradle
+    classpath "com.github.node-gradle:gradle-node-plugin:7.1.0"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+// Standalone AAR build: set in root build.gradle (ext.standaloneAarBuild = true) or via -PstandaloneAarBuild=true
+def isStandaloneAarBuild = rootProject.findProperty("standaloneAarBuild") in [true, "true"]
+// Only apply React Native plugin when building inside a React Native app (e.g. example app).
+if (!isStandaloneAarBuild) {
+  apply plugin: "com.facebook.react"
+}
+
+android {
+  namespace "com.sherpaonnx"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  // Native .so and headers: filled by prebuilt-download.gradle (local jniLibs, Maven AAR, or GitHub release).
+  // Alternatively by third_party/*/copy_prebuilts_to_sdk.js or shipped in npm package.
+
+  // Codegen Java output: always use the flat path. For app builds RNGP writes here directly;
+  // for standalone AAR builds the codegen task normalises the nested output to this path.
+  sourceSets.main.java.srcDirs += file("${buildDir}/generated/source/codegen/java")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    // ProGuard rules to preserve classes/methods called from JNI
+    consumerProguardFiles 'proguard-rules.pro'
+
+    // NDK configuration
+    ndkVersion getExtOrDefault("ndkVersion")
+    externalNativeBuild {
+      cmake {
+        cppFlags "-std=c++17", "-Wall", "-Wextra", "-fvisibility=hidden"
+        arguments "-DANDROID_STL=c++_shared"
+      }
+    }
+
+    // Supported ABIs
+    ndk {
+      abiFilters "arm64-v8a", "armeabi-v7a", "x86", "x86_64"
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  // CMake configuration
+  externalNativeBuild {
+    cmake {
+      path "src/main/cpp/CMakeLists.txt"
+      version "3.22.1"
+    }
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+  maven { url "https://xdcobra.github.io/maven" }
+}
+
+// Configurations used by prebuilt-download.gradle: downloadNativeLibsIfNeeded (AAR → jniLibs + headers),
+// extractSherpaOnnxClasses (sherpa-onnx classes.jar), extractOnnxruntimeClasses (onnxruntime classes.jar).
+configurations { sherpaOnnxAar; ffmpegAar; libarchiveAar; onnxruntimeAar }
+
+// Registers downloadNativeLibsIfNeeded, checkJniLibs, extractSherpaOnnxClasses, extractOnnxruntimeClasses; wires preBuild.dependsOn checkJniLibs.
+apply from: file("${project.projectDir}/prebuilt-download.gradle")
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // React Native dependency: explicit version ensures IDE (VS Code Kotlin LSP) and standalone
+  // AAR builds can resolve com.facebook.react types. When consumed by a React Native app,
+  // Gradle's dependency resolution picks the app's react-android version (typically higher).
+  implementation "com.facebook.react:react-android:0.83.0"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  // Versions from prebuilt-versions.gradle; AARs used by prebuilt-download.gradle tasks.
+  sherpaOnnxAar "com.xdcobra.sherpa:sherpa-onnx:${sherpaOnnxVersion}@aar"
+  ffmpegAar "com.xdcobra.sherpa:ffmpeg:${ffmpegVersion}@aar"
+  libarchiveAar "com.xdcobra.sherpa:libarchive:${libarchiveVersion}@aar"
+  onnxruntimeAar "com.xdcobra.sherpa:onnxruntime:${ortVersion}@aar"
+
+  // sherpa-onnx Java API: extractSherpaOnnxClasses (in prebuilt-download.gradle) fills sherpaOnnxClassesDir.
+  // Source: local third_party | Maven AAR | GitHub release. Native .so from same prebuilt pipeline.
+  implementation fileTree(dir: sherpaOnnxClassesDir, include: '*.jar').builtBy(tasks.named('extractSherpaOnnxClasses'))
+
+  // ORT Java API (OrtEnvironment, OrtSession, OrtProvider) for getAvailableProviders/getQnnSupport/etc.
+  // Extracted classes.jar from onnxruntime AAR (no compileOnly needed; bundled directly in the SDK).
+  // libonnxruntime4j_jni.so is also extracted to jniLibs so the Java bridge works at runtime.
+  def onnxruntimeClassesDir = file("${buildDir}/onnxruntime-classes")
+  implementation fileTree(dir: onnxruntimeClassesDir, include: '*.jar').builtBy(tasks.named('extractOnnxruntimeClasses'))
+
+  // Play Asset Delivery: optional for getAssetPackPath (returns null if not used)
+  implementation "com.google.android.play:asset-delivery:2.3.0"
+}
+
+// TurboModule codegen; separate script to avoid Gradle 9 Groovy "source is null" with NodeTask.
+apply from: file("${project.projectDir}/codegen.gradle")
+
+// Wire prebuilt tasks: extractSherpaOnnxClasses → downloadNativeLibsIfNeeded when not standalone;
+// CMake/compile tasks depend on extractSherpaOnnxClasses and checkJniLibs.
+afterEvaluate {
+  if (!isStandaloneAarBuild && tasks.findByName("downloadNativeLibsIfNeeded") != null) {
+    tasks.named("extractSherpaOnnxClasses").configure { dependsOn tasks.named("downloadNativeLibsIfNeeded") }
+    tasks.named("extractOnnxruntimeClasses").configure { dependsOn tasks.named("downloadNativeLibsIfNeeded") }
+  }
+  tasks.matching { it.name.contains("configureCMake") || it.name.contains("externalNativeBuild") }.configureEach {
+    dependsOn tasks.named("extractSherpaOnnxClasses")
+    dependsOn tasks.named("extractOnnxruntimeClasses")
+    dependsOn tasks.named("checkJniLibs")
+  }
+
+  // With includesGeneratedCode=false, codegen is always run by our custom task (not RNGP).
+  // Kotlin compile must depend on it for both standalone AAR and app-dependency builds.
+  def codegenJavaDir = project.file("${project.buildDir}/generated/source/codegen/java")
+  tasks.matching { it.name == "compileReleaseKotlin" || it.name == "compileDebugKotlin" }.configureEach {
+    dependsOn tasks.named("extractSherpaOnnxClasses")
+    dependsOn tasks.named("extractOnnxruntimeClasses")
+    dependsOn tasks.named('generateCodegenSpec')
+    inputs.dir(codegenJavaDir)
+  }
 }

package/android/codegen.gradle

@@ -0,0 +1,57 @@
+// With includesGeneratedCode=false, RNGP does not run codegen for this library when it
+// is built as a dependency (e.g. example app). Run codegen whenever this module is built
+// (standalone AAR or as part of an app) so that NativeSherpaOnnxSpec exists for Kotlin compile.
+// Uses Exec + node (no Node Gradle plugin) to avoid classloader/DSL issues in applied script.
+def libraryRoot = project.projectDir.parentFile
+def outDir = file("${project.buildDir}/generated/source/codegen")
+def codegenJavaDir = file("${project.buildDir}/generated/source/codegen/java")
+
+codegenJavaDir.mkdirs()
+
+def codegenScript = file("${libraryRoot}/node_modules/react-native/scripts/generate-codegen-artifacts.js")
+def outDirPath = outDir.absolutePath.replace("\\", "/")
+def libraryRootPath = libraryRoot.absolutePath.replace("\\", "/")
+
+tasks.register("generateCodegenSpecNode", Exec) {
+  onlyIf { !project.hasProperty('useNpx') || project.property('useNpx') != 'true' }
+  workingDir = libraryRoot
+  inputs.dir(file("${libraryRoot}/src"))
+  inputs.file(file("${libraryRoot}/package.json"))
+  outputs.dir(codegenJavaDir)
+
+  doFirst {
+    if (!file("${libraryRoot}/node_modules/react-native").exists()) {
+      throw new RuntimeException(
+        "Codegen requires node_modules at library root. Run 'yarn install' (or npm install) in ${libraryRoot}, then rebuild."
+      )
+    }
+    outDir.mkdirs()
+  }
+
+  commandLine(
+    'node',
+    codegenScript.absolutePath,
+    '-p', libraryRootPath,
+    '-t', 'android',
+    '-o', outDirPath,
+    '-s', 'library'
+  )
+  environment 'CI': 'true'
+
+  doLast {
+    def nestedJava = file("${outDir}/android/app/build/generated/source/codegen/java")
+    if (nestedJava.exists()) {
+      project.copy {
+        from nestedJava
+        into codegenJavaDir
+      }
+      println "[codegen] Normalised spec output -> ${codegenJavaDir}"
+    } else {
+      println "[codegen] WARNING: expected nested output at ${nestedJava} not found"
+    }
+  }
+}
+
+tasks.register('generateCodegenSpec') {
+  dependsOn tasks.named('generateCodegenSpecNode')
+}