diff --git a/build.gradle b/build.gradle
index beb6e2d..ce77c0a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -103,7 +103,7 @@
 
 // --------------- Configure sub-projects that are part of the library ---------------
 
-def internal = sourceless + ['benchmarks', 'knit', 'js-stub', 'binary-compatibility-validator']
+def internal = sourceless + ['benchmarks', 'knit', 'js-stub', 'stdlib-stubs', 'binary-compatibility-validator']
 
 // Reconfigure source sets to avoid long "src/main/kotlin/fqn"
 configure(subprojects.findAll { !it.name.contains(sourceless) && it.name != "benchmarks" }) {
diff --git a/common/kotlinx-coroutines-core-common/src/CoroutineContext.common.kt b/common/kotlinx-coroutines-core-common/src/CoroutineContext.common.kt
index 410c349..d831233 100644
--- a/common/kotlinx-coroutines-core-common/src/CoroutineContext.common.kt
+++ b/common/kotlinx-coroutines-core-common/src/CoroutineContext.common.kt
@@ -6,6 +6,10 @@
 
 import kotlin.coroutines.*
 
+/**
+ * Creates context for the new coroutine. It installs [Dispatchers.Default] when no other dispatcher nor
+ * [ContinuationInterceptor] is specified, and adds optional support for debugging facilities (when turned on).
+ */
 public expect fun CoroutineScope.newCoroutineContext(context: CoroutineContext): CoroutineContext
 
 internal expect fun createDefaultDispatcher(): CoroutineDispatcher
diff --git a/common/kotlinx-coroutines-core-common/src/CoroutineDispatcher.kt b/common/kotlinx-coroutines-core-common/src/CoroutineDispatcher.kt
index 2ec2520..c070edb 100644
--- a/common/kotlinx-coroutines-core-common/src/CoroutineDispatcher.kt
+++ b/common/kotlinx-coroutines-core-common/src/CoroutineDispatcher.kt
@@ -103,7 +103,7 @@
     )
     public operator fun plus(other: CoroutineDispatcher) = other
 
-    // for nicer debugging
+    /** @suppress for nicer debugging */
     override fun toString(): String = "$classSimpleName@$hexAddress"
 }
 
