diff --git a/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt b/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt
index bc662e79086..c8ab319ea48 100644
--- a/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt
+++ b/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt
@@ -115,10 +115,21 @@ suspend inline fun <T> runCatchingSafely(
     safely(onException, block)
 }
 
+suspend inline fun <T, R> T.runCatchingSafely(
+    noinline onException: ExceptionHandler<R> = defaultSafelyExceptionHandler,
+    noinline block: suspend T.() -> R
+): Result<R> = runCatching {
+    safely(onException) { block() }
+}
+
 suspend inline fun <T> safelyWithResult(
     noinline block: suspend CoroutineScope.() -> T
 ): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
 
+suspend inline fun <T, R> T.safelyWithResult(
+    noinline block: suspend T.() -> R
+): Result<R> = runCatchingSafely(defaultSafelyExceptionHandler, block)
+
 /**
  * Use this handler in cases you wish to include handling of exceptions by [defaultSafelyWithoutExceptionHandler] and
  * returning null at one time
diff --git a/safe_wrapper/build.gradle b/safe_wrapper/build.gradle
index 7c54502f100..854f51c5dfb 100644
--- a/safe_wrapper/build.gradle
+++ b/safe_wrapper/build.gradle
@@ -5,3 +5,13 @@ plugins {
 }
 
 apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":micro_utils.coroutines")
+            }
+        }
+    }
+}
diff --git a/safe_wrapper/src/commonMain/kotlin/SafeWrapper.kt b/safe_wrapper/src/commonMain/kotlin/SafeWrapper.kt
index f6e911189d5..6426ba6703e 100644
--- a/safe_wrapper/src/commonMain/kotlin/SafeWrapper.kt
+++ b/safe_wrapper/src/commonMain/kotlin/SafeWrapper.kt
@@ -1,8 +1,12 @@
 package dev.inmo.micro_utils.safe_wrapper
 
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+
 interface SafeWrapper<T> {
-    fun <R> safe (block: T.() -> R): Result<R> = unsafeTarget().runCatching(block)
+    fun <R> safe(block: T.() -> R): Result<R> = unsafeTarget().runCatching(block)
     fun <R> unsafe(block: T.() -> R): R = unsafeTarget().block()
+    suspend fun <R> safeS(block: suspend T.() -> R): Result<R> = unsafeTarget().runCatchingSafely(block = block)
+    suspend fun <R> unsafeS(block: suspend T.() -> R): R = unsafeTarget().block()
     fun unsafeTarget(): T
 
     class Default<T>(private val t: T) : SafeWrapper<T> { override fun unsafeTarget(): T = t }