@depup/react-native-worklets 0.11.3-depup.0

package/README.md

@@ -0,0 +1,43 @@
+# @depup/react-native-worklets
+
+> Dependency-bumped version of [react-native-worklets](https://www.npmjs.com/package/react-native-worklets)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/react-native-worklets
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [react-native-worklets](https://www.npmjs.com/package/react-native-worklets) @ 0.11.3 |
+| Processed | 2026-07-26 |
+| Smoke test | failed |
+| Deps updated | 13 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @babel/generator | ^7.27.1 | ^8.0.0 |
+| @babel/plugin-transform-arrow-functions | ^7.27.1 | ^8.0.1 |
+| @babel/plugin-transform-class-properties | ^7.28.6 | ^8.0.1 |
+| @babel/plugin-transform-classes | ^7.28.6 | ^8.0.1 |
+| @babel/plugin-transform-nullish-coalescing-operator | ^7.28.6 | ^8.0.1 |
+| @babel/plugin-transform-optional-chaining | ^7.28.6 | ^8.0.1 |
+| @babel/plugin-transform-shorthand-properties | ^7.27.1 | ^8.0.1 |
+| @babel/plugin-transform-template-literals | ^7.27.1 | ^8.0.1 |
+| @babel/plugin-transform-unicode-regex | ^7.27.1 | ^8.0.1 |
+| @babel/preset-typescript | ^7.28.5 | ^8.0.1 |
+| @babel/traverse | ^7.27.1 | ^8.0.4 |
+| @babel/types | ^7.27.1 | ^8.0.4 |
+| semver | ^7.7.4 | ^7.8.5 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/react-native-worklets
+
+License inherited from the original package.

package/RNWorklets.podspec

@@ -0,0 +1,94 @@
+require "json"
+require_relative './scripts/worklets_utils'
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+worklets_config = WorkletsUtils.find_config()
+WorkletsUtils.assert_minimal_react_native_version(worklets_config)
+
+ios_min_version = '13.4'
+
+# Directory in which data for further processing for clangd will be stored.
+compilation_metadata_dir = "CompilationDatabase"
+# We want generate the metadata only within the monorepo of Reanimated.
+compilation_metadata_generation_flag = worklets_config[:is_reanimated_example_app] ? "-gen-cdb-fragment-path #{compilation_metadata_dir}" : ''
+
+
+feature_flags = worklets_config[:feature_flags_flag]
+version_flag = "-DWORKLETS_VERSION=#{package['version']}"
+worklets_profiling_flag = ENV['IS_WORKLETS_PROFILING'] ? '-DWORKLETS_PROFILING' : ''
+fetch_preview_flag = worklets_config[:fetch_preview_flag]
+hermes_v1_flag = ENV['RCT_HERMES_V1_ENABLED'] == '1' ? '-DHERMES_V1_ENABLED' : ''
+
+# React Native doesn't expose these flags, but not having them
+# can lead to runtime errors due to ABI mismatches.
+# There's also
+#   HERMESVM_PROFILER_OPCODE
+#   HERMESVM_PROFILER_BB
+# which shouldn't be defined in standard setups.
+hermes_debug_hidden_flags = 'HERMES_ENABLE_DEBUGGER=1'
+
+Pod::Spec.new do |s|
+  s.name         = "RNWorklets"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/software-mansion/react-native-reanimated"
+  s.license      = package["license"]
+  s.authors      = { "author" => "author@domain.com" }
+  s.platforms    = { :ios => ios_min_version, :tvos => "9.0", :osx => "10.14", :visionos => "1.0" }
+  s.source       = { :git => "https://github.com/software-mansion/react-native-reanimated.git", :tag => "#{s.version}" }
+
+  s.header_dir = "worklets"
+
+  s.subspec "common" do |ss|
+    ss.source_files = "Common/cpp/worklets/**/*.{cpp,h}"
+    ss.public_header_files = "Common/cpp/worklets/**/*.h"
+    ss.header_mappings_dir = "Common/cpp/worklets"
+  end
+
+  s.subspec "apple" do |ss|
+    ss.source_files = "apple/worklets/**/*.{mm,h,m}"
+    ss.public_header_files = "apple/worklets/**/*.h"
+    ss.header_mappings_dir = "apple/worklets"
+  end
+
+  # Use install_modules_dependencies helper to install the dependencies.
+  # See https://github.com/facebook/react-native/blob/c925872e72d2422be46670777bfa2111e13c9e4c/packages/react-native/scripts/cocoapods/new_architecture.rb#L71.
+  install_modules_dependencies(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-hermes'
+  s.pod_target_xcconfig = {
+    "USE_HEADERMAP" => "YES",
+    "DEFINES_MODULE" => "YES",
+    "HEADER_SEARCH_PATHS" => [
+      '"$(PODS_TARGET_SRCROOT)/ReactCommon"',
+      '"$(PODS_TARGET_SRCROOT)"',
+      '"$(PODS_ROOT)/RCT-Folly"',
+      '"$(PODS_ROOT)/boost"',
+      '"$(PODS_ROOT)/boost-for-react-native"',
+      '"$(PODS_ROOT)/DoubleConversion"',
+      '"$(PODS_ROOT)/Headers/Private/React-Core"',
+      '"$(PODS_ROOT)/Headers/Private/Yoga"',
+      '"$(PODS_CONFIGURATION_BUILD_DIR)/React-utils/React_utils.framework/Headers/react/utils/platform/ios"',
+    ].join(' '),
+    "FRAMEWORK_SEARCH_PATHS" => '"${PODS_CONFIGURATION_BUILD_DIR}/React-hermes"',
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => "$(inherited) #{hermes_debug_hidden_flags}",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => "$(inherited)",
+    "OTHER_CFLAGS" => "$(inherited) #{feature_flags} #{version_flag} #{compilation_metadata_generation_flag} #{worklets_profiling_flag} #{fetch_preview_flag} #{hermes_v1_flag}",
+  }
+  s.xcconfig = {
+    "HEADER_SEARCH_PATHS" => [
+      '"$(PODS_ROOT)/boost"',
+      '"$(PODS_ROOT)/boost-for-react-native"',
+      '"$(PODS_ROOT)/glog"',
+      '"$(PODS_ROOT)/RCT-Folly"',
+      '"$(PODS_ROOT)/Headers/Public/React-hermes"',
+      '"$(PODS_ROOT)/Headers/Public/hermes-engine"',
+      # for static frameworks
+      "\"$(PODS_ROOT)/#{worklets_config[:react_native_common_dir]}\"",
+      "\"$(PODS_ROOT)/#{worklets_config[:react_native_common_dir]}/jsitooling\"",
+    ].join(' '),
+  }
+  
+end

package/android/CMakeLists.txt

@@ -0,0 +1,108 @@
+project(Worklets)
+cmake_minimum_required(VERSION 3.16)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+set(CMAKE_CXX_STANDARD 20)
+
+# Consume shared libraries and headers from prefabs
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(hermes-engine REQUIRED CONFIG)
+
+# default CMAKE_CXX_FLAGS: "-g -DANDROID -fdata-sections -ffunction-sections
+# -funwind-tables -fstack-protector-strong -no-canonical-prefixes
+# -D_FORTIFY_SOURCE=2 -Wformat -Werror=format-security -fstack-protector-all"
+include("${REACT_NATIVE_DIR}/ReactAndroid/cmake-utils/folly-flags.cmake")
+add_compile_options(${folly_FLAGS})
+
+string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_VERSION=${WORKLETS_VERSION}\
+    -DWORKLETS_FEATURE_FLAGS=\"${WORKLETS_FEATURE_FLAGS}\"")
+
+# HERMES_V1_ENABLED is centralized in react-native-flags.cmake for RN >= 84.
+# Only define manually for older versions to avoid macro redefinition error.
+if(ReactAndroid_VERSION_MINOR LESS 84)
+  string(APPEND CMAKE_CXX_FLAGS " -DHERMES_V1_ENABLED=${HERMES_V1_ENABLED}")
+else()
+  # Reference the value so CMake records it as used, otherwise it warns:
+  # "Manually-specified variables were not used by the project:
+  # HERMES_V1_ENABLED"
+  set(HERMES_V1_ENABLED "${HERMES_V1_ENABLED}")
+endif()
+
+string(APPEND CMAKE_CXX_FLAGS " -fno-omit-frame-pointer -fstack-protector-all")
+
+if(${WORKLETS_PROFILING})
+  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_PROFILING")
+endif()
+if(${IS_REANIMATED_EXAMPLE_APP})
+  string(APPEND CMAKE_CXX_FLAGS " -DIS_REANIMATED_EXAMPLE_APP -Wpedantic")
+endif()
+if(${WORKLETS_FETCH_PREVIEW_ENABLED})
+  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_FETCH_PREVIEW_ENABLED")
+endif()
+
+if(NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug")
+  string(APPEND CMAKE_CXX_FLAGS " -DNDEBUG")
+endif()
+
+set(BUILD_DIR "${CMAKE_SOURCE_DIR}/build")
+set(ANDROID_CPP_DIR "${CMAKE_SOURCE_DIR}/src/main/cpp")
+set(COMMON_CPP_DIR "${CMAKE_SOURCE_DIR}/../Common/cpp")
+
+file(GLOB_RECURSE WORKLETS_COMMON_CPP_SOURCES CONFIGURE_DEPENDS
+     "${COMMON_CPP_DIR}/worklets/*.cpp")
+file(GLOB_RECURSE WORKLETS_ANDROID_CPP_SOURCES CONFIGURE_DEPENDS
+     "${ANDROID_CPP_DIR}/worklets/*.cpp")
+
+add_library(worklets SHARED ${WORKLETS_COMMON_CPP_SOURCES}
+                            ${WORKLETS_ANDROID_CPP_SOURCES})
+
+target_precompile_headers(worklets PRIVATE "${ANDROID_CPP_DIR}/WorkletsPCH.h")
+
+# Stop Clang from embedding a build timestamp in the .pch. Without this the PCH
+# is non-reproducible across builds, so ccache can't reuse it and translation
+# units reject a restored PCH as "modified since built".
+target_compile_options(
+  worklets PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-Xclang;-fno-pch-timestamp>")
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
+  include(
+    "${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
+  target_compile_reactnative_options(worklets PUBLIC)
+else()
+  string(APPEND CMAKE_CXX_FLAGS
+         " -fexceptions -frtti -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
+endif()
+
+# includes
+target_include_directories(worklets PUBLIC "${COMMON_CPP_DIR}"
+                                           "${ANDROID_CPP_DIR}")
+
+target_include_directories(
+  worklets
+  PRIVATE "${REACT_NATIVE_DIR}/ReactCommon"
+          "${REACT_NATIVE_DIR}/ReactCommon/yoga"
+          "${REACT_NATIVE_DIR}/ReactAndroid/src/main/jni/react/turbomodule"
+          "${REACT_NATIVE_DIR}/ReactCommon/react/nativemodule/core/ReactCommon"
+          "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+          "${REACT_NATIVE_DIR}/ReactCommon/runtimeexecutor"
+          "${REACT_NATIVE_DIR}/ReactCommon/jsiexecutor"
+          "${REACT_NATIVE_DIR}/ReactCommon/react/renderer/graphics/platform/cxx"
+)
+
+# build shared lib
+set_target_properties(worklets PROPERTIES LINKER_LANGUAGE CXX)
+
+target_link_libraries(worklets android log ReactAndroid::reactnative
+                      ReactAndroid::jsi fbjni::fbjni)
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 82)
+  target_link_libraries(worklets hermes-engine::hermesvm)
+else()
+  target_link_libraries(worklets hermes-engine::libhermes)
+endif()
+
+if(${HERMES_ENABLE_DEBUGGER})
+  string(APPEND CMAKE_CXX_FLAGS " -DHERMES_ENABLE_DEBUGGER=1")
+endif()

package/android/build.gradle.kts

@@ -0,0 +1,369 @@
+import groovy.json.JsonSlurper
+import org.apache.tools.ant.taskdefs.condition.Os
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import java.util.Properties
+import javax.inject.Inject
+
+plugins {
+    id("com.android.library")
+    id("maven-publish")
+    id("com.diffplug.spotless") version "8.1.0"
+    id("org.jetbrains.kotlin.android")
+}
+
+fun safeExtGet(prop: String, fallback: Any?): Any? =
+    if (rootProject.extensions.extraProperties.has(prop)) rootProject.extensions.extraProperties.get(prop) else fallback
+
+fun safeAppExtGet(prop: String, fallback: Any?): Any? {
+    val appProject = rootProject.allprojects.find { it.plugins.hasPlugin("com.android.application") }
+    return if (appProject?.extensions?.extraProperties?.has(prop) == true)
+        appProject.extensions.extraProperties.get(prop)
+    else
+        fallback
+}
+
+fun resolveReactNativeDirectory(): File {
+    val reactNativeLocationProperty = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+    if (reactNativeLocationProperty != null) {
+        return when (reactNativeLocationProperty) {
+            is File -> reactNativeLocationProperty
+            is String -> file(reactNativeLocationProperty)
+            else -> file(reactNativeLocationProperty.toString())
+        }
+    }
+
+    // Fallback to node resolver for custom directory structures like monorepos.
+    val reactNativePackage = file(
+        providers.exec {
+            workingDir(rootDir)
+            commandLine("node", "--print", "require.resolve('react-native/package.json')")
+        }.standardOutput.asText.get().trim()
+    )
+    if (reactNativePackage.exists()) {
+        return reactNativePackage.parentFile
+    }
+
+    throw GradleException(
+        "[Worklets] Unable to resolve react-native location in node_modules. You should set project extension property (in `app/build.gradle`) named `REACT_NATIVE_NODE_MODULES_DIR` with the path to react-native in node_modules."
+    )
+}
+
+fun getReactNativeVersion(): String {
+    val reactNativeRootDir = resolveReactNativeDirectory()
+    val reactProperties = Properties()
+    file("$reactNativeRootDir/ReactAndroid/gradle.properties").inputStream().use { reactProperties.load(it) }
+    return reactProperties.getProperty("VERSION_NAME")
+}
+
+fun getReactNativeMinorVersion(): Int {
+    val reactNativeVersion = getReactNativeVersion()
+    return if (reactNativeVersion.startsWith("0.0.0-")) 1000 else reactNativeVersion.split(".")[1].toInt()
+}
+
+fun getHermesV1Enabled(): Boolean {
+    // Even though `HERMES_V1_ENABLED` is now centralized
+    // in `react-native-flags.cmake` for React Native >= 0.84
+    // that CMake file depends on definitions provided
+    // in local `externalNativeBuild` configuration of the LIBRARY.
+    // I hope this is only a temporary workaround.
+    return if (getReactNativeMinorVersion() >= 84) {
+        safeAppExtGet("hermesV1Enabled", true)?.toString()?.toBoolean() ?: true
+    } else {
+        safeAppExtGet("hermesV1Enabled", false)?.toString()?.toBoolean() ?: false
+    }
+}
+
+fun getWorkletsVersion(): String {
+    val inputFile = file("${projectDir.path}/../package.json")
+    val json = JsonSlurper().parseText(inputFile.readText()) as Map<*, *>
+    return json["version"]?.toString() ?: throw GradleException("[Worklets] Cannot find version in package.json")
+}
+
+fun toPlatformFileString(path: String): String {
+    var result = path
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        result = result.replace(File.separatorChar, '/')
+    }
+    return result
+}
+
+fun getStaticFeatureFlags(): Map<String, String> {
+    val featureFlags = HashMap<String, String>()
+
+    val staticFeatureFlagsFile = file("${projectDir.path}/../src/featureFlags/staticFlags.json")
+    if (!staticFeatureFlagsFile.exists()) {
+        throw GradleException("[Worklets] Feature flags file not found at ${staticFeatureFlagsFile.absolutePath}.")
+    }
+    (JsonSlurper().parseText(staticFeatureFlagsFile.readText()) as Map<*, *>).forEach { (key, value) ->
+        featureFlags[key.toString()] = value.toString()
+    }
+
+    val packageJsonFile = file("${rootDir.path}/../package.json")
+    if (packageJsonFile.exists()) {
+        val packageJson = JsonSlurper().parseText(packageJsonFile.readText()) as Map<*, *>
+        (packageJson["worklets"] as? Map<*, *>)
+            ?.get("staticFeatureFlags")
+            ?.let { it as? Map<*, *> }
+            ?.forEach { (key, value) -> featureFlags[key.toString()] = value.toString() }
+    }
+
+    return featureFlags
+}
+
+fun getStaticFeatureFlagsString(featureFlags: Map<String, String>): String =
+    featureFlags.entries.joinToString("") { (key, value) -> "[$key:$value]" }
+
+fun isFlagEnabled(featureFlags: Map<String, String>, flagName: String): Boolean =
+    featureFlags.containsKey(flagName) && featureFlags[flagName] == "true"
+
+if (project != rootProject) {
+    apply(plugin = "com.facebook.react")
+}
+
+val featureFlags = getStaticFeatureFlags()
+
+val packageDir: File = project.projectDir.parentFile
+val reactNativeRootDir: File = resolveReactNativeDirectory()
+val REACT_NATIVE_VERSION: String = getReactNativeVersion()
+val WORKLETS_VERSION: String = getWorkletsVersion()
+val IS_REANIMATED_EXAMPLE_APP: Boolean = safeAppExtGet("isReanimatedExampleApp", false)?.toString()?.toBoolean() ?: false
+val FETCH_PREVIEW_ENABLED: Boolean = isFlagEnabled(featureFlags, "FETCH_PREVIEW_ENABLED")
+val WORKLETS_FEATURE_FLAGS: String = getStaticFeatureFlagsString(featureFlags)
+val HERMES_V1_ENABLED: Boolean = getHermesV1Enabled()
+val WORKLETS_PROFILING: Boolean = safeAppExtGet("enableWorkletsProfiling", false)?.toString()?.toBoolean() ?: false
+
+// Set version for prefab
+version = WORKLETS_VERSION
+
+val workletsPrefabHeadersDir: File = project.file("${layout.buildDirectory.get().asFile.absolutePath}/prefab-headers/worklets")
+
+fun reactNativeArchitectures(): List<String> {
+    val value = project.findProperty("reactNativeArchitectures") as String?
+    return value?.split(",")
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        ?.ifEmpty { null }
+        ?: listOf("armeabi-v7a", "x86", "x86_64", "arm64-v8a")
+}
+
+if (project == rootProject) {
+    spotless {
+        kotlin {
+            target("src/**/*.kt")
+            ktlint()
+        }
+    }
+}
+
+apply(from = "./fix-prefab.gradle.kts")
+apply(from = "./generate-stub-pch.gradle.kts")
+
+android {
+    compileSdk = safeExtGet("compileSdkVersion", 36) as Int
+
+    namespace = "com.swmansion.worklets"
+
+    val resolvedNdkPath = rootProject.findProperty("ndkPath") as? String
+    if (!resolvedNdkPath.isNullOrEmpty()) {
+        ndkPath = resolvedNdkPath
+    }
+
+    val resolvedNdkVersion = rootProject.findProperty("ndkVersion") as? String
+    if (!resolvedNdkVersion.isNullOrEmpty()) {
+        ndkVersion = resolvedNdkVersion
+    }
+
+    buildFeatures {
+        prefab = true
+        prefabPublishing = true
+        buildConfig = true
+    }
+
+    prefab {
+        create("worklets") {
+            headers = workletsPrefabHeadersDir.absolutePath
+        }
+    }
+
+    defaultConfig {
+        minSdk = safeExtGet("minSdkVersion", 24) as Int
+        testOptions.targetSdk = safeExtGet("targetSdkVersion", 36) as Int
+        lint.targetSdk = safeExtGet("targetSdkVersion", 36) as Int
+
+        buildConfigField("boolean", "WORKLETS_PROFILING", WORKLETS_PROFILING.toString())
+        buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
+        buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
+
+        @Suppress("UnstableApiUsage")
+        externalNativeBuild {
+            cmake {
+                arguments(
+                    "-DANDROID_STL=c++_shared",
+                    "-DANDROID_TOOLCHAIN=clang",
+                    "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
+                    "-DIS_REANIMATED_EXAMPLE_APP=$IS_REANIMATED_EXAMPLE_APP",
+                    "-DWORKLETS_FETCH_PREVIEW_ENABLED=$FETCH_PREVIEW_ENABLED",
+                    "-DWORKLETS_PROFILING=$WORKLETS_PROFILING",
+                    "-DWORKLETS_VERSION=$WORKLETS_VERSION",
+                    "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
+                    "-DWORKLETS_FEATURE_FLAGS=$WORKLETS_FEATURE_FLAGS",
+                    "-DHERMES_V1_ENABLED=$HERMES_V1_ENABLED"
+                )
+                abiFilters.addAll(reactNativeArchitectures())
+                targets("worklets")
+            }
+        }
+
+        consumerProguardFiles("proguard-rules.pro")
+    }
+
+    externalNativeBuild {
+        cmake {
+            path = file("CMakeLists.txt")
+        }
+    }
+
+    buildTypes {
+        debug {
+            @Suppress("UnstableApiUsage")
+            externalNativeBuild {
+                cmake {
+                    //  React Native doesn't expose these flags, but not having them
+                    //  can lead to runtime errors due to ABI mismatches.
+                    //  There's also
+                    //    HERMESVM_PROFILER_OPCODE
+                    //    HERMESVM_PROFILER_BB
+                    //  which shouldn't be defined in standard setups.
+                    arguments("-DHERMES_ENABLE_DEBUGGER=1")
+                }
+            }
+        }
+    }
+
+    lint {
+        abortOnError = false
+    }
+
+    packaging {
+        // For some reason gradle only complains about the duplicated version of librrc_root and libreact_render libraries
+        // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
+        // only the ones that make the build fail (ideally we should only include libworklets but we
+        // are only allowed to specify exclude patterns)
+        resources {
+            excludes += setOf(
+                "META-INF",
+                "META-INF/**",
+            )
+        }
+        jniLibs {
+            excludes += setOf(
+                "**/libc++_shared.so",
+                "**/libfbjni.so",
+                "**/libjsi.so",
+                "**/libhermes.so",
+                "**/libhermesvm.so",
+                "**/libreactnative.so",
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    sourceSets {
+        getByName("main") {
+            java {
+                if (FETCH_PREVIEW_ENABLED) {
+                    srcDir("src/networking")
+                } else {
+                    srcDir("src/no-networking")
+                }
+            }
+        }
+    }
+
+    if (IS_REANIMATED_EXAMPLE_APP) {
+        apply(from = "../../../scripts/llvm-tools/android-hook.gradle.kts")
+    }
+}
+
+if (project != rootProject) {
+    kotlin {
+        compilerOptions {
+            jvmTarget = JvmTarget.fromTarget("17")
+        }
+    }
+}
+
+androidComponents {
+    onVariants(selector().withBuildType("debug")) {
+        it.packaging.jniLibs.keepDebugSymbols.add("**/**/*.so")
+    }
+}
+
+val validateReactNativeVersionResult = providers.exec {
+    workingDir(projectDir.path)
+    commandLine("node", "./../scripts/validate-react-native-version.js", REACT_NATIVE_VERSION)
+    isIgnoreExitValue = true
+}
+
+tasks.register("assertMinimalReactNativeVersionTask") {
+    val result = validateReactNativeVersionResult
+    doFirst {
+        if (result.result.get().exitValue != 0) {
+            throw GradleException(result.standardError.asText.get().trim())
+        }
+    }
+}
+
+tasks.named("preBuild") { dependsOn("assertMinimalReactNativeVersionTask") }
+
+// Workaround for AGP 9 + Kotlin 2.x lint K2 UAST crash on .gradle.kts build scripts.
+// See: https://issuetracker.google.com/issues/432144179
+tasks.configureEach { if (name.startsWith("lintVital")) enabled = false }
+
+tasks.register<Copy>("prepareWorkletsHeadersForPrefabs") {
+    from("$projectDir/src/main/cpp")
+    from("$projectDir/../Common/cpp")
+    include("worklets/**/*.h")
+    into(workletsPrefabHeadersDir.absolutePath)
+}
+
+interface FSService {
+    @get:Inject
+    val fs: FileSystemOperations
+}
+
+tasks.register("cleanCMakeCache") {
+    val fsProvider = project.objects.newInstance<FSService>()
+    val cxxDir = file("${projectDir}/.cxx")
+    doFirst {
+        fsProvider.fs.delete {
+            delete(cxxDir)
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    "implementation"("com.facebook.yoga:proguard-annotations:1.19.0")
+    "implementation"("androidx.transition:transition:1.6.0")
+    "implementation"("androidx.core:core:1.15.0")
+    "implementation"("com.facebook.react:react-android") // version substituted by RNGP
+    "implementation"("androidx.core:core-ktx:1.17.0")
+    "implementation"("com.facebook.react:hermes-android") // version substituted by RNGP
+}
+
+tasks.named("preBuild") { dependsOn("prepareWorkletsHeadersForPrefabs") }
+
+afterEvaluate {
+    tasks.named("clean") {
+        finalizedBy("cleanCMakeCache")
+    }
+}

package/android/fix-prefab.gradle.kts

@@ -0,0 +1,56 @@
+fun reactNativeArchitectures(): List<String> {
+    val value = project.findProperty("reactNativeArchitectures") as String?
+    return value?.split(",")
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        ?.ifEmpty { null }
+        ?: listOf("armeabi-v7a", "x86", "x86_64", "arm64-v8a")
+}
+
+tasks.configureEach {
+    // Make sure that we generate our prefab publication file only after having built the native library
+    // so that not a header publication file, but a full configuration publication will be generated, which
+    // will include the .so file
+    val prefabConfigurePattern = Regex("^prefab(.+)ConfigurePackage$")
+    val matchResult = prefabConfigurePattern.matchEntire(name)
+    if (matchResult != null) {
+        val variantName = matchResult.groupValues[1]
+        outputs.upToDateWhen { false }
+        dependsOn("externalNativeBuild$variantName")
+    }
+}
+
+afterEvaluate {
+    val abis = reactNativeArchitectures()
+    rootProject.allprojects.forEach { proj ->
+        if (proj === rootProject) {
+            return@forEach
+        }
+
+        val dependsOnThisLib = proj.configurations.any { config ->
+            config.dependencies.any { dep ->
+                dep.group == project.group && dep.name == project.name
+            }
+        }
+        if (!dependsOnThisLib && proj != project) return@forEach
+
+        if (!proj.plugins.hasPlugin("com.android.application") && !proj.plugins.hasPlugin("com.android.library")) {
+            return@forEach
+        }
+
+        // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+        // generate a libnameConfig.cmake file that will contain our native library (.so).
+        // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+        val cxxDir = File(proj.projectDir, ".cxx")
+        if (!cxxDir.exists()) return@forEach
+        cxxDir.listFiles { dir -> dir.isDirectory }?.forEach { variantDir ->
+            val randomDirs = variantDir.listFiles { dir -> dir.isDirectory }
+            abis.forEach { abi ->
+                randomDirs?.forEach { randomDir ->
+                    val prefabFile = File(randomDir, "$abi/prefab_config.json")
+                    if (prefabFile.exists()) prefabFile.setLastModified(System.currentTimeMillis())
+                }
+            }
+        }
+    }
+}