diff --git a/common/kotlinx-coroutines-core-common/src/CoroutineScope.kt b/common/kotlinx-coroutines-core-common/src/CoroutineScope.kt
index ae42c3e..1ab48b0 100644
--- a/common/kotlinx-coroutines-core-common/src/CoroutineScope.kt
+++ b/common/kotlinx-coroutines-core-common/src/CoroutineScope.kt
@@ -58,7 +58,6 @@
  * ```
  */
 public interface CoroutineScope {
-
     /**
      * Context of this scope.
      */
diff --git a/common/kotlinx-coroutines-core-common/src/Delay.kt b/common/kotlinx-coroutines-core-common/src/Delay.kt
index a25ba09..5517e79 100644
--- a/common/kotlinx-coroutines-core-common/src/Delay.kt
+++ b/common/kotlinx-coroutines-core-common/src/Delay.kt
@@ -16,7 +16,7 @@
  *
  * @suppress **This an internal API and should not be used from general code.**
  */
-@InternalCoroutinesApi // todo: Remove references from other docs
+@InternalCoroutinesApi
 public interface Delay {
     /**
      * Delays coroutine for a given time without blocking a thread and resumes it after a specified time.
@@ -65,9 +65,7 @@
  *
  * Note, that delay can be used in [select] invocation with [onTimeout][SelectBuilder.onTimeout] clause.
  *
- * This function delegates to [Delay.scheduleResumeAfterDelay] if the context [CoroutineDispatcher]
- * implements [Delay] interface, otherwise it resumes using a built-in single-threaded scheduled executor service.
- *
+ * Implementation note: how exactly time is tracked is an implementation detail of [CoroutineDispatcher] in the context.
  * @param timeMillis time in milliseconds.
  */
 public suspend fun delay(timeMillis: Long) {
diff --git a/common/kotlinx-coroutines-core-common/src/Exceptions.common.kt b/common/kotlinx-coroutines-core-common/src/Exceptions.common.kt
index 8c9f88d..3e94572 100644
--- a/common/kotlinx-coroutines-core-common/src/Exceptions.common.kt
+++ b/common/kotlinx-coroutines-core-common/src/Exceptions.common.kt
@@ -4,6 +4,9 @@
 
 package kotlinx.coroutines
 
+/**
+ * @suppress **This an internal API and should not be used from general code.**
+ */
 @InternalCoroutinesApi
 public expect class CompletionHandlerException(message: String, cause: Throwable) : RuntimeException
 
diff --git a/common/kotlinx-coroutines-core-common/src/NonCancellable.kt b/common/kotlinx-coroutines-core-common/src/NonCancellable.kt
index a104df8..2347a57 100644
--- a/common/kotlinx-coroutines-core-common/src/NonCancellable.kt
+++ b/common/kotlinx-coroutines-core-common/src/NonCancellable.kt
@@ -5,12 +5,11 @@
 
 package kotlinx.coroutines
 
-import kotlinx.coroutines.NonCancellable.isActive
 import kotlinx.coroutines.selects.*
 import kotlin.coroutines.*
 
 /**
- * A non-cancelable job that is always [active][isActive]. It is designed for [withContext] function
+ * A non-cancelable job that is always [active][Job.isActive]. It is designed for [withContext] function
  * to prevent cancellation of code blocks that need to be executed without cancellation.
  *
  * Use it like this:
@@ -26,7 +25,7 @@
      * @suppress **This an internal API and should not be used from general code.**
      */
     @InternalCoroutinesApi
-    override val isActive: Boolean  get() = true
+    override val isActive: Boolean get() = true
 
     /**
      * Always returns `false`.
diff --git a/common/kotlinx-coroutines-core-common/src/Runnable.common.kt b/common/kotlinx-coroutines-core-common/src/Runnable.common.kt
index 8f8f916..c6bdd94 100644
--- a/common/kotlinx-coroutines-core-common/src/Runnable.common.kt
+++ b/common/kotlinx-coroutines-core-common/src/Runnable.common.kt
@@ -4,6 +4,7 @@
 
 package kotlinx.coroutines
 
+/** @suppress */
 public expect interface Runnable {
     public fun run()
 }
diff --git a/common/kotlinx-coroutines-core-common/src/Timeout.kt b/common/kotlinx-coroutines-core-common/src/Timeout.kt
index 57f4fa4..8c8f96b 100644
--- a/common/kotlinx-coroutines-core-common/src/Timeout.kt
+++ b/common/kotlinx-coroutines-core-common/src/Timeout.kt
@@ -20,8 +20,7 @@
  * The sibling function that does not throw exception on timeout is [withTimeoutOrNull].
  * Note, that timeout action can be specified for [select] invocation with [onTimeout][SelectBuilder.onTimeout] clause.
  *
- * This function delegates to [Delay.invokeOnTimeout] if the context [CoroutineDispatcher]
- * implements [Delay] interface, otherwise it tracks time using a built-in single-threaded scheduled executor service.
+ * Implementation note: how exactly time is tracked is an implementation detail of [CoroutineDispatcher] in the context.
  *
  * @param timeMillis timeout time in milliseconds.
  */
@@ -42,8 +41,7 @@
  * The sibling function that throws exception on timeout is [withTimeout].
  * Note, that timeout action can be specified for [select] invocation with [onTimeout][SelectBuilder.onTimeout] clause.
  *
- * This function delegates to [Delay.invokeOnTimeout] if the context [CoroutineDispatcher]
- * implements [Delay] interface, otherwise it tracks time using a built-in single-threaded scheduled executor service.
+ * Implementation note: how exactly time is tracked is an implementation detail of [CoroutineDispatcher] in the context.
  *
  * @param timeMillis timeout time in milliseconds.
  */
diff --git a/common/kotlinx-coroutines-core-common/src/channels/Channel.kt b/common/kotlinx-coroutines-core-common/src/channels/Channel.kt
index 86ce386..56c4713 100644
--- a/common/kotlinx-coroutines-core-common/src/channels/Channel.kt
+++ b/common/kotlinx-coroutines-core-common/src/channels/Channel.kt
@@ -342,7 +342,7 @@
  *   while previously sent elements **are lost**.
  *   Sender to this channel never suspends and [offer] always returns `true`.
  *
- * * When `capacity` is positive, but less than [UNLIMITED] -- it creates [ArrayChannel].
+ * * When `capacity` is positive, but less than [UNLIMITED] -- it creates array-based channel with given capacity.
  *   This channel has an array buffer of a fixed `capacity`.
  *   Sender suspends only when buffer is fully and receiver suspends only when buffer is empty.
  */
diff --git a/common/kotlinx-coroutines-core-common/src/internal/MainDispatcherFactory.kt b/common/kotlinx-coroutines-core-common/src/internal/MainDispatcherFactory.kt
index 3255b39..6e26cff 100644
--- a/common/kotlinx-coroutines-core-common/src/internal/MainDispatcherFactory.kt
+++ b/common/kotlinx-coroutines-core-common/src/internal/MainDispatcherFactory.kt
@@ -6,6 +6,7 @@
 
 import kotlinx.coroutines.*
 
+/** @suppress */
 @InternalCoroutinesApi // Emulating DI for Kotlin object's
 public interface MainDispatcherFactory {
     val loadPriority: Int // higher priority wins
diff --git a/common/kotlinx-coroutines-core-common/src/selects/Select.kt b/common/kotlinx-coroutines-core-common/src/selects/Select.kt
index 020e2bb..88af832 100644
--- a/common/kotlinx-coroutines-core-common/src/selects/Select.kt
+++ b/common/kotlinx-coroutines-core-common/src/selects/Select.kt
@@ -9,6 +9,7 @@
 import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.internal.*
 import kotlinx.coroutines.intrinsics.*
+import kotlinx.coroutines.sync.*
 import kotlin.coroutines.*
 import kotlin.coroutines.intrinsics.*
 
@@ -150,12 +151,12 @@
  *
  * | **Receiver**     | **Suspending function**                       | **Select clause**                                | **Non-suspending version**
  * | ---------------- | --------------------------------------------- | ------------------------------------------------ | --------------------------
- * | [Job]            | [join][Job.join]                              | [onJoin][SelectBuilder.onJoin]                   | [isCompleted][Job.isCompleted]
- * | [Deferred]       | [await][Deferred.await]                       | [onAwait][SelectBuilder.onAwait]                 | [isCompleted][Job.isCompleted]
- * | [SendChannel]    | [send][SendChannel.send]                      | [onSend][SelectBuilder.onSend]                   | [offer][SendChannel.offer]
- * | [ReceiveChannel] | [receive][ReceiveChannel.receive]             | [onReceive][SelectBuilder.onReceive]             | [poll][ReceiveChannel.poll]
- * | [ReceiveChannel] | [receiveOrNull][ReceiveChannel.receiveOrNull] | [onReceiveOrNull][SelectBuilder.onReceiveOrNull] | [poll][ReceiveChannel.poll]
- * | [Mutex]          | [lock][Mutex.lock]                            | [onLock][SelectBuilder.onLock]                   | [tryLock][Mutex.tryLock]
+ * | [Job]            | [join][Job.join]                              | [onJoin][Job.onJoin]                             | [isCompleted][Job.isCompleted]
+ * | [Deferred]       | [await][Deferred.await]                       | [onAwait][Deferred.onAwait]                      | [isCompleted][Job.isCompleted]
+ * | [SendChannel]    | [send][SendChannel.send]                      | [onSend][SendChannel.onSend]                     | [offer][SendChannel.offer]
+ * | [ReceiveChannel] | [receive][ReceiveChannel.receive]             | [onReceive][ReceiveChannel.onReceive]            | [poll][ReceiveChannel.poll]
+ * | [ReceiveChannel] | [receiveOrNull][ReceiveChannel.receiveOrNull] | [onReceiveOrNull][ReceiveChannel.onReceiveOrNull]| [poll][ReceiveChannel.poll]
+ * | [Mutex]          | [lock][Mutex.lock]                            | [onLock][Mutex.onLock]                           | [tryLock][Mutex.tryLock]
  * | none             | [delay]                                       | [onTimeout][SelectBuilder.onTimeout]             | none
  *
  * This suspending function is cancellable. If the [Job] of the current coroutine is cancelled or completed while this
diff --git a/common/kotlinx-coroutines-core-common/test/channels/BroadcastChannelFactoryTest.kt b/common/kotlinx-coroutines-core-common/test/channels/BroadcastChannelFactoryTest.kt
index 1d172b3..4f11f6c 100644
--- a/common/kotlinx-coroutines-core-common/test/channels/BroadcastChannelFactoryTest.kt
+++ b/common/kotlinx-coroutines-core-common/test/channels/BroadcastChannelFactoryTest.kt
@@ -4,10 +4,11 @@
 
 package kotlinx.coroutines.channels
 
+import kotlinx.coroutines.*
 import kotlin.test.*
 
 
-class BroadcastChannelFactoryTest {
+class BroadcastChannelFactoryTest : TestBase() {
 
     @Test
     fun testRendezvousChannelNotSupported() {
diff --git a/core/kotlinx-coroutines-core/src/Runnable.kt b/core/kotlinx-coroutines-core/src/Runnable.kt
index 2acd554..c69c07d 100644
--- a/core/kotlinx-coroutines-core/src/Runnable.kt
+++ b/core/kotlinx-coroutines-core/src/Runnable.kt
@@ -6,6 +6,7 @@
 
 /**
  * A runnable task for [CoroutineDispatcher.dispatch].
+ * @suppress
  */
 public actual typealias Runnable = java.lang.Runnable
 
diff --git a/core/kotlinx-coroutines-core/src/channels/Actor.kt b/core/kotlinx-coroutines-core/src/channels/Actor.kt
index c1482bf..2216268 100644
--- a/core/kotlinx-coroutines-core/src/channels/Actor.kt
+++ b/core/kotlinx-coroutines-core/src/channels/Actor.kt
@@ -101,7 +101,7 @@
  * @param context additional to [CoroutineScope.coroutineContext] context of the coroutine.
  * @param capacity capacity of the channel's buffer (no buffer by default).
  * @param start coroutine start option. The default value is [CoroutineStart.DEFAULT].
- * @param onCompletion optional completion handler for the actor coroutine (see [Job.invokeOnCompletion]).
+ * @param onCompletion optional completion handler for the actor coroutine (see [Job.invokeOnCompletion])
  * @param block the coroutine code.
  */
 @ObsoleteCoroutinesApi
diff --git a/core/stdlib-stubs/README.md b/core/stdlib-stubs/README.md
new file mode 100644
index 0000000..f47bccc
--- /dev/null
+++ b/core/stdlib-stubs/README.md
@@ -0,0 +1 @@
+This is a workaround for Dokka to generate proper references for Kotlin 1.3 API.
\ No newline at end of file
diff --git a/core/stdlib-stubs/build.gradle b/core/stdlib-stubs/build.gradle
new file mode 100644
index 0000000..4d7eee1
--- /dev/null
+++ b/core/stdlib-stubs/build.gradle
@@ -0,0 +1,9 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+compileKotlin {
+    kotlinOptions {
+        freeCompilerArgs += "-Xallow-kotlin-package"
+    }
+}
diff --git a/core/stdlib-stubs/src/Continuation.kt b/core/stdlib-stubs/src/Continuation.kt
new file mode 100644
index 0000000..d5834da
--- /dev/null
+++ b/core/stdlib-stubs/src/Continuation.kt
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+package kotlin.coroutines
+
+// DOKKA STUB
+public interface Continuation<in T> {
+    public val context: CoroutineContext
+    public fun resumeWith(result: Result<T>)
+}
\ No newline at end of file
diff --git a/core/stdlib-stubs/src/ContinuationInterceptor.kt b/core/stdlib-stubs/src/ContinuationInterceptor.kt
new file mode 100644
index 0000000..6fbfa70
--- /dev/null
+++ b/core/stdlib-stubs/src/ContinuationInterceptor.kt
@@ -0,0 +1,15 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+package kotlin.coroutines
+
+// DOKKA STUB
+public interface ContinuationInterceptor : CoroutineContext.Element {
+    companion object Key : CoroutineContext.Key<ContinuationInterceptor>
+    public fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T>
+    public fun releaseInterceptedContinuation(continuation: Continuation<*>): Continuation<*> {
+        return continuation
+    }
+    public override operator fun <E : CoroutineContext.Element> get(key: CoroutineContext.Key<E>): E? = TODO()
+    public override fun minusKey(key: CoroutineContext.Key<*>): CoroutineContext = TODO()
+}
diff --git a/core/stdlib-stubs/src/CoroutineContext.kt b/core/stdlib-stubs/src/CoroutineContext.kt
new file mode 100644
index 0000000..e263154
--- /dev/null
+++ b/core/stdlib-stubs/src/CoroutineContext.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+package kotlin.coroutines
+
+// DOKKA STUB
+public interface CoroutineContext {
+    public operator fun <E : Element> get(key: Key<E>): E?
+    public fun <R> fold(initial: R, operation: (R, Element) -> R): R
+    public operator fun plus(context: CoroutineContext): CoroutineContext = TODO()
+    public fun minusKey(key: Key<*>): CoroutineContext
+    public interface Key<E : Element>
+    public interface Element : CoroutineContext {
+        public val key: Key<*>
+
+        public override operator fun <E : Element> get(key: Key<E>): E? =
+            @Suppress("UNCHECKED_CAST")
+            if (this.key == key) this as E else null
+
+        public override fun <R> fold(initial: R, operation: (R, Element) -> R): R =
+            operation(initial, this)
+
+        public override fun minusKey(key: Key<*>): CoroutineContext =
+            if (this.key == key) EmptyCoroutineContext else this
+    }
+}
+
+public object EmptyCoroutineContext : CoroutineContext {
+    private const val serialVersionUID: Long = 0
+    private fun readResolve(): Any = EmptyCoroutineContext
+
+    public override fun <E : CoroutineContext.Element> get(key: CoroutineContext.Key<E>): E? = null
+    public override fun <R> fold(initial: R, operation: (R, CoroutineContext.Element) -> R): R = initial
+    public override fun plus(context: CoroutineContext): CoroutineContext = context
+    public override fun minusKey(key: CoroutineContext.Key<*>): CoroutineContext = this
+    public override fun hashCode(): Int = 0
+    public override fun toString(): String = "EmptyCoroutineContext"
+}
diff --git a/core/stdlib-stubs/src/Result.kt b/core/stdlib-stubs/src/Result.kt
new file mode 100644
index 0000000..5fe48cb
--- /dev/null
+++ b/core/stdlib-stubs/src/Result.kt
@@ -0,0 +1,14 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlin
+
+interface Result<out T> {
+    public val value: T
+    public val isSuccess: Boolean
+    public val isFailure: Boolean
+    public fun exceptionOrNull(): Throwable?
+    public fun getOrNull(): T?
+    public fun getOrThrow(): T
+}
diff --git a/docs/channels.md b/docs/channels.md
index e216b8d..d213688 100644
--- a/docs/channels.md
+++ b/docs/channels.md
@@ -627,6 +627,7 @@
 <!--- INDEX kotlinx.coroutines -->
 [CoroutineScope]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html
 [runBlocking]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html
+[kotlin.coroutines.CoroutineContext.cancelChildren]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/kotlin.coroutines.-coroutine-context/cancel-children.html
 [Dispatchers.Default]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-dispatchers/-default.html
 <!--- INDEX kotlinx.coroutines.channels -->
 [Channel]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/-channel/index.html
diff --git a/gradle/dokka.gradle b/gradle/dokka.gradle
index 76a432c..730fd7b 100644
--- a/gradle/dokka.gradle
+++ b/gradle/dokka.gradle
@@ -16,6 +16,10 @@
     }
 }
 
+configurations {
+    dokkaStubs.extendsFrom compileOnly
+}
+
 if (platform == "jvm") {
     apply plugin: 'org.jetbrains.dokka'
 
@@ -24,14 +28,24 @@
         includes = ['README.md']
     }
 
+    dependencies {
+        dokkaStubs project(":stdlib-stubs")
+    }
+
     dokka {
+        kotlinTasks { [] }
         outputFormat = 'kotlin-website'
+        afterEvaluate {
+            dependsOn(project.configurations.dokkaStubs)
+            dependsOn(project.configurations.compileClasspath)
+            classpath = project.configurations.dokkaStubs.files + project.configurations.compileClasspath.files + project.sourceSets.main.output.files
+        }
     }
 
     if (project.name == coroutines_core) {
         // Custom configuration for MPP modules
         dependencies {
-            compileOnly project(":js-stub") // so that JS library reference can resolve properly
+            dokkaStubs project(":js-stub") // so that JS library reference can resolve properly
         }
         
         dokka {
@@ -63,8 +77,9 @@
                 dependsOn(tasks.getByPath(":$project.name:classes"))
                 dependsOn(tasks.getByPath(":$project.name-js:classes"))
                 dependsOn(tasks.getByPath(":$project.name-common:classes"))
+                dependsOn(project.configurations.dokkaStubs)
                 dependsOn(project.configurations.compileClasspath)
-                classpath = project.configurations.compileClasspath.files + project.sourceSets.main.output.files
+                classpath = project.configurations.dokkaStubs.files + project.configurations.compileClasspath.files + project.sourceSets.main.output.files
             }
         }
     }
diff --git a/integration/kotlinx-coroutines-play-services/build.gradle b/integration/kotlinx-coroutines-play-services/build.gradle
index eb37d2a..44eec3b 100644
--- a/integration/kotlinx-coroutines-play-services/build.gradle
+++ b/integration/kotlinx-coroutines-play-services/build.gradle
@@ -38,10 +38,12 @@
 tasks.withType(dokka.getClass()) {
     externalDocumentationLink {
         url = new URL("https://developers.google.com/android/reference/")
-        /*
-         * This is workaround for missing package list in Google API
-         */
-        packageListUrl = rootDir.toPath().resolve("integration/kotlinx-coroutines-play-services/resources/package.list").toUri().toURL()
+        // This is workaround for missing package list in Google API
+        packageListUrl = projectDir.toPath().resolve("package.list").toUri().toURL()
+    }
+
+    afterEvaluate {
+        classpath += project.configurations.aar.files
     }
 }
 
diff --git a/integration/kotlinx-coroutines-play-services/resources/package.list b/integration/kotlinx-coroutines-play-services/package.list
similarity index 100%
rename from integration/kotlinx-coroutines-play-services/resources/package.list
rename to integration/kotlinx-coroutines-play-services/package.list
diff --git a/integration/kotlinx-coroutines-slf4j/build.gradle b/integration/kotlinx-coroutines-slf4j/build.gradle
index c97e9a3..161a0b8 100644
--- a/integration/kotlinx-coroutines-slf4j/build.gradle
+++ b/integration/kotlinx-coroutines-slf4j/build.gradle
@@ -5,8 +5,9 @@
     testRuntime 'ch.qos.logback:logback-core:1.2.3'
 }
 
-//tasks.withType(dokka.getClass()) {
-//    externalDocumentationLink {
-//        url = new URL("https://www.slf4j.org/apidocs/")
-//    }
-//}
\ No newline at end of file
+tasks.withType(dokka.getClass()) {
+    externalDocumentationLink {
+        packageListUrl = projectDir.toPath().resolve("package.list").toUri().toURL()
+        url = new URL("https://www.slf4j.org/apidocs/")
+    }
+}
\ No newline at end of file
diff --git a/integration/kotlinx-coroutines-slf4j/package.list b/integration/kotlinx-coroutines-slf4j/package.list
new file mode 100644
index 0000000..bfea07f
--- /dev/null
+++ b/integration/kotlinx-coroutines-slf4j/package.list
@@ -0,0 +1,21 @@
+org.apache.commons.logging
+org.apache.commons.logging.impl
+org.apache.log4j
+org.apache.log4j.helpers
+org.apache.log4j.spi
+org.apache.log4j.xml
+org.slf4j
+org.slf4j.agent
+org.slf4j.bridge
+org.slf4j.cal10n
+org.slf4j.event
+org.slf4j.ext
+org.slf4j.helpers
+org.slf4j.instrumentation
+org.slf4j.jul
+org.slf4j.log4j12
+org.slf4j.nop
+org.slf4j.osgi.logservice.impl
+org.slf4j.profiler
+org.slf4j.simple
+org.slf4j.spi
diff --git a/js/kotlinx-coroutines-core-js/src/Exceptions.kt b/js/kotlinx-coroutines-core-js/src/Exceptions.kt
index ef18dec..fadaa5a 100644
--- a/js/kotlinx-coroutines-core-js/src/Exceptions.kt
+++ b/js/kotlinx-coroutines-core-js/src/Exceptions.kt
@@ -6,6 +6,7 @@
 
 /**
  * This exception gets thrown if an exception is caught while processing [CompletionHandler] invocation for [Job].
+ * @suppress
  */
 public actual class CompletionHandlerException public actual constructor(
     message: String,
diff --git a/js/kotlinx-coroutines-core-js/src/Runnable.kt b/js/kotlinx-coroutines-core-js/src/Runnable.kt
index 6e85f67..06e9da6 100644
--- a/js/kotlinx-coroutines-core-js/src/Runnable.kt
+++ b/js/kotlinx-coroutines-core-js/src/Runnable.kt
@@ -6,6 +6,7 @@
 
 /**
  * A runnable task for [CoroutineDispatcher.dispatch].
+ * @suppress
  */
 public actual interface Runnable {
     public actual fun run()
diff --git a/reactive/kotlinx-coroutines-rx2/src/RxScheduler.kt b/reactive/kotlinx-coroutines-rx2/src/RxScheduler.kt
index f7b6989..53fbaf6 100644
--- a/reactive/kotlinx-coroutines-rx2/src/RxScheduler.kt
+++ b/reactive/kotlinx-coroutines-rx2/src/RxScheduler.kt
@@ -5,16 +5,13 @@
 package kotlinx.coroutines.rx2
 
 import io.reactivex.Scheduler
-import kotlinx.coroutines.CancellableContinuation
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Delay
-import kotlinx.coroutines.DisposableHandle
+import kotlinx.coroutines.*
 import java.util.concurrent.TimeUnit
 import kotlin.coroutines.CoroutineContext
 
 /**
  * Converts an instance of [Scheduler] to an implementation of [CoroutineDispatcher]
- * and provides native [delay][Delay.delay] support.
+ * and provides native support of [delay] and [withTimeout].
  */
 public fun Scheduler.asCoroutineDispatcher(): SchedulerCoroutineDispatcher = SchedulerCoroutineDispatcher(this)
 
diff --git a/settings.gradle b/settings.gradle
index 95a0f11..449f7cb 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -23,6 +23,7 @@
 module('common/kotlinx-coroutines-core-common')
 
 module('core/kotlinx-coroutines-core')
+module('core/stdlib-stubs')
 
 module('integration/kotlinx-coroutines-guava')
 module('integration/kotlinx-coroutines-jdk8')
diff --git a/ui/kotlinx-coroutines-javafx/src/JavaFxDispatcher.kt b/ui/kotlinx-coroutines-javafx/src/JavaFxDispatcher.kt
index 39c7505..b723f11 100644
--- a/ui/kotlinx-coroutines-javafx/src/JavaFxDispatcher.kt
+++ b/ui/kotlinx-coroutines-javafx/src/JavaFxDispatcher.kt
@@ -27,8 +27,10 @@
  */
 public sealed class JavaFxDispatcher : MainCoroutineDispatcher(), Delay {
 
+    /** @suppress */
     override fun dispatch(context: CoroutineContext, block: Runnable) = Platform.runLater(block)
 
+    /** @suppress */
     override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
         val timeline = schedule(timeMillis, TimeUnit.MILLISECONDS, EventHandler {
             with(continuation) { resumeUndispatched(Unit) }
@@ -36,6 +38,7 @@
         continuation.invokeOnCancellation { timeline.stop() }
     }
 
+    /** @suppress */
     override fun invokeOnTimeout(timeMillis: Long, block: Runnable): DisposableHandle {
         val timeline = schedule(timeMillis, TimeUnit.MILLISECONDS, EventHandler {
             block.run()
diff --git a/ui/kotlinx-coroutines-swing/src/SwingDispatcher.kt b/ui/kotlinx-coroutines-swing/src/SwingDispatcher.kt
index 07bef74..79c28e8 100644
--- a/ui/kotlinx-coroutines-swing/src/SwingDispatcher.kt
+++ b/ui/kotlinx-coroutines-swing/src/SwingDispatcher.kt
@@ -24,8 +24,10 @@
  * This class provides type-safety and a point for future extensions.
  */
 public sealed class SwingDispatcher : MainCoroutineDispatcher(), Delay {
+    /** @suppress */
     override fun dispatch(context: CoroutineContext, block: Runnable) = SwingUtilities.invokeLater(block)
 
+    /** @suppress */
     override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
         val timer = schedule(timeMillis, TimeUnit.MILLISECONDS, ActionListener {
             with(continuation) { resumeUndispatched(Unit) }
@@ -33,6 +35,7 @@
         continuation.invokeOnCancellation { timer.stop() }
     }
 
+    /** @suppress */
     override fun invokeOnTimeout(timeMillis: Long, block: Runnable): DisposableHandle {
         val timer = schedule(timeMillis, TimeUnit.MILLISECONDS, ActionListener {
             block.run()