diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/scripting/internal/ScriptingGradleSubplugin.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/scripting/internal/ScriptingGradleSubplugin.kt
index a4321374692..428656a0060 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/scripting/internal/ScriptingGradleSubplugin.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/scripting/internal/ScriptingGradleSubplugin.kt
@@ -10,7 +10,6 @@ package org.jetbrains.kotlin.gradle.scripting.internal
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
-import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.artifacts.transform.InputArtifact
 import org.gradle.api.artifacts.transform.TransformAction
 import org.gradle.api.artifacts.transform.TransformOutputs
@@ -56,19 +55,23 @@ class ScriptingGradleSubplugin : Plugin<Project> {
             val javaPluginConvention = project.convention.findPlugin(JavaPluginConvention::class.java)
             if (javaPluginConvention?.sourceSets?.isEmpty() == false) {
 
-                val configureAction: (KotlinCompile) -> (Unit) = ca@{ task ->
+                val configureAction: (KotlinCompile) -> (Unit) = { task ->
 
                     if (task !is KaptGenerateStubsTask) {
-                        val sourceSetName = task.sourceSetName.orNull ?: return@ca
-                        val discoveryResultsConfigurationName = getDiscoveryResultsConfigurationName(sourceSetName)
-                        val discoveryResultConfiguration = project.configurations.findByName(discoveryResultsConfigurationName)
-                        if (discoveryResultConfiguration == null) {
-                            project.logger.warn(
-                                "$SCRIPTING_LOG_PREFIX $project.${task.name} - configuration not found:" +
-                                        " $discoveryResultsConfigurationName, $MISCONFIGURATION_MESSAGE_SUFFIX"
-                            )
-                        } else {
-                            task.scriptDefinitions.from(discoveryResultConfiguration)
+
+                        try {
+                            val discoveryClasspathConfigurationName = getDiscoveryClasspathConfigurationName(task.sourceSetName.get())
+                            val discoveryClasspathConfiguration = project.configurations.findByName(discoveryClasspathConfigurationName)
+                            when {
+                                discoveryClasspathConfiguration == null ->
+                                    project.logger.warn("$SCRIPTING_LOG_PREFIX $project.${task.name} - configuration not found: $discoveryClasspathConfigurationName, $MISCONFIGURATION_MESSAGE_SUFFIX")
+                                discoveryClasspathConfiguration.allDependencies.isEmpty() -> {
+                                    // skip further checks - user did not configured any discovery sources
+                                }
+                                else -> task.scriptDefinitions.from(discoveryClasspathConfiguration)
+                            }
+                        } catch (e: IllegalStateException) {
+                            project.logger.warn("$SCRIPTING_LOG_PREFIX applied in the non-supported environment (error received: ${e.message})")
                         }
                     }
                 }
@@ -103,11 +106,15 @@ private fun configureDiscoveryTransformation(
 ) {
     project.configurations.maybeCreate(discoveryResultsConfigurationName).apply {
         isCanBeConsumed = false
-        isCanBeResolved = true
-        attributes.attribute(artifactType, scriptFilesExtensions)
-        extendsFrom(discoveryConfiguration)
     }
-    project.dependencies.registerOnceDiscoverScriptExtensionsTransform()
+    project.dependencies.apply {
+        add(
+            discoveryResultsConfigurationName,
+            project.withRegisteredDiscoverScriptExtensionsTransform {
+                discoveryConfiguration.discoverScriptExtensionsFiles()
+            }
+        )
+    }
 }
 
 internal abstract class DiscoverScriptExtensionsTransformAction : TransformAction<TransformParameters.None> {
@@ -129,32 +136,36 @@ internal abstract class DiscoverScriptExtensionsTransformAction : TransformActio
         if (extensions.isNotEmpty()) {
             val outputFile = outputs.file("${input.nameWithoutExtension}.discoveredScriptsExtensions.txt")
             outputFile.writeText(extensions.joinToString("\n"))
+            listOf(outputFile)
         }
     }
 }
 
-private fun DependencyHandler.registerDiscoverScriptExtensionsTransform() {
-    registerTransform(DiscoverScriptExtensionsTransformAction::class.java) { transformSpec ->
-        transformSpec.from.attribute(artifactType, "jar")
-        transformSpec.to.attribute(artifactType, scriptFilesExtensions)
-    }
+private fun Project.registerDiscoverScriptExtensionsTransform() {
+    dependencies.apply {
+        registerTransform(DiscoverScriptExtensionsTransformAction::class.java) { transformSpec ->
+            transformSpec.from.attribute(artifactType, "jar")
+            transformSpec.to.attribute(artifactType, scriptFilesExtensions)
 
-    registerTransform(DiscoverScriptExtensionsTransformAction::class.java) { transformSpec ->
-        transformSpec.from.attribute(artifactType, "classes")
-        transformSpec.to.attribute(artifactType, scriptFilesExtensions)
+        }
+        registerTransform(DiscoverScriptExtensionsTransformAction::class.java) { transformSpec ->
+            transformSpec.from.attribute(artifactType, "classes")
+            transformSpec.to.attribute(artifactType, scriptFilesExtensions)
+        }
     }
 }
 
-private fun DependencyHandler.registerOnceDiscoverScriptExtensionsTransform() {
-    if (!extensions.extraProperties.has("DiscoverScriptExtensionsTransform")) {
+private fun <T> Project.withRegisteredDiscoverScriptExtensionsTransform(block: () -> T): T {
+    if (!project.extensions.extraProperties.has("DiscoverScriptExtensionsTransform")) {
         registerDiscoverScriptExtensionsTransform()
-        extensions.extraProperties["DiscoverScriptExtensionsTransform"] = true
+        project.extensions.extraProperties["DiscoverScriptExtensionsTransform"] = true
     }
+    return block()
 }
 
 private val artifactType = Attribute.of("artifactType", String::class.java)
 
-private const val scriptFilesExtensions = "script-files-extensions"
+private val scriptFilesExtensions = "script-files-extensions"
 
 private fun Configuration.discoverScriptExtensionsFiles() =
     incoming.artifactView {