diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/common/script/KotlinScriptExternalImportsProviderImpl.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/common/script/KotlinScriptExternalImportsProviderImpl.kt
index 5aed9363c2f..2e2512aaa50 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/common/script/KotlinScriptExternalImportsProviderImpl.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/common/script/KotlinScriptExternalImportsProviderImpl.kt
@@ -26,7 +26,7 @@ import java.io.File
 import java.util.concurrent.locks.ReentrantReadWriteLock
 import kotlin.concurrent.read
 import kotlin.concurrent.write
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
+import kotlin.script.dependencies.ScriptDependencies
 
 class KotlinScriptExternalImportsProviderImpl(
         val project: Project,
@@ -34,13 +34,13 @@ class KotlinScriptExternalImportsProviderImpl(
 ) : KotlinScriptExternalImportsProviderBase(project) {
 
     private val cacheLock = ReentrantReadWriteLock()
-    private val cache = hashMapOf<String, KotlinScriptExternalDependencies?>()
+    private val cache = hashMapOf<String, ScriptDependencies?>()
 
-    override fun getScriptDependencies(file: VirtualFile): KotlinScriptExternalDependencies? = cacheLock.read {
+    override fun getScriptDependencies(file: VirtualFile): ScriptDependencies? = cacheLock.read {
         calculateExternalDependencies(file)
     }
 
-    private fun calculateExternalDependencies(file: VirtualFile): KotlinScriptExternalDependencies? {
+    private fun calculateExternalDependencies(file: VirtualFile): ScriptDependencies? {
         val path = file.path
         val cached = cache[path]
         return if (cached != null) cached
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/GenericCompilerState.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/GenericCompilerState.kt
index 4eb7d3a863f..758d9138c79 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/GenericCompilerState.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/GenericCompilerState.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.cli.jvm.repl.messages.DiagnosticMessageHolder
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.psi.KtFile
 import java.util.concurrent.locks.ReentrantReadWriteLock
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
+import kotlin.script.dependencies.ScriptDependencies
 
 class ReplCompilerStageHistory(private val state: GenericReplCompilerState) : BasicReplStageHistory<ScriptDescriptor>(state.lock) {
 
@@ -70,5 +70,5 @@ class GenericReplCompilerState(environment: KotlinCoreEnvironment, override val
 
     val analyzerEngine = ReplCodeAnalyzer(environment)
 
-    var lastDependencies: KotlinScriptExternalDependencies? = null
+    var lastDependencies: ScriptDependencies? = null
 }
diff --git a/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptDefinitionFromAnnotatedTemplate.kt b/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptDefinitionFromAnnotatedTemplate.kt
index 832bb702223..6258d66cd57 100644
--- a/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptDefinitionFromAnnotatedTemplate.kt
+++ b/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptDefinitionFromAnnotatedTemplate.kt
@@ -17,8 +17,6 @@
 package org.jetbrains.kotlin.script
 
 import com.intellij.openapi.diagnostic.Logger
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.NameUtils
 import org.jetbrains.kotlin.psi.KtScript
@@ -28,15 +26,13 @@ import kotlin.reflect.KFunction
 import kotlin.reflect.KParameter
 import kotlin.reflect.full.memberFunctions
 import kotlin.reflect.full.primaryConstructor
-import kotlin.script.dependencies.BasicScriptDependenciesResolver
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
-import kotlin.script.dependencies.ScriptContents
+import kotlin.script.dependencies.DependenciesResolver
 import kotlin.script.dependencies.ScriptDependenciesResolver
 import kotlin.script.templates.AcceptedAnnotations
 
 open class KotlinScriptDefinitionFromAnnotatedTemplate(
         template: KClass<out Any>,
-        providedResolver: ScriptDependenciesResolver? = null,
+        providedResolver: DependenciesResolver? = null,
         providedScriptFilePattern: String? = null,
         val environment: Map<String, Any?>? = null
 ) : KotlinScriptDefinition(template) {
@@ -48,38 +44,45 @@ open class KotlinScriptDefinitionFromAnnotatedTemplate(
         ?: DEFAULT_SCRIPT_FILE_PATTERN
     }
 
-    override val dependencyResolver: ScriptDependenciesResolver by lazy {
+    override val dependencyResolver: DependenciesResolver by lazy {
+        computeResolver(template, providedResolver)
+    }
+
+    private fun computeResolver(
+            template: KClass<out Any>,
+            providedResolver: DependenciesResolver?
+    ): @Suppress("DEPRECATION") DependenciesResolver {
         val defAnn by lazy { takeUnlessError { template.annotations.firstIsInstanceOrNull<kotlin.script.templates.ScriptTemplateDefinition>() } }
-        val legacyDefAnn by lazy { takeUnlessError { template.annotations.firstIsInstanceOrNull<org.jetbrains.kotlin.script.ScriptTemplateDefinition>() } }
-        when {
-            providedResolver != null -> providedResolver
-            // TODO: logScriptDefMessage missing or invalid constructor
-            defAnn != null ->
-                try {
-                    defAnn.resolver.primaryConstructor?.call() ?: null.apply {
-                        log.warn("[kts] No default constructor found for ${defAnn.resolver.qualifiedName}")
-                    }
-                }
-                catch (ex: ClassCastException) {
-                    log.warn("[kts] Script def error ${ex.message}")
-                    null
-                }
-            legacyDefAnn != null ->
-                try {
-                    log.warn("[kts] Deprecated annotations on the script template are used, please update the provider")
-                    legacyDefAnn.resolver.primaryConstructor?.call()?.let {
-                        LegacyScriptDependenciesResolverWrapper(it)
-                    }
-                    ?: null.apply {
-                        log.warn("[kts] No default constructor found for ${legacyDefAnn.resolver.qualifiedName}")
-                    }
-                }
-                catch (ex: ClassCastException) {
-                    log.warn("[kts] Script def error ${ex.message}")
-                    null
-                }
-            else -> null
-        } ?: BasicScriptDependenciesResolver()
+        val legacyDefAnn by lazy { takeUnlessError { template.annotations.firstIsInstanceOrNull<ScriptTemplateDefinition>() } }
+        return when {
+                   providedResolver != null -> providedResolver
+               // TODO: logScriptDefMessage missing or invalid constructor
+                   defAnn != null ->
+                       try {
+                           defAnn.resolver.primaryConstructor?.call() as? DependenciesResolver ?: null.apply {
+                               log.warn("[kts] No default constructor found for ${defAnn.resolver.qualifiedName}")
+                           }
+                       }
+                       catch (ex: ClassCastException) {
+                           log.warn("[kts] Script def error ${ex.message}")
+                           null
+                       }
+                   legacyDefAnn != null ->
+                       try {
+                           log.warn("[kts] Deprecated annotations on the script template are used, please update the provider")
+                           legacyDefAnn.resolver.primaryConstructor?.call()?.let {
+                               LegacyScriptDependenciesResolverWrapper(it)
+                           }
+                           ?: null.apply {
+                               log.warn("[kts] No default constructor found for ${legacyDefAnn.resolver.qualifiedName}")
+                           }
+                       }
+                       catch (ex: ClassCastException) {
+                           log.warn("[kts] Script def error ${ex.message}")
+                           null
+                       }
+                   else -> null
+               } ?: DependenciesResolver.NoDependencies
     }
 
     val samWithReceiverAnnotations: List<String>? by lazy {
@@ -116,8 +119,6 @@ open class KotlinScriptDefinitionFromAnnotatedTemplate(
     // TODO: implement other strategy - e.g. try to extract something from match with ScriptFilePattern
     override fun getScriptName(script: KtScript): Name = NameUtils.getScriptNameForFile(script.containingKtFile.name)
 
-    override fun getDependenciesFor(file: VirtualFile, project: Project, previousDependencies: KotlinScriptExternalDependencies?) = error("Should not be called")
-
     override fun toString(): String = "KotlinScriptDefinitionFromAnnotatedTemplate - ${template.simpleName}"
 
     override val annotationsForSamWithReceivers: List<String>
@@ -140,21 +141,4 @@ open class KotlinScriptDefinitionFromAnnotatedTemplate(
     companion object {
         internal val log = Logger.getInstance(KotlinScriptDefinitionFromAnnotatedTemplate::class.java)
     }
-}
-
-internal fun logScriptDefMessage(reportSeverity: ScriptDependenciesResolver.ReportSeverity, s: String, position: ScriptContents.Position?): Unit {
-    val msg = (position?.run { "[at $line:$col]" } ?: "") + s
-    when (reportSeverity) {
-        ScriptDependenciesResolver.ReportSeverity.ERROR -> KotlinScriptDefinitionFromAnnotatedTemplate.log.error(msg)
-        ScriptDependenciesResolver.ReportSeverity.WARNING -> KotlinScriptDefinitionFromAnnotatedTemplate.log.warn(msg)
-        ScriptDependenciesResolver.ReportSeverity.INFO -> KotlinScriptDefinitionFromAnnotatedTemplate.log.info(msg)
-        ScriptDependenciesResolver.ReportSeverity.DEBUG -> KotlinScriptDefinitionFromAnnotatedTemplate.log.debug(msg)
-    }
-}
-
-internal fun sameSignature(left: KFunction<*>, right: KFunction<*>): Boolean =
-        left.parameters.size == right.parameters.size &&
-        left.parameters.zip(right.parameters).all {
-            it.first.kind == KParameter.Kind.INSTANCE ||
-            it.first.type == it.second.type
-        }
+}
\ No newline at end of file
diff --git a/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProviderBase.kt b/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProviderBase.kt
index 2316c519611..2f6c19e3333 100644
--- a/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProviderBase.kt
+++ b/compiler/frontend.script/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProviderBase.kt
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.psi.KtAnnotationEntry
 import org.jetbrains.kotlin.psi.KtFile
 import java.io.File
 import kotlin.reflect.KClass
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
 import kotlin.script.dependencies.ScriptContents
+import kotlin.script.dependencies.ScriptDependencies
 
 abstract class KotlinScriptExternalImportsProviderBase(private val project: Project): KotlinScriptExternalImportsProvider {
     fun getScriptContents(scriptDefinition: KotlinScriptDefinition, file: VirtualFile)
@@ -58,16 +58,13 @@ abstract class KotlinScriptExternalImportsProviderBase(private val project: Proj
 
     fun resolveDependencies(
             scriptDef: KotlinScriptDefinition,
-            file: VirtualFile,
-            oldDependencies: KotlinScriptExternalDependencies? = null
-    ): KotlinScriptExternalDependencies? {
+            file: VirtualFile
+    ): ScriptDependencies? {
         val scriptContents = getScriptContents(scriptDef, file)
         return scriptDef.dependencyResolver.resolve(
                 scriptContents,
-                (scriptDef as? KotlinScriptDefinitionFromAnnotatedTemplate)?.environment,
-                { _, _, _ -> Unit }, // TODO_R:
-                oldDependencies
-        ).get()
+                (scriptDef as? KotlinScriptDefinitionFromAnnotatedTemplate)?.environment ?: emptyMap()
+        ).dependencies
     }
 }
 
diff --git a/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplate.kt b/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplate.kt
index b47d4199f74..d7fac8d0504 100644
--- a/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplate.kt
+++ b/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplate.kt
@@ -20,6 +20,9 @@ import java.io.File
 import java.util.concurrent.Future
 import java.util.concurrent.TimeUnit
 import kotlin.reflect.KClass
+import kotlin.script.dependencies.DependenciesResolver.ResolveResult
+import kotlin.script.dependencies.ScriptDependencies
+import kotlin.script.dependencies.ScriptReport
 
 const val DEFAULT_SCRIPT_FILE_PATTERN = ".*\\.kts"
 
@@ -115,41 +118,42 @@ private fun<T: Comparable<T>> compareIterables(a: Iterable<T>, b: Iterable<T>):
 
 private inline fun Int.chainCompare(compFn: () -> Int ): Int = if (this != 0) this else compFn()
 
-class LegacyScriptDependenciesResolverWrapper(val legacyResolver: ScriptDependenciesResolver) : kotlin.script.dependencies.ScriptDependenciesResolver {
+@Suppress("DEPRECATION")
+class LegacyScriptDependenciesResolverWrapper(val legacyResolver: ScriptDependenciesResolver) : kotlin.script.dependencies.DependenciesResolver {
 
-    override fun resolve(script: kotlin.script.dependencies.ScriptContents,
-                environment: Map<String, Any?>?,
-                report: (kotlin.script.dependencies.ScriptDependenciesResolver.ReportSeverity, String, kotlin.script.dependencies.ScriptContents.Position?) -> Unit,
-                previousDependencies: kotlin.script.dependencies.KotlinScriptExternalDependencies?
-    ): Future<kotlin.script.dependencies.KotlinScriptExternalDependencies?> {
+    override fun resolve(
+            scriptContents: kotlin.script.dependencies.ScriptContents,
+            environment: Map<String, Any?>
+    ): ResolveResult {
+        val reports = ArrayList<ScriptReport>()
         val legacyDeps = legacyResolver.resolve(
                 object : ScriptContents {
-                    override val file: File? get() = script.file
-                    override val annotations: Iterable<Annotation> get() = script.annotations
-                    override val text: CharSequence? get() = script.text
+                    override val file: File? get() = scriptContents.file
+                    override val annotations: Iterable<Annotation> get() = scriptContents.annotations
+                    override val text: CharSequence? get() = scriptContents.text
                 },
                 environment,
-                { sev, msg, pos -> report(kotlin.script.dependencies.ScriptDependenciesResolver.ReportSeverity.values()[sev.ordinal],
-                                          msg,
-                                          pos?.let { kotlin.script.dependencies.ScriptContents.Position(it.line, it.col) }) },
-                previousDependencies?.let {
-                    object : KotlinScriptExternalDependencies {
-                        override val javaHome get() = it.javaHome
-                        override val classpath get() = it.classpath
-                        override val imports get() = it.imports
-                        override val sources get() = it.sources
-                        override val scripts get() = it.scripts
-                    }
-                }
-        ).get()
-        return kotlin.script.dependencies.PseudoFuture(legacyDeps?.let {
-            object : kotlin.script.dependencies.KotlinScriptExternalDependencies {
-                override val javaHome get() = it.javaHome
-                override val classpath get() = it.classpath
-                override val imports get() = it.imports
-                override val sources get() = it.sources
-                override val scripts get() = it.scripts
-            }
-        })
+                { sev, msg, pos ->
+                    reports.add(ScriptReport(msg, sev.convertSeverity(), pos?.convertPosition()))
+                }, null
+        ).get() ?: return ResolveResult.Failure()
+
+        val dependencies = ScriptDependencies(
+                javaHome = legacyDeps.javaHome?.let(::File),
+                classpath = legacyDeps.classpath.toList(),
+                imports = legacyDeps.imports.toList(),
+                sources = legacyDeps.sources.toList(),
+                scripts = legacyDeps.scripts.toList()
+        )
+        return ResolveResult.Success(dependencies, reports)
     }
+
+    private fun ScriptDependenciesResolver.ReportSeverity.convertSeverity(): ScriptReport.Severity  = when(this) {
+        ScriptDependenciesResolver.ReportSeverity.ERROR -> ScriptReport.Severity.ERROR
+        ScriptDependenciesResolver.ReportSeverity.WARNING -> ScriptReport.Severity.WARNING
+        ScriptDependenciesResolver.ReportSeverity.INFO -> ScriptReport.Severity.INFO
+        ScriptDependenciesResolver.ReportSeverity.DEBUG -> ScriptReport.Severity.DEBUG
+    }
+
+    private fun ScriptContents.Position.convertPosition(): ScriptReport.Position = ScriptReport.Position(line, col)
 }
\ No newline at end of file
diff --git a/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplateProviderExtensionPoint.kt b/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplateProviderExtensionPoint.kt
index 329874c9748..53a19720428 100644
--- a/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplateProviderExtensionPoint.kt
+++ b/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTemplateProviderExtensionPoint.kt
@@ -22,7 +22,7 @@ import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.project.Project
 import java.io.File
 import java.net.URLClassLoader
-import kotlin.script.dependencies.ScriptDependenciesResolver
+import kotlin.script.dependencies.DependenciesResolver
 
 interface ScriptTemplatesProvider {
 
@@ -38,7 +38,7 @@ interface ScriptTemplatesProvider {
 
     val templateClassNames: Iterable<String>
 
-    val resolver: ScriptDependenciesResolver? get() = null
+    val resolver: DependenciesResolver? get() = null
 
     val filePattern: String? get() = null
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptDefinition.kt b/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptDefinition.kt
index 11cd6d3d219..9c2d44b8259 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptDefinition.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptDefinition.kt
@@ -17,16 +17,13 @@
 package org.jetbrains.kotlin.script
 
 import com.intellij.openapi.fileTypes.LanguageFileType
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.NameUtils
 import org.jetbrains.kotlin.parsing.KotlinParserDefinition
 import org.jetbrains.kotlin.psi.KtScript
 import kotlin.reflect.KClass
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
-import kotlin.script.dependencies.ScriptDependenciesResolver
+import kotlin.script.dependencies.DependenciesResolver
 import kotlin.script.templates.standard.ScriptTemplateWithArgs
 
 open class KotlinScriptDefinition(val template: KClass<out Any>) {
@@ -45,14 +42,9 @@ open class KotlinScriptDefinition(val template: KClass<out Any>) {
     open fun getScriptName(script: KtScript): Name =
             NameUtils.getScriptNameForFile(script.containingKtFile.name)
 
-    @Deprecated("Use dependencyResolver instead", level = DeprecationLevel.ERROR)
-    open fun getDependenciesFor(file: VirtualFile, project: Project, previousDependencies: KotlinScriptExternalDependencies?): KotlinScriptExternalDependencies? = null
+    open val dependencyResolver: DependenciesResolver get() = DependenciesResolver.NoDependencies
 
-    open val dependencyResolver: ScriptDependenciesResolver = EmptyDependencyResolver
-
-    open val acceptedAnnotations: List<KClass<out Annotation>> = emptyList()
-
-    private object EmptyDependencyResolver : ScriptDependenciesResolver
+    open val acceptedAnnotations: List<KClass<out Annotation>> get() = emptyList()
 }
 
 object StandardScriptDefinition : KotlinScriptDefinition(ScriptTemplateWithArgs::class)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProvider.kt
index 5ef86a38142..0ae57bc732e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/script/KotlinScriptExternalImportsProvider.kt
@@ -20,10 +20,10 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiFile
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
+import kotlin.script.dependencies.ScriptDependencies
 
 interface KotlinScriptExternalImportsProvider {
-    fun getScriptDependencies(file: VirtualFile): KotlinScriptExternalDependencies?
+    fun getScriptDependencies(file: VirtualFile): ScriptDependencies?
     fun getScriptDependencies(file: PsiFile) = getScriptDependencies(file.virtualFile)
 
     companion object {
@@ -32,5 +32,5 @@ interface KotlinScriptExternalImportsProvider {
     }
 }
 
-fun getScriptExternalDependencies(file: VirtualFile, project: Project): KotlinScriptExternalDependencies?  =
+fun getScriptExternalDependencies(file: VirtualFile, project: Project): ScriptDependencies?  =
         KotlinScriptExternalImportsProvider.getInstance(project).getScriptDependencies(file)
diff --git a/compiler/tests/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt b/compiler/tests/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt
index 6a31bace626..ec753116532 100644
--- a/compiler/tests/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt
@@ -35,13 +35,10 @@ import java.net.URLClassLoader
 import java.nio.charset.Charset
 import java.rmi.server.UnicastRemoteObject
 import java.util.concurrent.CountDownLatch
-import java.util.concurrent.Future
 import java.util.concurrent.TimeUnit
 import kotlin.concurrent.thread
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
-import kotlin.script.dependencies.ScriptContents
-import kotlin.script.dependencies.ScriptDependenciesResolver
-import kotlin.script.dependencies.asFuture
+import kotlin.script.dependencies.*
+import kotlin.script.dependencies.DependenciesResolver.ResolveResult
 import kotlin.script.templates.ScriptTemplateDefinition
 import kotlin.test.fail
 
@@ -817,18 +814,13 @@ internal val File.loggerCompatiblePath: String
         if (OSKind.current == OSKind.Windows) absolutePath.replace('\\', '/')
         else absolutePath
 
-open class TestKotlinScriptDummyDependenciesResolver : ScriptDependenciesResolver {
+open class TestKotlinScriptDummyDependenciesResolver : DependenciesResolver {
 
-    override fun resolve(script: ScriptContents,
-                         environment: Map<String, Any?>?,
-                         report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit,
-                         previousDependencies: KotlinScriptExternalDependencies?
-    ): Future<KotlinScriptExternalDependencies?>
-    {
-        return object : KotlinScriptExternalDependencies {
-            override val classpath: Iterable<File> = classpathFromClassloader()
-            override val imports: Iterable<String> = listOf("org.jetbrains.kotlin.scripts.DependsOn", "org.jetbrains.kotlin.scripts.DependsOnTwo")
-        }.asFuture()
+    override fun resolve(scriptContents: ScriptContents, environment: Environment): ResolveResult {
+        return ScriptDependencies(
+            classpath = classpathFromClassloader(),
+            imports = listOf("org.jetbrains.kotlin.scripts.DependsOn", "org.jetbrains.kotlin.scripts.DependsOnTwo")
+        ).asSuccess()
     }
 }
 
diff --git a/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTemplateTest.kt b/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTemplateTest.kt
index 1ea9527db5f..18860eba7af 100644
--- a/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTemplateTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTemplateTest.kt
@@ -44,12 +44,9 @@ import java.lang.Exception
 import java.lang.reflect.InvocationTargetException
 import java.net.URL
 import java.net.URLClassLoader
-import java.util.concurrent.Future
 import kotlin.reflect.KClass
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
-import kotlin.script.dependencies.ScriptContents
-import kotlin.script.dependencies.ScriptDependenciesResolver
-import kotlin.script.dependencies.asFuture
+import kotlin.script.dependencies.*
+import kotlin.script.dependencies.DependenciesResolver.ResolveResult
 import kotlin.script.templates.AcceptedAnnotations
 import kotlin.script.templates.ScriptTemplateDefinition
 import kotlin.script.templates.standard.ScriptTemplateWithArgs
@@ -320,19 +317,17 @@ class ScriptTemplateTest {
     }
 }
 
-open class TestKotlinScriptDummyDependenciesResolver : ScriptDependenciesResolver {
+open class TestKotlinScriptDummyDependenciesResolver : DependenciesResolver {
 
     @AcceptedAnnotations(DependsOn::class, DependsOnTwo::class)
-    override fun resolve(script: ScriptContents,
-                         environment: Map<String, Any?>?,
-                         report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit,
-                         previousDependencies: KotlinScriptExternalDependencies?
-    ): Future<KotlinScriptExternalDependencies?>
+    override fun resolve(scriptContents: ScriptContents,
+                         environment: Environment
+    ): ResolveResult
     {
-        return object : KotlinScriptExternalDependencies {
-            override val classpath: Iterable<File> = classpathFromClassloader()
-            override val imports: Iterable<String> = listOf("org.jetbrains.kotlin.scripts.DependsOn", "org.jetbrains.kotlin.scripts.DependsOnTwo")
-        }.asFuture()
+        return ScriptDependencies(
+            classpath = classpathFromClassloader(),
+            imports = listOf("org.jetbrains.kotlin.scripts.DependsOn", "org.jetbrains.kotlin.scripts.DependsOnTwo")
+        ).asSuccess()
     }
 
     protected fun classpathFromClassloader(): List<File> =
@@ -347,13 +342,11 @@ class TestKotlinScriptDependenciesResolver : TestKotlinScriptDummyDependenciesRe
     private val kotlinPaths by lazy { PathUtil.getKotlinPathsForCompiler() }
 
     @AcceptedAnnotations(DependsOn::class, DependsOnTwo::class)
-    override fun resolve(script: ScriptContents,
-                         environment: Map<String, Any?>?,
-                         report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit,
-                         previousDependencies: KotlinScriptExternalDependencies?
-    ): Future<KotlinScriptExternalDependencies?>
+    override fun resolve(scriptContents: ScriptContents,
+                         environment: Environment
+    ): ResolveResult
     {
-        val cp = script.annotations.flatMap {
+        val cp = scriptContents.annotations.flatMap {
             when (it) {
                 is DependsOn -> if (it.path == "@{runtime}") listOf(kotlinPaths.runtimePath, kotlinPaths.scriptRuntimePath) else listOf(File(it.path))
                 is DependsOnTwo -> listOf(it.path1, it.path2).flatMap {
@@ -367,10 +360,10 @@ class TestKotlinScriptDependenciesResolver : TestKotlinScriptDummyDependenciesRe
                 else -> throw Exception("Unknown annotation ${it::class.java}")
             }
         }
-        return object : KotlinScriptExternalDependencies {
-            override val classpath: Iterable<File> = classpathFromClassloader() + cp
-            override val imports: Iterable<String> = listOf("org.jetbrains.kotlin.scripts.DependsOn", "org.jetbrains.kotlin.scripts.DependsOnTwo")
-        }.asFuture()
+        return ScriptDependencies(
+            classpath = classpathFromClassloader() + cp,
+            imports = listOf("org.jetbrains.kotlin.scripts.DependsOn", "org.jetbrains.kotlin.scripts.DependsOnTwo")
+        ).asSuccess()
     }
 }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ScriptModuleInfos.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ScriptModuleInfos.kt
index 734a89dae7e..00c54b54327 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ScriptModuleInfos.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ScriptModuleInfos.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.idea.core.script.KotlinScriptConfigurationManager
 import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.script.KotlinScriptDefinition
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
+import kotlin.script.dependencies.ScriptDependencies
 
 class ScriptModuleSearchScope(val scriptFile: VirtualFile, baseScope: GlobalSearchScope) : DelegatingGlobalSearchScope(baseScope) {
     override fun equals(other: Any?) = other is ScriptModuleSearchScope && scriptFile == other.scriptFile && super.equals(other)
@@ -42,7 +42,7 @@ data class ScriptModuleInfo(val project: Project, val scriptFile: VirtualFile,
     override val moduleOrigin: ModuleOrigin
         get() = ModuleOrigin.OTHER
 
-    val externalDependencies: KotlinScriptExternalDependencies?
+    val externalDependencies: ScriptDependencies?
         get() = KotlinScriptConfigurationManager.getInstance(project).getScriptDependencies(scriptFile)
 
     override val name: Name = Name.special("<script ${scriptFile.name} ${scriptDefinition.name}>")
@@ -56,13 +56,13 @@ data class ScriptModuleInfo(val project: Project, val scriptFile: VirtualFile,
     }
 }
 
-private fun sdkDependencies(scriptDependencies: KotlinScriptExternalDependencies?, project: Project): List<SdkInfo>
+private fun sdkDependencies(scriptDependencies: ScriptDependencies?, project: Project): List<SdkInfo>
         = listOfNotNull(findJdk(scriptDependencies, project)?.let { SdkInfo(project, it) })
 
-fun findJdk(dependencies: KotlinScriptExternalDependencies?, project: Project): Sdk? {
+fun findJdk(dependencies: ScriptDependencies?, project: Project): Sdk? {
     val allJdks = getAllProjectSdks()
     // workaround for mismatched gradle wrapper and plugin version
-    val javaHome = try { dependencies?.javaHome } catch (e: Throwable) { null }
+    val javaHome = try { dependencies?.javaHome?.canonicalPath } catch (e: Throwable) { null }
 
     return allJdks.find { javaHome != null && it.homePath == javaHome } ?:
            ProjectRootManager.getInstance(project).projectSdk ?:
@@ -113,8 +113,8 @@ data class ScriptDependenciesSourceModuleInfo(
 
 }
 
-private class ScriptBinariesScopeCache(private val project: Project) : SLRUCache<KotlinScriptExternalDependencies, GlobalSearchScope>(6, 6) {
-    override fun createValue(key: KotlinScriptExternalDependencies?): GlobalSearchScope {
+private class ScriptBinariesScopeCache(private val project: Project) : SLRUCache<ScriptDependencies, GlobalSearchScope>(6, 6) {
+    override fun createValue(key: ScriptDependencies?): GlobalSearchScope {
         val roots = key?.classpath ?: emptyList()
         val classpath = KotlinScriptConfigurationManager.toVfsRoots(roots)
         // TODO: this is not very efficient because KotlinSourceFilterScope already checks if the files are in scripts classpath
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/KotlinScriptConfigurationManager.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/KotlinScriptConfigurationManager.kt
index 5ce78f97f6c..4666220ec71 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/KotlinScriptConfigurationManager.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/KotlinScriptConfigurationManager.kt
@@ -34,19 +34,19 @@ import com.intellij.openapi.vfs.newvfs.events.VFileEvent
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.search.NonClasspathDirectoriesScope
 import com.intellij.util.io.URLUtil
+import kotlinx.coroutines.experimental.asCoroutineDispatcher
+import kotlinx.coroutines.experimental.future.future
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.script.*
 import java.io.File
-import java.lang.Math.max
 import java.util.concurrent.CompletableFuture
-import java.util.concurrent.CompletableFuture.supplyAsync
 import java.util.concurrent.Executors.newFixedThreadPool
 import java.util.concurrent.locks.ReentrantReadWriteLock
-import java.util.function.Supplier
 import kotlin.concurrent.read
 import kotlin.concurrent.write
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
+import kotlin.script.dependencies.ScriptDependencies
+import kotlin.script.dependencies.experimental.AsyncDependenciesResolver
 
 
 // NOTE: this service exists exclusively because KotlinScriptConfigurationManager
@@ -54,7 +54,7 @@ import kotlin.script.dependencies.KotlinScriptExternalDependencies
 class IdeScriptExternalImportsProvider(
         private val scriptConfigurationManager: KotlinScriptConfigurationManager
 ) : KotlinScriptExternalImportsProvider {
-    override fun getScriptDependencies(file: VirtualFile): KotlinScriptExternalDependencies? {
+    override fun getScriptDependencies(file: VirtualFile): ScriptDependencies? {
         return scriptConfigurationManager.getScriptDependencies(file)
     }
 }
@@ -64,7 +64,7 @@ class KotlinScriptConfigurationManager(
         private val scriptDefinitionProvider: KotlinScriptDefinitionProvider
 ) : KotlinScriptExternalImportsProviderBase(project) {
     private val cacheLock = ReentrantReadWriteLock()
-    private val threadPool = newFixedThreadPool(max(1, Runtime.getRuntime().availableProcessors() / 2))
+    private val scriptDependencyUpdatesDispatcher = newFixedThreadPool(1).asCoroutineDispatcher()
 
     init {
         reloadScriptDefinitions()
@@ -144,17 +144,17 @@ class KotlinScriptConfigurationManager(
         scriptDefinitionProvider.setScriptDefinitions(def)
     }
 
-    private class TimeStampedRequest(val future: CompletableFuture<Unit>, val timeStamp: TimeStamp)
+    private class TimeStampedRequest(val future: CompletableFuture<*>, val timeStamp: TimeStamp)
 
     private class DataAndRequest(
-            val dependencies: KotlinScriptExternalDependencies?,
+            val dependencies: ScriptDependencies?,
             val modificationStamp: Long?,
             val requestInProgress: TimeStampedRequest? = null
     )
 
     private val cache = hashMapOf<String, DataAndRequest?>()
 
-    override fun getScriptDependencies(file: VirtualFile): KotlinScriptExternalDependencies = cacheLock.read {
+    override fun getScriptDependencies(file: VirtualFile): ScriptDependencies = cacheLock.read {
         val path = file.path
         val cached = cache[path]
         cached?.dependencies?.let { return it }
@@ -163,7 +163,7 @@ class KotlinScriptConfigurationManager(
 
         updateExternalImportsCache(listOf(file))
 
-        return cache[path]?.dependencies ?: NoDependencies
+        return cache[path]?.dependencies ?: ScriptDependencies.Empty
     }
 
     private fun tryLoadingFromDisk(cached: DataAndRequest?, file: VirtualFile, path: String) {
@@ -189,14 +189,18 @@ class KotlinScriptConfigurationManager(
             return cache.remove(file.path) != null
         }
 
-        // TODO: support apis that allow for async updates for any template
-        if (scriptDef is KotlinScriptDefinitionFromAnnotatedTemplate) {
-            return updateAsync(file, scriptDef)
+        val dependencyResolver = scriptDef.dependencyResolver
+        if (dependencyResolver is AsyncDependenciesResolver) {
+            return updateAsync(file, scriptDef, dependencyResolver)
         }
         return updateSync(file, scriptDef)
     }
 
-    private fun updateAsync(file: VirtualFile, scriptDefinition: KotlinScriptDefinitionFromAnnotatedTemplate): Boolean {
+    private fun updateAsync(
+            file: VirtualFile,
+            scriptDefinition: KotlinScriptDefinition,
+            dependencyResolver: AsyncDependenciesResolver
+    ): Boolean {
         val path = file.path
         val oldDataAndRequest = cache[path]
 
@@ -206,7 +210,7 @@ class KotlinScriptConfigurationManager(
 
         oldDataAndRequest?.requestInProgress?.future?.cancel(true)
 
-        val (currentTimeStamp, newFuture) = sendRequest(path, scriptDefinition, file, oldDataAndRequest)
+        val (currentTimeStamp, newFuture) = sendRequest(path, scriptDefinition, dependencyResolver, file, oldDataAndRequest)
 
         cache[path] = DataAndRequest(
                 oldDataAndRequest?.dependencies,
@@ -218,24 +222,29 @@ class KotlinScriptConfigurationManager(
 
     private fun sendRequest(
             path: String,
-            scriptDefinition: KotlinScriptDefinitionFromAnnotatedTemplate,
+            scriptDef: KotlinScriptDefinition,
+            dependenciesResolver: AsyncDependenciesResolver,
             file: VirtualFile,
             oldDataAndRequest: DataAndRequest?
-    ): Pair<TimeStamp, CompletableFuture<Unit>> {
+    ): Pair<TimeStamp, CompletableFuture<*>> {
         val currentTimeStamp = TimeStamps.next()
 
-        val newFuture = supplyAsync(Supplier {
-            val newDependencies = resolveDependencies(scriptDefinition, file, oldDataAndRequest?.dependencies) ?: EmptyDependencies
+        val newFuture = future(scriptDependencyUpdatesDispatcher) {
+            dependenciesResolver.resolveAsync(
+                    getScriptContents(scriptDef, file),
+                    (scriptDef as? KotlinScriptDefinitionFromAnnotatedTemplate)?.environment.orEmpty()
+            )
+        }.thenAccept { result ->
             cacheLock.read {
                 val lastTimeStamp = cache[path]?.requestInProgress?.timeStamp
                 if (lastTimeStamp == currentTimeStamp) {
-                    if (cacheSync(newDependencies, oldDataAndRequest?.dependencies, path, file)) {
+                    if (cacheSync(result.dependencies ?: ScriptDependencies.Empty, oldDataAndRequest?.dependencies, path, file)) {
                         invalidateLocalCaches()
                         notifyRootsChanged()
                     }
                 }
             }
-        }, threadPool)
+        }
         return Pair(currentTimeStamp, newFuture)
     }
 
@@ -253,13 +262,13 @@ class KotlinScriptConfigurationManager(
     private fun updateSync(file: VirtualFile, scriptDef: KotlinScriptDefinition): Boolean {
         val path = file.path
         val oldDeps = cache[path]?.dependencies
-        val newDeps = resolveDependencies(scriptDef, file, oldDeps) ?: EmptyDependencies
+        val newDeps = resolveDependencies(scriptDef, file) ?: ScriptDependencies.Empty
         return cacheSync(newDeps, oldDeps, path, file)
     }
 
     private fun cacheSync(
-            new: KotlinScriptExternalDependencies,
-            old: KotlinScriptExternalDependencies?,
+            new: ScriptDependencies,
+            old: ScriptDependencies?,
             path: String,
             file: VirtualFile
     ): Boolean {
@@ -277,7 +286,7 @@ class KotlinScriptConfigurationManager(
         }
     }
 
-    private fun save(path: String, new: KotlinScriptExternalDependencies?, virtualFile: VirtualFile, persist: Boolean) {
+    private fun save(path: String, new: ScriptDependencies?, virtualFile: VirtualFile, persist: Boolean) {
         cacheLock.write {
             cache.put(path, DataAndRequest(new, virtualFile.modificationStamp))
         }
@@ -342,8 +351,6 @@ class KotlinScriptConfigurationManager(
             }
         }
     }
-
-    private object NoDependencies: KotlinScriptExternalDependencies
 }
 
 private class ClearableLazyValue<out T : Any>(private val lock: ReentrantReadWriteLock, private val compute: () -> T) {
@@ -368,7 +375,7 @@ private class ClearableLazyValue<out T : Any>(private val lock: ReentrantReadWri
 }
 
 // TODO: relying on this to compare dependencies seems wrong, doesn't take javaHome and other stuff into account
-private fun KotlinScriptExternalDependencies.match(other: KotlinScriptExternalDependencies)
+private fun ScriptDependencies.match(other: ScriptDependencies)
         = classpath.isSamePathListAs(other.classpath) &&
           sources.toSet().isSamePathListAs(other.sources.toSet()) // TODO: gradle returns stdlib and reflect sources in unstable order for some reason
 
@@ -389,6 +396,4 @@ object TimeStamps {
     private var current: Long = 0
 
     fun next() = TimeStamp(current++)
-}
-
-private object EmptyDependencies: KotlinScriptExternalDependencies
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDependenciesFileAttribute.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDependenciesFileAttribute.kt
index a24d5894ecd..48ba530a9fe 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDependenciesFileAttribute.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/ScriptDependenciesFileAttribute.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.idea.caches.FileAttributeService
 import java.io.DataInput
 import java.io.DataOutput
 import java.io.File
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
+import kotlin.script.dependencies.ScriptDependencies
 
 // TODO_R: write nullable, write version
 object ScriptDependenciesFileAttribute {
@@ -40,29 +40,27 @@ object ScriptDependenciesFileAttribute {
         fileAttributeService.register(ID, VERSION, false)
     }
 
-    fun write(virtualFile: VirtualFile, dependencies: KotlinScriptExternalDependencies) {
+    fun write(virtualFile: VirtualFile, dependencies: ScriptDependencies) {
         if (virtualFile !is VirtualFileWithId) return
-
         fileAttributeService.write(virtualFile, ID, dependencies) { output, dep ->
             with(dep) {
                 output.writeFileList(classpath)
                 output.writeStringList(imports)
                 // TODO: actually read/write nullable
-                output.writeString(javaHome ?: "")
+                output.writeFile(javaHome ?: File(""))
                 output.writeFileList(scripts)
                 output.writeFileList(sources)
             }
         }
     }
 
-    fun read(virtualFile: VirtualFile): KotlinScriptExternalDependencies? {
+    fun read(virtualFile: VirtualFile): ScriptDependencies? {
         if (virtualFile !is VirtualFileWithId) return null
-
         return fileAttributeService.read(virtualFile, ID) { input ->
-            SerializedScriptDependencies(
+            ScriptDependencies(
                     classpath = input.readFileList(),
                     imports = input.readStringList(),
-                    javaHome = input.readString(),
+                    javaHome = input.readFile(),
                     scripts = input.readFileList(),
                     sources = input.readFileList()
             )
@@ -71,19 +69,11 @@ object ScriptDependenciesFileAttribute {
 }
 
 private fun DataInput.readStringList(): List<String> = readSeq(this) { readString() }
-private fun DataInput.readFileList() = readStringList().map { File(it) }
+private fun DataInput.readFileList() = readSeq(this) { readFile() }
 private fun DataInput.readString() = readUTF(this)
+private fun DataInput.readFile() = readUTF(this).let { File(it) }
 
 private fun DataOutput.writeFileList(iterable: Iterable<File>) = writeSeq(this, iterable.toList()) { writeFile(it) }
 private fun DataOutput.writeFile(it: File) = writeString(it.canonicalPath)
 private fun DataOutput.writeString(string: String) = writeUTF(this, string)
 private fun DataOutput.writeStringList(iterable: Iterable<String>) = writeSeq(this, iterable.toList()) { writeString(it) }
-
-
-private class SerializedScriptDependencies(
-        override val classpath: Iterable<File>,
-        override val imports: Iterable<String>,
-        override val javaHome: String?,
-        override val scripts: Iterable<File>,
-        override val sources: Iterable<File>
-) : KotlinScriptExternalDependencies
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/script/StandardKotlinScriptTemplateProvider.kt b/idea/src/org/jetbrains/kotlin/idea/script/StandardKotlinScriptTemplateProvider.kt
index 92d2cbc3a98..8a0150b5e2a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/script/StandardKotlinScriptTemplateProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/script/StandardKotlinScriptTemplateProvider.kt
@@ -24,11 +24,8 @@ import org.jetbrains.kotlin.idea.core.script.dependencies.KotlinScriptResolveSco
 import org.jetbrains.kotlin.script.ScriptTemplatesProvider
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
-import java.util.concurrent.Future
-import kotlin.script.dependencies.KotlinScriptExternalDependencies
-import kotlin.script.dependencies.PseudoFuture
-import kotlin.script.dependencies.ScriptContents
-import kotlin.script.dependencies.ScriptDependenciesResolver
+import kotlin.script.dependencies.*
+import kotlin.script.dependencies.DependenciesResolver.ResolveResult
 import kotlin.script.templates.standard.ScriptTemplateWithArgs
 
 class StandardKotlinScriptTemplateProvider(val project: Project) : ScriptTemplatesProvider {
@@ -45,7 +42,7 @@ class StandardKotlinScriptTemplateProvider(val project: Project) : ScriptTemplat
         )
     }
 
-    override val resolver: ScriptDependenciesResolver = BundledKotlinScriptDependenciesResolver()
+    override val resolver: DependenciesResolver = BundledKotlinScriptDependenciesResolver()
 
     private fun getScriptSDK(project: Project): String? {
         val jdk = PathUtilEx.getAnyJdk(project) ?:
@@ -55,26 +52,22 @@ class StandardKotlinScriptTemplateProvider(val project: Project) : ScriptTemplat
     }
 }
 
-class BundledKotlinScriptDependenciesResolver : ScriptDependenciesResolver {
+class BundledKotlinScriptDependenciesResolver : DependenciesResolver {
     override fun resolve(
-            script: ScriptContents,
-            environment: Map<String, Any?>?,
-            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit,
-            previousDependencies: KotlinScriptExternalDependencies?): Future<KotlinScriptExternalDependencies?> {
-        val javaHome = environment?.get("sdk") as String?
-        val dependencies = KotlinBundledScriptDependencies(javaHome)
-        return PseudoFuture(dependencies)
+            scriptContents: ScriptContents,
+            environment: Environment
+    ): ResolveResult {
+        val javaHome = environment.get("sdk") as String?
+        val dependencies = ScriptDependencies(
+                javaHome = javaHome?.let(::File),
+                classpath = with(PathUtil.getKotlinPathsForIdeaPlugin()) {
+                    listOf(
+                            reflectPath,
+                            stdlibPath,
+                            scriptRuntimePath
+                    )
+                }
+        )
+        return dependencies.asSuccess()
     }
 }
-
-class KotlinBundledScriptDependencies(override val javaHome: String?) : KotlinScriptExternalDependencies {
-    override val classpath: Iterable<File> get() {
-        return with(PathUtil.getKotlinPathsForIdeaPlugin()) {
-            listOf(
-                    reflectPath,
-                    stdlibPath,
-                    scriptRuntimePath
-            )
-        }
-    }
-}
\ No newline at end of file