@granite-js/screen 1.0.0

package/gradle-plugin/src/main/kotlin/run/granite/gradle/GraniteRootExtension.kt

@@ -0,0 +1,107 @@
+package run.granite.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
+import run.granite.gradle.config.DependencyCoordinates
+import run.granite.gradle.utils.ReactNativeVersionReader
+import java.io.File
+
+/**
+ * DSL configuration extension for Granite Root Project plugin.
+ *
+ * Configure the plugin in your root build.gradle.kts:
+ * ```
+ * graniteRoot {
+ *     // Optional: Explicit version override (auto-detected from node_modules if not set)
+ *     // reactNativeVersion.set("0.84.0")
+ *     // hermesVersion.set("250829098.0.6")
+ *
+ *     // Optional: Override Maven group (for custom Maven repositories)
+ *     // reactGroup.set("com.facebook.react")
+ *     // hermesGroup.set("com.facebook.hermes")
+ * }
+ * ```
+ */
+abstract class GraniteRootExtension(private val project: Project) {
+
+  /**
+   * React Native version (auto-detected from node_modules if not set)
+   */
+  abstract val reactNativeVersion: Property<String>
+
+  /**
+   * Hermes version (auto-detected from node_modules if not set)
+   */
+  abstract val hermesVersion: Property<String>
+
+  /**
+   * React Native Maven group.
+   * Default: com.facebook.react
+   */
+  abstract val reactGroup: Property<String>
+
+  /**
+   * Hermes Maven group.
+   * Default: com.facebook.hermes
+   */
+  abstract val hermesGroup: Property<String>
+
+  /**
+   * Location of the node_modules directory.
+   * Default: rootProject.file("node_modules")
+   */
+  abstract val nodeModulesDir: Property<File>
+
+  init {
+    // Set default conventions
+    reactGroup.convention(DependencyCoordinates.DEFAULT_REACT_GROUP)
+    hermesGroup.convention(DependencyCoordinates.DEFAULT_HERMES_GROUP)
+    nodeModulesDir.convention(project.file("node_modules"))
+    // reactNativeVersion and hermesVersion are intentionally left without conventions
+    // They will be auto-detected if not explicitly set
+  }
+
+  /**
+   * Gets the resolved DependencyCoordinates.
+   *
+   * If versions are explicitly set, uses those values.
+   * Otherwise, auto-detects from node_modules/react-native.
+   *
+   * @return DependencyCoordinates for dependency substitution
+   * @throws IllegalStateException if auto-detection fails and no explicit versions set
+   */
+  internal fun getCoordinates(): DependencyCoordinates {
+    val reactNativeDir = nodeModulesDir.get().resolve("react-native")
+
+    // Auto-detect base coordinates if needed
+    val baseCoordinates = if (!reactNativeVersion.isPresent || !hermesVersion.isPresent) {
+      if (!reactNativeDir.exists()) {
+        error(
+          """
+                    |React Native directory not found: ${reactNativeDir.absolutePath}
+                    |
+                    |Either set versions explicitly in graniteRoot { } or ensure node_modules/react-native exists.
+                    |
+                    |Example:
+                    |  graniteRoot {
+                    |      reactNativeVersion.set("0.84.0")
+                    |      hermesVersion.set("250829098.0.6")
+                    |  }
+          """.trimMargin(),
+        )
+      }
+      ReactNativeVersionReader.readCoordinates(reactNativeDir)
+    } else {
+      null
+    }
+
+    // Build final coordinates: explicit > auto-detected
+    return DependencyCoordinates(
+      reactVersion = reactNativeVersion.orNull ?: baseCoordinates!!.reactVersion,
+      hermesVersion = baseCoordinates?.hermesVersion ?: "",
+      hermesV1Version = hermesVersion.orNull ?: baseCoordinates!!.hermesV1Version,
+      reactGroup = reactGroup.get(),
+      hermesGroup = hermesGroup.get(),
+    )
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/GraniteRootProjectPlugin.kt

@@ -0,0 +1,290 @@
+package run.granite.gradle
+
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import org.gradle.api.JavaVersion
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import run.granite.gradle.config.DependencyConfigurator
+
+/**
+ * Granite Root Project Plugin
+ *
+ * Plugin applied to the root project to automatically configure
+ * React Native dependency substitution.
+ *
+ * This plugin performs the following roles:
+ * - react-native → react-android dependency substitution
+ * - hermes-engine → hermes-android dependency substitution
+ * - com.facebook.react:hermes-android → com.facebook.hermes:hermes-android substitution (RN 0.84+)
+ * - Version forcing (force)
+ *
+ * Usage:
+ * ```
+ * // root build.gradle.kts
+ * plugins {
+ *     id("run.granite.rootproject")
+ * }
+ *
+ * graniteRoot {
+ *     // Optional: Explicit version override
+ *     // reactNativeVersion.set("0.84.0")
+ *     // hermesVersion.set("250829098.0.6")
+ * }
+ * ```
+ *
+ * @see GraniteRootExtension for configuration options
+ */
+class GraniteRootProjectPlugin : Plugin<Project> {
+
+  companion object {
+    /** Plugin identifier used in build.gradle.kts: `id("run.granite.rootproject")`. */
+    const val PLUGIN_ID = "run.granite.rootproject"
+
+    /** Name of the DSL extension block: `graniteRoot { ... }`. */
+    const val EXTENSION_NAME = "graniteRoot"
+
+    // Uses Granite-specific properties (operates independently from react.internal.*)
+    private const val INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT =
+      "granite.internal.disableJavaVersionAlignment"
+  }
+
+  override fun apply(project: Project) {
+    // 1. Root project validation
+    validateRootProject(project)
+
+    // 2. Create extension
+    val extension = project.extensions.create(
+      EXTENSION_NAME,
+      GraniteRootExtension::class.java,
+      project,
+    )
+
+    // 3. Configure PrivateReactExtension for React Native Gradle Plugin compatibility
+    configurePrivateReactExtension(project)
+
+    // 4. Configure Java toolchains IMMEDIATELY (before afterEvaluate)
+    // This must run before afterEvaluate for finalizeDsl to work
+    configureJavaToolChains(project)
+
+    // 5. Configure dependency substitution after evaluation
+    project.afterEvaluate {
+      configureDependencySubstitution(project, extension)
+    }
+
+    project.logger.lifecycle("Granite Root Project plugin applied to ${project.name}")
+  }
+
+  private fun validateRootProject(project: Project) {
+    if (project != project.rootProject) {
+      error(
+        """
+                |Granite Root Project plugin can only be applied to the root project.
+                |
+                |Current project: ${project.path}
+                |Root project: ${project.rootProject.path}
+                |
+                |Solution: Move the plugin application to your root build.gradle.kts:
+                |  plugins {
+                |      id("run.granite.rootproject")
+                |  }
+        """.trimMargin(),
+      )
+    }
+  }
+
+  private fun configureDependencySubstitution(project: Project, extension: GraniteRootExtension) {
+    val coordinates = extension.getCoordinates()
+    val substitutions = DependencyConfigurator.getDependencySubstitutions(coordinates)
+    val hermesVersion = coordinates.getEffectiveHermesVersion()
+
+    project.logger.lifecycle(
+      "Granite: Configuring dependency substitution " +
+        "(react: ${coordinates.reactVersion}, hermes: $hermesVersion)",
+    )
+
+    project.allprojects {
+      val targetProject = this
+
+      targetProject.configurations.all configBlock@{
+        // Filter: only Classpath configurations
+        if (!name.endsWith("CompileClasspath") && !name.endsWith("RuntimeClasspath")) {
+          return@configBlock
+        }
+        // Filter: skip AGP internal metadata configurations
+        if (name.contains("Metadata", ignoreCase = true)) {
+          return@configBlock
+        }
+        // Skip already resolved or non-resolvable configurations
+        if (!isCanBeResolved || state == Configuration.State.RESOLVED) {
+          return@configBlock
+        }
+
+        // Apply dependency substitution rules
+        resolutionStrategy.dependencySubstitution {
+          for ((oldCoordinate, newCoordinate, reason) in substitutions) {
+            substitute(module(oldCoordinate))
+              .using(module(newCoordinate))
+              .because(reason)
+          }
+        }
+
+        // Force versions for consistency
+        resolutionStrategy.force(
+          "${coordinates.reactGroup}:react-android:${coordinates.reactVersion}",
+          "${coordinates.hermesGroup}:hermes-android:$hermesVersion",
+        )
+      }
+    }
+
+    project.logger.lifecycle(
+      "Granite: Dependency substitution configured for all projects " +
+        "(${substitutions.size} rules applied)",
+    )
+  }
+
+  /**
+   * Configures Java 17 toolchain for all projects.
+   *
+   * Uses finalizeDsl in the same way as React Native's JdkConfiguratorUtils.kt.
+   * finalizeDsl runs after the android { } block evaluation but before AGP internal finalization.
+   *
+   * - Sets Java 17 for projects with com.android.application / com.android.library plugins
+   * - Sets jvmToolchain(17) for org.jetbrains.kotlin.android / org.jetbrains.kotlin.jvm plugins
+   *
+   * Disable: Set granite.internal.disableJavaVersionAlignment=true in gradle.properties
+   *
+   * @param project Root project
+   */
+  private fun configureJavaToolChains(project: Project) {
+    // Check if disabled at root project level
+    if (project.hasProperty(INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT)) {
+      project.logger.lifecycle("Granite: Java version alignment disabled via property")
+      return
+    }
+
+    project.allprojects {
+      val targetProject = this
+
+      // Can also be disabled at project level
+      if (targetProject.hasProperty(INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT)) {
+        return@allprojects
+      }
+
+      // Android Application plugin - set compileOptions via finalizeDsl
+      targetProject.pluginManager.withPlugin("com.android.application") {
+        targetProject.extensions
+          .getByType(ApplicationAndroidComponentsExtension::class.java)
+          .finalizeDsl { ext ->
+            ext.compileOptions.sourceCompatibility = JavaVersion.VERSION_17
+            ext.compileOptions.targetCompatibility = JavaVersion.VERSION_17
+          }
+      }
+
+      // Android Library plugin - set compileOptions via finalizeDsl
+      targetProject.pluginManager.withPlugin("com.android.library") {
+        targetProject.extensions
+          .getByType(LibraryAndroidComponentsExtension::class.java)
+          .finalizeDsl { ext ->
+            ext.compileOptions.sourceCompatibility = JavaVersion.VERSION_17
+            ext.compileOptions.targetCompatibility = JavaVersion.VERSION_17
+          }
+      }
+
+      // Kotlin Android plugin (uses reflection to avoid compile-time dependency)
+      targetProject.pluginManager.withPlugin("org.jetbrains.kotlin.android") {
+        try {
+          val kotlinExtension = targetProject.extensions.findByName("kotlin")
+          if (kotlinExtension != null) {
+            val jvmToolchainMethod = kotlinExtension.javaClass
+              .getMethod("jvmToolchain", Int::class.javaPrimitiveType)
+            jvmToolchainMethod.invoke(kotlinExtension, 17)
+          }
+        } catch (e: Exception) {
+          targetProject.logger.debug(
+            "Granite: Could not set jvmToolchain for ${targetProject.name}: ${e.message}",
+          )
+        }
+      }
+
+      // Kotlin JVM plugin configuration
+      targetProject.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+        try {
+          val kotlinExtension = targetProject.extensions.findByName("kotlin")
+          if (kotlinExtension != null) {
+            val jvmToolchainMethod = kotlinExtension.javaClass
+              .getMethod("jvmToolchain", Int::class.javaPrimitiveType)
+            jvmToolchainMethod.invoke(kotlinExtension, 17)
+          }
+        } catch (e: Exception) {
+          targetProject.logger.debug(
+            "Granite: Could not set jvmToolchain for ${targetProject.name}: ${e.message}",
+          )
+        }
+      }
+    }
+
+    project.logger.lifecycle("Granite: Configured Java 17 toolchain for all projects")
+  }
+
+  /**
+   * Pre-emptively creates and configures PrivateReactExtension from the React Native Gradle Plugin.
+   *
+   * Background:
+   * - PrivateReactExtension is created on the rootProject to share configuration between app and library modules
+   * - The default convention assumes rootProject.dir/../ (standard RN app's android/ directory structure)
+   * - In monorepo setups where rootProject.dir IS the package.json location, ../ points to the wrong path
+   * - When the application module does not apply com.facebook.react, root.set() is never called
+   *
+   * Solution:
+   * - This plugin creates the extension first and sets root to rootProject.dir
+   * - ReactPlugin uses findByType to reuse an existing extension, so there is no conflict
+   */
+  private fun configurePrivateReactExtension(project: Project) {
+    try {
+      val privateReactExtensionClass = Class.forName(
+        "com.facebook.react.internal.PrivateReactExtension",
+      )
+
+      val existing = project.extensions.findByType(privateReactExtensionClass)
+      if (existing != null) {
+        // If already exists, only configure root
+        setRootProperty(existing, project)
+        project.logger.lifecycle(
+          "Granite: Configured existing PrivateReactExtension root to ${project.projectDir}",
+        )
+        return
+      }
+
+      // Create new instance
+      val extension = project.extensions.create(
+        "privateReact",
+        privateReactExtensionClass,
+        project,
+      )
+      setRootProperty(extension, project)
+      project.logger.lifecycle(
+        "Granite: Created PrivateReactExtension with root=${project.projectDir}",
+      )
+    } catch (e: Exception) {
+      project.logger.warn(
+        "Granite: Could not configure PrivateReactExtension: ${e.message}. " +
+          "React Native Gradle Plugin may not be available on the classpath.",
+      )
+    }
+  }
+
+  private fun setRootProperty(extension: Any, project: Project) {
+    try {
+      val rootProperty = extension.javaClass.getMethod("getRoot").invoke(extension)
+      if (rootProperty is org.gradle.api.file.DirectoryProperty) {
+        rootProperty.set(project.layout.projectDirectory)
+      }
+    } catch (e: Exception) {
+      project.logger.warn(
+        "Granite: Could not set PrivateReactExtension root: ${e.message}",
+      )
+    }
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/BuildConfigConfigurator.kt

@@ -0,0 +1,69 @@
+package run.granite.gradle.config
+
+import com.android.build.gradle.LibraryExtension
+import org.gradle.api.Project
+import run.granite.gradle.GraniteExtension
+
+/**
+ * Configurator for Android BuildConfig field generation.
+ *
+ * Generates BuildConfig fields to expose:
+ * - Feature flags (New Architecture, Hermes always enabled)
+ * - Development server configuration
+ * - React Native version information
+ *
+ * These constants are available at runtime and compile-time for conditional logic.
+ */
+class BuildConfigConfigurator(
+  private val project: Project,
+  private val extension: GraniteExtension,
+) {
+
+  /**
+   * Configures BuildConfig fields for the Android library.
+   *
+   * Adds fields that are available in generated BuildConfig class:
+   * - IS_HERMES_ENABLED: Boolean flag for Hermes JavaScript engine (always true)
+   * - IS_NEW_ARCHITECTURE_ENABLED: Boolean flag for TurboModules/Fabric (always true)
+   * - REACT_NATIVE_VERSION: String with React Native version
+   */
+  fun configure(androidExtension: LibraryExtension) {
+    androidExtension.apply {
+      // Enable BuildConfig generation for library module
+      buildFeatures.buildConfig = true
+
+      // Add common BuildConfig fields
+      defaultConfig {
+        // Hermes JavaScript engine flag (always enabled)
+        buildConfigField(
+          "boolean",
+          "IS_HERMES_ENABLED",
+          "true",
+        )
+
+        // New Architecture (TurboModules + Fabric) flag (always enabled)
+        buildConfigField(
+          "boolean",
+          "IS_NEW_ARCHITECTURE_ENABLED",
+          "true",
+        )
+
+        // React Native version
+        buildConfigField(
+          "String",
+          "REACT_NATIVE_VERSION",
+          "\"${extension.reactNativeVersion.get()}\"",
+        )
+
+        // Bundle asset name
+        buildConfigField(
+          "String",
+          "BUNDLE_ASSET_NAME",
+          "\"${extension.bundleAssetName.get()}\"",
+        )
+      }
+    }
+
+    project.logger.lifecycle("BuildConfig fields configured for ${project.name}")
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/DependencyConfigurator.kt

@@ -0,0 +1,232 @@
+package run.granite.gradle.config
+
+import com.android.build.gradle.LibraryExtension
+import org.gradle.api.JavaVersion
+import org.gradle.api.Project
+import run.granite.gradle.GraniteExtension
+import run.granite.gradle.utils.ReactNativeVersionReader
+
+/**
+ * Configures React Native and related dependencies for the library module.
+ *
+ * This configurator automatically adds required dependencies:
+ * - react-native (implementation)
+ * - hermes-android (implementation)
+ * - soloader (implementation)
+ *
+ * Versions are resolved from the React Native installation to ensure compatibility.
+ */
+class DependencyConfigurator(
+  private val project: Project,
+  private val extension: GraniteExtension,
+) {
+
+  companion object {
+    // Default Maven group (official React Native Maven group)
+    const val DEFAULT_GROUP = "com.facebook.react"
+
+    // Dependency coordinates
+    private const val REACT_NATIVE_ARTIFACT = "react-android"
+    private const val HERMES_ARTIFACT = "hermes-android"
+
+    private const val SOLOADER_GROUP = "com.facebook.soloader"
+    private const val SOLOADER_ARTIFACT = "soloader"
+    private const val SOLOADER_VERSION = "0.12.1" // Compatible with RN 0.84+
+
+    // Deprecated coordinates for substitution
+    private const val DEPRECATED_REACT_NATIVE = "com.facebook.react:react-native"
+    private const val DEPRECATED_HERMES_ENGINE = "com.facebook.react:hermes-engine"
+
+    // Hermes group (RN 0.84+)
+    private const val HERMES_GROUP = "com.facebook.hermes"
+
+    // Additional deprecated coordinate
+    private const val DEPRECATED_HERMES_ANDROID = "com.facebook.react:hermes-android"
+
+    /**
+     * Creates dependency substitution rules.
+     *
+     * @param version React Native version
+     * @param group React Native Maven group (default: com.facebook.react)
+     * @return List of triples (original coordinate, replacement coordinate, reason)
+     */
+    fun getDependencySubstitutions(
+      version: String,
+      group: String,
+    ): List<Triple<String, String, String>> {
+      val substitutions = mutableListOf<Triple<String, String, String>>()
+
+      // Base substitution rules: deprecated coordinates → new coordinates
+      substitutions.add(
+        Triple(
+          DEPRECATED_REACT_NATIVE,
+          "$group:$REACT_NATIVE_ARTIFACT:$version",
+          "The react-native artifact was deprecated in favor of react-android",
+        ),
+      )
+      substitutions.add(
+        Triple(
+          DEPRECATED_HERMES_ENGINE,
+          "$group:$HERMES_ARTIFACT:$version",
+          "The hermes-engine artifact was deprecated in favor of hermes-android",
+        ),
+      )
+
+      // Cross-group substitution: when using custom Maven group
+      if (group != DEFAULT_GROUP) {
+        substitutions.add(
+          Triple(
+            "$DEFAULT_GROUP:$REACT_NATIVE_ARTIFACT",
+            "$group:$REACT_NATIVE_ARTIFACT:$version",
+            "Modified to use correct Maven group",
+          ),
+        )
+        substitutions.add(
+          Triple(
+            "$DEFAULT_GROUP:$HERMES_ARTIFACT",
+            "$group:$HERMES_ARTIFACT:$version",
+            "Modified to use correct Maven group",
+          ),
+        )
+      }
+
+      return substitutions
+    }
+
+    /**
+     * Creates dependency substitution rules (DependencyCoordinates version).
+     *
+     * Supports the new Hermes group structure in React Native 0.84+:
+     * - com.facebook.react:react-native → {reactGroup}:react-android:{reactVersion}
+     * - com.facebook.react:hermes-engine → {hermesGroup}:hermes-android:{hermesVersion}
+     * - com.facebook.react:hermes-android → {hermesGroup}:hermes-android:{hermesVersion}
+     *
+     * @param coordinates Dependency coordinate information
+     * @return List of triples (original coordinate, replacement coordinate, reason)
+     */
+    fun getDependencySubstitutions(coordinates: DependencyCoordinates): List<Triple<String, String, String>> {
+      val substitutions = mutableListOf<Triple<String, String, String>>()
+      val hermesVersion = coordinates.getEffectiveHermesVersion()
+      val hermesCoordinate = "${coordinates.hermesGroup}:$HERMES_ARTIFACT:$hermesVersion"
+
+      // 1. react-native -> react-android
+      substitutions.add(
+        Triple(
+          DEPRECATED_REACT_NATIVE,
+          "${coordinates.reactGroup}:$REACT_NATIVE_ARTIFACT:${coordinates.reactVersion}",
+          "The react-native artifact was deprecated in favor of react-android",
+        ),
+      )
+
+      // 2. hermes-engine -> hermes-android (new group)
+      substitutions.add(
+        Triple(
+          DEPRECATED_HERMES_ENGINE,
+          hermesCoordinate,
+          "The hermes-engine artifact was deprecated in favor of hermes-android",
+        ),
+      )
+
+      // 3. com.facebook.react:hermes-android → com.facebook.hermes:hermes-android (NEW!)
+      substitutions.add(
+        Triple(
+          DEPRECATED_HERMES_ANDROID,
+          hermesCoordinate,
+          "The hermes-android artifact was moved to com.facebook.hermes publishing group",
+        ),
+      )
+
+      // 4. Custom React group substitution
+      if (coordinates.reactGroup != DEFAULT_GROUP) {
+        substitutions.add(
+          Triple(
+            "$DEFAULT_GROUP:$REACT_NATIVE_ARTIFACT",
+            "${coordinates.reactGroup}:$REACT_NATIVE_ARTIFACT:${coordinates.reactVersion}",
+            "Modified to use correct Maven group",
+          ),
+        )
+      }
+
+      // 5. Custom Hermes group substitution
+      if (coordinates.hermesGroup != HERMES_GROUP) {
+        substitutions.add(
+          Triple(
+            "$HERMES_GROUP:$HERMES_ARTIFACT",
+            hermesCoordinate,
+            "Modified to use correct Maven group",
+          ),
+        )
+      }
+
+      return substitutions
+    }
+  }
+
+  /**
+   * Configures all required React Native dependencies.
+   *
+   * Called during project evaluation (afterEvaluate) to ensure configuration is complete.
+   */
+  fun configure() {
+    val reactNativeDir = extension.getReactNativeDirResolved()
+
+    // Read all coordinates (React + Hermes)
+    val coordinates = ReactNativeVersionReader.readCoordinates(reactNativeDir)
+    ReactNativeVersionReader.validateVersion(coordinates.reactVersion)
+
+    project.logger.lifecycle(
+      "Configuring React Native dependencies (version: ${coordinates.reactVersion}, " +
+        "hermes: ${coordinates.getEffectiveHermesVersion()}, " +
+        "hermesGroup: ${coordinates.hermesGroup})",
+    )
+
+    // Note: Dependency substitution is now handled by run.granite.rootproject plugin.
+    // See GraniteRootProjectPlugin for the centralized substitution logic.
+
+    // Add React Native core dependencies
+    addReactNativeDependencies(coordinates.reactVersion, coordinates.reactGroup)
+
+    // Add Hermes engine
+    addHermesDependency(coordinates)
+
+    // Add SoLoader (required for native library loading)
+    addSoLoaderDependency()
+  }
+
+  /**
+   * Adds React Native core dependencies.
+   */
+  private fun addReactNativeDependencies(version: String, group: String) {
+    project.dependencies.add(
+      "implementation",
+      "$group:$REACT_NATIVE_ARTIFACT:$version",
+    )
+
+    project.logger.debug("Added dependency: $group:$REACT_NATIVE_ARTIFACT:$version")
+  }
+
+  /**
+   * Adds Hermes JavaScript engine dependency (DependencyCoordinates version).
+   */
+  private fun addHermesDependency(coordinates: DependencyCoordinates) {
+    val hermesVersion = coordinates.getEffectiveHermesVersion()
+    project.dependencies.add(
+      "implementation",
+      "${coordinates.hermesGroup}:$HERMES_ARTIFACT:$hermesVersion",
+    )
+
+    project.logger.debug("Added dependency: ${coordinates.hermesGroup}:$HERMES_ARTIFACT:$hermesVersion")
+  }
+
+  /**
+   * Adds SoLoader dependency for native library loading.
+   */
+  private fun addSoLoaderDependency() {
+    project.dependencies.add(
+      "implementation",
+      "$SOLOADER_GROUP:$SOLOADER_ARTIFACT:$SOLOADER_VERSION",
+    )
+
+    project.logger.debug("Added dependency: $SOLOADER_GROUP:$SOLOADER_ARTIFACT:$SOLOADER_VERSION")
+  }
+}