diff --git a/example/src/getTests.ts b/example/src/getTests.ts
index 48fe50bed..9a5822c9c 100644
--- a/example/src/getTests.ts
+++ b/example/src/getTests.ts
@@ -828,33 +828,27 @@ export function getTests(
         .didNotThrow()
         .equals(433)
     ),
-    ...('getValueFromJsCallback' in testObject
-      ? [
-          createTest('getValueFromJsCallback(...)', async () =>
-            (
-              await it(async () => {
-                let value: string | undefined
-                await testObject.getValueFromJsCallback(
-                  () => 'hello',
-                  (val) => {
-                    value = val
-                  }
-                )
-                return value
-              })
-            )
-              .didNotThrow()
-              .equals('hello')
-          ),
-          createTest('getValueFromJSCallbackAndWait(...)', async () =>
-            (await it(() => testObject.getValueFromJSCallbackAndWait(() => 73)))
-              .didNotThrow()
-              .equals(73)
-          ),
-        ]
-      : [
-          // Swift/Kotlin Test Object does not support JS callbacks _that return a value_ yet!
-        ]),
+    createTest('getValueFromJsCallback(...)', async () =>
+      (
+        await it(async () => {
+          let value: string | undefined
+          await testObject.getValueFromJsCallback(
+            () => 'hello',
+            (val) => {
+              value = val
+            }
+          )
+          return value
+        })
+      )
+        .didNotThrow()
+        .equals('hello')
+    ),
+    createTest('getValueFromJSCallbackAndWait(...)', async () =>
+      (await it(() => testObject.getValueFromJSCallbackAndWait(() => 73)))
+        .didNotThrow()
+        .equals(73)
+    ),
     createTest('callAll(...)', async () =>
       (
         await it(async () => {
diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinCxxBridgedType.ts b/packages/nitrogen/src/syntax/kotlin/KotlinCxxBridgedType.ts
index 89a56d10c..f5088e559 100644
--- a/packages/nitrogen/src/syntax/kotlin/KotlinCxxBridgedType.ts
+++ b/packages/nitrogen/src/syntax/kotlin/KotlinCxxBridgedType.ts
@@ -538,7 +538,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
               // void: resolve()
               return `
 [&]() {
-  jni::local_ref<JPromise::javaobject> __promise = JPromise::create();
+  jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+  jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
   ${parameterName}->addOnResolvedListener([=]() {
     __promise->cthis()->resolve(JUnit::instance());
   });
@@ -546,14 +547,15 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
     auto __jniError = jni::getJavaExceptionForCppException(__error);
     __promise->cthis()->reject(__jniError);
   });
-  return __promise;
+  return __localPromise;
 }()
 `.trim()
             } else {
               // T: resolve(T)
               return `
 [&]() {
-  jni::local_ref<JPromise::javaobject> __promise = JPromise::create();
+  jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+  jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
   ${parameterName}->addOnResolvedListener([=](const ${resolvingType}& __result) {
     __promise->cthis()->resolve(${indent(bridge.parseFromCppToKotlin('__result', 'c++', true), '    ')});
   });
@@ -561,7 +563,7 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
     auto __jniError = jni::getJavaExceptionForCppException(__error);
     __promise->cthis()->reject(__jniError);
   });
-  return __promise;
+  return __localPromise;
 }()
 `.trim()
             }
diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts b/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts
index 4630b1c81..1c2fff81c 100644
--- a/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts
+++ b/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts
@@ -60,7 +60,8 @@ class ${name} {
 }
   `.trim()
 
-  const cppReturnType = functionType.returnType.getCode('c++')
+  const bridgedReturn = new KotlinCxxBridgedType(functionType.returnType)
+
   const cppParams = functionType.parameters.map((p) => {
     const bridge = new KotlinCxxBridgedType(p)
     const type = bridge.asJniReferenceType('alias')
@@ -73,6 +74,17 @@ class ${name} {
   const jniClassDescriptor = NitroConfig.getAndroidPackage('c++/jni', name)
   const cxxNamespace = NitroConfig.getCxxNamespace('c++')
   const typename = functionType.getCode('c++')
+  let callBody: string
+  if (functionType.returnType.kind === 'void') {
+    // It returns void
+    callBody = `_func(${indent(paramsForward.join(', '), '      ')});`
+  } else {
+    // It returns a type!
+    callBody = `
+${functionType.returnType.getCode('c++')} __result = _func(${indent(paramsForward.join(', '), '      ')});
+return ${bridgedReturn.parseFromCppToKotlin('__result', 'c++')};
+`.trim()
+  }
 
   const bridged = new KotlinCxxBridgedType(functionType)
   const imports = bridged
@@ -105,8 +117,8 @@ namespace ${cxxNamespace} {
     }
 
   public:
-    ${cppReturnType} call(${cppParams.join(', ')}) {
-      return _func(${indent(paramsForward.join(', '), '      ')});
+    ${bridgedReturn.asJniReferenceType('local')} call(${cppParams.join(', ')}) {
+      ${indent(callBody, '      ')}
     }
 
   public:
diff --git a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts
index 56761653d..77ddeb18e 100644
--- a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts
+++ b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts
@@ -341,9 +341,6 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
         const promise = getTypeAs(this.type, PromiseType)
         switch (language) {
           case 'swift': {
-            const resolvingTypeBridge = new SwiftCxxBridgedType(
-              promise.resultingType
-            )
             if (promise.resultingType.kind === 'void') {
               // It's void - resolve()
               const rejecterFunc = new FunctionType(new VoidType(), [
@@ -380,8 +377,8 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
               return `
 { () -> ${promise.getCode('swift')} in
   let __promise = ${promise.getCode('swift')}()
-  let __resolver = { (__result: ${resolvingTypeBridge.getTypeCode('swift')}) in
-    __promise.resolve(withResult: ${indent(resolvingTypeBridge.parseFromCppToSwift('__result', 'swift'), '    ')})
+  let __resolver = { (__result: ${promise.resultingType.getCode('swift')}) in
+    __promise.resolve(withResult: __result)
   }
   let __rejecter = { (__error: Error) in
     __promise.reject(withError: __error)
@@ -543,7 +540,7 @@ case ${i}:
   let __sharedClosure = bridge.share_${bridge.specializationName}(${cppParameterName})
   return { ${signature} in
     let __result = __sharedClosure.pointee.call(${paramsForward.join(', ')})
-    return ${indent(resultBridged.parseFromSwiftToCpp('__result', 'swift'), '  ')}
+    return ${indent(resultBridged.parseFromCppToSwift('__result', 'swift'), '    ')}
   }
 }()`.trim()
             }
diff --git a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt
index 7f3db0633..20eac13a5 100644
--- a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt
+++ b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt
@@ -167,6 +167,20 @@ class HybridTestObjectKotlin: HybridTestObjectSwiftKotlinSpec() {
         callback(value)
     }
 
+    override fun getValueFromJSCallbackAndWait(getValue: (() -> Promise<Double>)): Promise<Double> {
+        return Promise.async {
+            val jsResult = getValue().await()
+            return@async jsResult
+        }
+    }
+
+    override fun getValueFromJsCallback(callback: (() -> Promise<String>), andThenCall: ((valueFromJs: String) -> Unit)): Promise<Unit> {
+        return Promise.async {
+            val jsResult = callback().await()
+            andThenCall(jsResult)
+        }
+    }
+
     override fun callAll(first: () -> Unit, second: () -> Unit, third: () -> Unit) {
         first()
         second()
diff --git a/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift
index 35a38edd1..fd108adc9 100644
--- a/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift
+++ b/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift
@@ -61,6 +61,21 @@ class HybridTestObjectSwift : HybridTestObjectSwiftKotlinSpec {
   func callWithOptional(value: Double?, callback: @escaping ((_ maybe: Double?) -> Void)) throws -> Void {
     callback(value)
   }
+  
+  func getValueFromJSCallbackAndWait(getValue: @escaping (() -> Promise<Double>)) throws -> Promise<Double> {
+    return .async {
+      let jsResult = try await getValue().await()
+      return jsResult
+    }
+  }
+  
+  func getValueFromJsCallback(callback: @escaping (() -> Promise<String>), andThenCall: @escaping ((_ valueFromJs: String) -> Void)) throws -> Promise<Void> {
+    return .async {
+      let jsResult = try await callback().await()
+      andThenCall(jsResult)
+    }
+  }
+
 
   func bounceStrings(array: [String]) throws -> [String] {
     return array
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/NitroImageOnLoad.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/NitroImageOnLoad.cpp
index e9406c02a..5b8996e32 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/NitroImageOnLoad.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/NitroImageOnLoad.cpp
@@ -18,6 +18,8 @@
 #include "JFunc_void_std__vector_Powertrain_.hpp"
 #include "JFunc_void.hpp"
 #include "JFunc_void_std__optional_double_.hpp"
+#include "JFunc_std__shared_ptr_Promise_double__.hpp"
+#include "JFunc_std__shared_ptr_Promise_std__string__.hpp"
 #include "JHybridBaseSpec.hpp"
 #include "JHybridChildSpec.hpp"
 #include <NitroModules/JNISharedPtr.hpp>
@@ -43,6 +45,9 @@ int initialize(JavaVM* vm) {
     margelo::nitro::image::JFunc_void::registerNatives();
     margelo::nitro::image::JFunc_void::registerNatives();
     margelo::nitro::image::JFunc_void_std__optional_double_::registerNatives();
+    margelo::nitro::image::JFunc_std__shared_ptr_Promise_double__::registerNatives();
+    margelo::nitro::image::JFunc_std__shared_ptr_Promise_std__string__::registerNatives();
+    margelo::nitro::image::JFunc_void_std__string::registerNatives();
     margelo::nitro::image::JHybridBaseSpec::registerNatives();
     margelo::nitro::image::JHybridChildSpec::registerNatives();
 
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_double__.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_double__.hpp
new file mode 100644
index 000000000..0635dcb64
--- /dev/null
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_double__.hpp
@@ -0,0 +1,62 @@
+///
+/// JFunc_std__shared_ptr_Promise_double__.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+
+namespace margelo::nitro::image {
+
+  using namespace facebook;
+
+  /**
+   * C++ representation of the callback Func_std__shared_ptr_Promise_double__.
+   * This is a Kotlin `() -> Promise<Double>`, backed by a `std::function<...>`.
+   */
+  struct JFunc_std__shared_ptr_Promise_double__ final: public jni::HybridClass<JFunc_std__shared_ptr_Promise_double__> {
+  public:
+    static jni::local_ref<JFunc_std__shared_ptr_Promise_double__::javaobject> fromCpp(const std::function<std::shared_ptr<Promise<double>>()>& func) {
+      return JFunc_std__shared_ptr_Promise_double__::newObjectCxxArgs(func);
+    }
+
+  public:
+    jni::local_ref<JPromise::javaobject> call() {
+      std::shared_ptr<Promise<double>> __result = _func();
+      return [&]() {
+        jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+        jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
+        __result->addOnResolvedListener([=](const double& __result) {
+          __promise->cthis()->resolve(jni::JDouble::valueOf(__result));
+        });
+        __result->addOnRejectedListener([=](const std::exception_ptr& __error) {
+          auto __jniError = jni::getJavaExceptionForCppException(__error);
+          __promise->cthis()->reject(__jniError);
+        });
+        return __localPromise;
+      }();
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_std__shared_ptr_Promise_double__;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("call", JFunc_std__shared_ptr_Promise_double__::call)});
+    }
+
+  private:
+    explicit JFunc_std__shared_ptr_Promise_double__(const std::function<std::shared_ptr<Promise<double>>()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<std::shared_ptr<Promise<double>>()> _func;
+  };
+
+} // namespace margelo::nitro::image
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_std__string__.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_std__string__.hpp
new file mode 100644
index 000000000..d75fb1180
--- /dev/null
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_std__string__.hpp
@@ -0,0 +1,63 @@
+///
+/// JFunc_std__shared_ptr_Promise_std__string__.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <NitroModules/JPromise.hpp>
+
+namespace margelo::nitro::image {
+
+  using namespace facebook;
+
+  /**
+   * C++ representation of the callback Func_std__shared_ptr_Promise_std__string__.
+   * This is a Kotlin `() -> Promise<String>`, backed by a `std::function<...>`.
+   */
+  struct JFunc_std__shared_ptr_Promise_std__string__ final: public jni::HybridClass<JFunc_std__shared_ptr_Promise_std__string__> {
+  public:
+    static jni::local_ref<JFunc_std__shared_ptr_Promise_std__string__::javaobject> fromCpp(const std::function<std::shared_ptr<Promise<std::string>>()>& func) {
+      return JFunc_std__shared_ptr_Promise_std__string__::newObjectCxxArgs(func);
+    }
+
+  public:
+    jni::local_ref<JPromise::javaobject> call() {
+      std::shared_ptr<Promise<std::string>> __result = _func();
+      return [&]() {
+        jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+        jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
+        __result->addOnResolvedListener([=](const std::string& __result) {
+          __promise->cthis()->resolve(jni::make_jstring(__result));
+        });
+        __result->addOnRejectedListener([=](const std::exception_ptr& __error) {
+          auto __jniError = jni::getJavaExceptionForCppException(__error);
+          __promise->cthis()->reject(__jniError);
+        });
+        return __localPromise;
+      }();
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_std__shared_ptr_Promise_std__string__;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("call", JFunc_std__shared_ptr_Promise_std__string__::call)});
+    }
+
+  private:
+    explicit JFunc_std__shared_ptr_Promise_std__string__(const std::function<std::shared_ptr<Promise<std::string>>()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<std::shared_ptr<Promise<std::string>>()> _func;
+  };
+
+} // namespace margelo::nitro::image
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void.hpp
index d435e2942..ff66ac3fd 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void.hpp
@@ -28,7 +28,7 @@ namespace margelo::nitro::image {
 
   public:
     void call() {
-      return _func();
+      _func();
     }
 
   public:
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__optional_double_.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__optional_double_.hpp
index f52bd30eb..f974dc2d4 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__optional_double_.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__optional_double_.hpp
@@ -29,7 +29,7 @@ namespace margelo::nitro::image {
 
   public:
     void call(jni::alias_ref<jni::JDouble> maybe) {
-      return _func(maybe != nullptr ? std::make_optional(maybe->value()) : std::nullopt);
+      _func(maybe != nullptr ? std::make_optional(maybe->value()) : std::nullopt);
     }
 
   public:
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__string.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__string.hpp
index 762af03b3..3aa8af789 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__string.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__string.hpp
@@ -19,17 +19,17 @@ namespace margelo::nitro::image {
 
   /**
    * C++ representation of the callback Func_void_std__string.
-   * This is a Kotlin `(path: String) -> Unit`, backed by a `std::function<...>`.
+   * This is a Kotlin `(valueFromJs: String) -> Unit`, backed by a `std::function<...>`.
    */
   struct JFunc_void_std__string final: public jni::HybridClass<JFunc_void_std__string> {
   public:
-    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* path */)>& func) {
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* valueFromJs */)>& func) {
       return JFunc_void_std__string::newObjectCxxArgs(func);
     }
 
   public:
-    void call(jni::alias_ref<jni::JString> path) {
-      return _func(path->toStdString());
+    void call(jni::alias_ref<jni::JString> valueFromJs) {
+      _func(valueFromJs->toStdString());
     }
 
   public:
@@ -39,11 +39,11 @@ namespace margelo::nitro::image {
     }
 
   private:
-    explicit JFunc_void_std__string(const std::function<void(const std::string& /* path */)>& func): _func(func) { }
+    explicit JFunc_void_std__string(const std::function<void(const std::string& /* valueFromJs */)>& func): _func(func) { }
 
   private:
     friend HybridBase;
-    std::function<void(const std::string& /* path */)> _func;
+    std::function<void(const std::string& /* valueFromJs */)> _func;
   };
 
 } // namespace margelo::nitro::image
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__vector_Powertrain_.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__vector_Powertrain_.hpp
index b36ee8351..66f574887 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__vector_Powertrain_.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__vector_Powertrain_.hpp
@@ -31,16 +31,16 @@ namespace margelo::nitro::image {
 
   public:
     void call(jni::alias_ref<jni::JArrayClass<JPowertrain>> array) {
-      return _func([&]() {
-        size_t __size = array->size();
-        std::vector<Powertrain> __vector;
-        __vector.reserve(__size);
-        for (size_t __i = 0; __i < __size; __i++) {
-          auto __element = array->getElement(__i);
-          __vector.push_back(__element->toCpp());
-        }
-        return __vector;
-      }());
+      _func([&]() {
+              size_t __size = array->size();
+              std::vector<Powertrain> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = array->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
     }
 
   public:
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
index 0492bac39..d4fa2eee0 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
@@ -59,6 +59,9 @@ namespace margelo::nitro::image { class HybridBaseSpec; }
 #include <exception>
 #include "JFunc_void.hpp"
 #include "JFunc_void_std__optional_double_.hpp"
+#include "JFunc_std__shared_ptr_Promise_double__.hpp"
+#include "JFunc_std__shared_ptr_Promise_std__string__.hpp"
+#include "JFunc_void_std__string.hpp"
 
 namespace margelo::nitro::image {
 
@@ -414,7 +417,8 @@ namespace margelo::nitro::image {
   std::shared_ptr<Promise<double>> JHybridTestObjectSwiftKotlinSpec::awaitAndGetPromise(const std::shared_ptr<Promise<double>>& promise) {
     static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPromise::javaobject> /* promise */)>("awaitAndGetPromise");
     auto __result = method(_javaPart, [&]() {
-      jni::local_ref<JPromise::javaobject> __promise = JPromise::create();
+      jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+      jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
       promise->addOnResolvedListener([=](const double& __result) {
         __promise->cthis()->resolve(jni::JDouble::valueOf(__result));
       });
@@ -422,7 +426,7 @@ namespace margelo::nitro::image {
         auto __jniError = jni::getJavaExceptionForCppException(__error);
         __promise->cthis()->reject(__jniError);
       });
-      return __promise;
+      return __localPromise;
     }());
     return [&]() {
       auto __promise = Promise<double>::create();
@@ -440,7 +444,8 @@ namespace margelo::nitro::image {
   std::shared_ptr<Promise<Car>> JHybridTestObjectSwiftKotlinSpec::awaitAndGetComplexPromise(const std::shared_ptr<Promise<Car>>& promise) {
     static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPromise::javaobject> /* promise */)>("awaitAndGetComplexPromise");
     auto __result = method(_javaPart, [&]() {
-      jni::local_ref<JPromise::javaobject> __promise = JPromise::create();
+      jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+      jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
       promise->addOnResolvedListener([=](const Car& __result) {
         __promise->cthis()->resolve(JCar::fromCpp(__result));
       });
@@ -448,7 +453,7 @@ namespace margelo::nitro::image {
         auto __jniError = jni::getJavaExceptionForCppException(__error);
         __promise->cthis()->reject(__jniError);
       });
-      return __promise;
+      return __localPromise;
     }());
     return [&]() {
       auto __promise = Promise<Car>::create();
@@ -466,7 +471,8 @@ namespace margelo::nitro::image {
   std::shared_ptr<Promise<void>> JHybridTestObjectSwiftKotlinSpec::awaitPromise(const std::shared_ptr<Promise<void>>& promise) {
     static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPromise::javaobject> /* promise */)>("awaitPromise");
     auto __result = method(_javaPart, [&]() {
-      jni::local_ref<JPromise::javaobject> __promise = JPromise::create();
+      jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+      jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
       promise->addOnResolvedListener([=]() {
         __promise->cthis()->resolve(JUnit::instance());
       });
@@ -474,7 +480,7 @@ namespace margelo::nitro::image {
         auto __jniError = jni::getJavaExceptionForCppException(__error);
         __promise->cthis()->reject(__jniError);
       });
-      return __promise;
+      return __localPromise;
     }());
     return [&]() {
       auto __promise = Promise<void>::create();
@@ -500,6 +506,37 @@ namespace margelo::nitro::image {
     static const auto method = _javaPart->getClass()->getMethod<void(jni::alias_ref<jni::JDouble> /* value */, jni::alias_ref<JFunc_void_std__optional_double_::javaobject> /* callback */)>("callWithOptional");
     method(_javaPart, value.has_value() ? jni::JDouble::valueOf(value.value()) : nullptr, JFunc_void_std__optional_double_::fromCpp(callback));
   }
+  std::shared_ptr<Promise<double>> JHybridTestObjectSwiftKotlinSpec::getValueFromJSCallbackAndWait(const std::function<std::shared_ptr<Promise<double>>()>& getValue) {
+    static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JFunc_std__shared_ptr_Promise_double__::javaobject> /* getValue */)>("getValueFromJSCallbackAndWait");
+    auto __result = method(_javaPart, JFunc_std__shared_ptr_Promise_double__::fromCpp(getValue));
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTestObjectSwiftKotlinSpec::getValueFromJsCallback(const std::function<std::shared_ptr<Promise<std::string>>()>& callback, const std::function<void(const std::string& /* valueFromJs */)>& andThenCall) {
+    static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JFunc_std__shared_ptr_Promise_std__string__::javaobject> /* callback */, jni::alias_ref<JFunc_void_std__string::javaobject> /* andThenCall */)>("getValueFromJsCallback");
+    auto __result = method(_javaPart, JFunc_std__shared_ptr_Promise_std__string__::fromCpp(callback), JFunc_void_std__string::fromCpp(andThenCall));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
   Car JHybridTestObjectSwiftKotlinSpec::getCar() {
     static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JCar>()>("getCar");
     auto __result = method(_javaPart);
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
index 4529d12ae..1594402b9 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
@@ -102,6 +102,8 @@ namespace margelo::nitro::image {
     void callCallback(const std::function<void()>& callback) override;
     void callAll(const std::function<void()>& first, const std::function<void()>& second, const std::function<void()>& third) override;
     void callWithOptional(std::optional<double> value, const std::function<void(std::optional<double> /* maybe */)>& callback) override;
+    std::shared_ptr<Promise<double>> getValueFromJSCallbackAndWait(const std::function<std::shared_ptr<Promise<double>>()>& getValue) override;
+    std::shared_ptr<Promise<void>> getValueFromJsCallback(const std::function<std::shared_ptr<Promise<std::string>>()>& callback, const std::function<void(const std::string& /* valueFromJs */)>& andThenCall) override;
     Car getCar() override;
     bool isCarElectric(const Car& car) override;
     std::optional<Person> getDriver(const Car& car) override;
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_std__shared_ptr_Promise_double__.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_std__shared_ptr_Promise_double__.kt
new file mode 100644
index 000000000..ab11421e9
--- /dev/null
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_std__shared_ptr_Promise_double__.kt
@@ -0,0 +1,46 @@
+///
+/// Func_std__shared_ptr_Promise_double__.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.image
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+import dalvik.annotation.optimization.FastNative
+
+/**
+ * Represents the JavaScript callback `() => std::shared_ptr<Promise<double>>`.
+ * This is implemented in C++, via a `std::function<...>`.
+ */
+@DoNotStrip
+@Keep
+@Suppress("RedundantSuppression", "ConvertSecondaryConstructorToPrimary", "RedundantUnitReturnType", "KotlinJniMissingFunction", "ClassName", "unused")
+class Func_std__shared_ptr_Promise_double__ {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  /**
+   * Converts this function to a Kotlin Lambda.
+   * This exists purely as syntactic sugar, and has minimal runtime overhead.
+   */
+  fun toLambda(): () -> Promise<Double> = this::call
+
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @FastNative
+  external fun call(): Promise<Double>
+}
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_std__shared_ptr_Promise_std__string__.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_std__shared_ptr_Promise_std__string__.kt
new file mode 100644
index 000000000..e444f3ff9
--- /dev/null
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_std__shared_ptr_Promise_std__string__.kt
@@ -0,0 +1,46 @@
+///
+/// Func_std__shared_ptr_Promise_std__string__.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.image
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+import dalvik.annotation.optimization.FastNative
+
+/**
+ * Represents the JavaScript callback `() => std::shared_ptr<Promise<std::string>>`.
+ * This is implemented in C++, via a `std::function<...>`.
+ */
+@DoNotStrip
+@Keep
+@Suppress("RedundantSuppression", "ConvertSecondaryConstructorToPrimary", "RedundantUnitReturnType", "KotlinJniMissingFunction", "ClassName", "unused")
+class Func_std__shared_ptr_Promise_std__string__ {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  /**
+   * Converts this function to a Kotlin Lambda.
+   * This exists purely as syntactic sugar, and has minimal runtime overhead.
+   */
+  fun toLambda(): () -> Promise<String> = this::call
+
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @FastNative
+  external fun call(): Promise<String>
+}
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_void_std__string.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_void_std__string.kt
index 190621d8b..8ec0e4236 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_void_std__string.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Func_void_std__string.kt
@@ -14,7 +14,7 @@ import com.margelo.nitro.core.*
 import dalvik.annotation.optimization.FastNative
 
 /**
- * Represents the JavaScript callback `(path: string) => void`.
+ * Represents the JavaScript callback `(valueFromJs: string) => void`.
  * This is implemented in C++, via a `std::function<...>`.
  */
 @DoNotStrip
@@ -35,12 +35,12 @@ class Func_void_std__string {
    * Converts this function to a Kotlin Lambda.
    * This exists purely as syntactic sugar, and has minimal runtime overhead.
    */
-  fun toLambda(): (path: String) -> Unit = this::call
+  fun toLambda(): (valueFromJs: String) -> Unit = this::call
 
   /**
    * Call the given JS callback.
    * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
    */
   @FastNative
-  external fun call(path: String): Unit
+  external fun call(valueFromJs: String): Unit
 }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
index 7dc7e9d7b..2c87b8934 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
@@ -251,6 +251,28 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
     return __result
   }
   
+  @DoNotStrip
+  @Keep
+  abstract fun getValueFromJSCallbackAndWait(getValue: () -> Promise<Double>): Promise<Double>
+  
+  @DoNotStrip
+  @Keep
+  private fun getValueFromJSCallbackAndWait(getValue: Func_std__shared_ptr_Promise_double__): Promise<Double> {
+    val __result = getValueFromJSCallbackAndWait(getValue.toLambda())
+    return __result
+  }
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getValueFromJsCallback(callback: () -> Promise<String>, andThenCall: (valueFromJs: String) -> Unit): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  private fun getValueFromJsCallback(callback: Func_std__shared_ptr_Promise_std__string__, andThenCall: Func_void_std__string): Promise<Unit> {
+    val __result = getValueFromJsCallback(callback.toLambda(), andThenCall.toLambda())
+    return __result
+  }
+  
   @DoNotStrip
   @Keep
   abstract fun getCar(): Car
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp
index a94db6844..40bbf83fa 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp
@@ -499,6 +499,75 @@ namespace margelo::nitro::image::bridge::swift {
     return std::make_shared<Func_void_std__optional_double__Wrapper>(value);
   }
   
+  // pragma MARK: std::function<std::shared_ptr<Promise<double>>()>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<double>>()>`.
+   */
+  using Func_std__shared_ptr_Promise_double__ = std::function<std::shared_ptr<Promise<double>>()>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<double>>()>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_double___Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_double___Wrapper(const std::function<std::shared_ptr<Promise<double>>()>& func): _function(func) {}
+    explicit Func_std__shared_ptr_Promise_double___Wrapper(std::function<std::shared_ptr<Promise<double>>()>&& func): _function(std::move(func)) {}
+    inline std::shared_ptr<Promise<double>> call() const {
+      auto __result = _function();
+      return __result;
+    }
+  private:
+    std::function<std::shared_ptr<Promise<double>>()> _function;
+  };
+  inline Func_std__shared_ptr_Promise_double__ create_Func_std__shared_ptr_Promise_double__(void* _Nonnull closureHolder, std::shared_ptr<Promise<double>>(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) {
+    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
+    return Func_std__shared_ptr_Promise_double__([sharedClosureHolder, call]() -> std::shared_ptr<Promise<double>> {
+      auto __result = call(sharedClosureHolder.get());
+      return __result;
+    });
+  }
+  inline std::shared_ptr<Func_std__shared_ptr_Promise_double___Wrapper> share_Func_std__shared_ptr_Promise_double__(const Func_std__shared_ptr_Promise_double__& value) {
+    return std::make_shared<Func_std__shared_ptr_Promise_double___Wrapper>(value);
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::string>>()>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::string>>()>`.
+   */
+  using Func_std__shared_ptr_Promise_std__string__ = std::function<std::shared_ptr<Promise<std::string>>()>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::string>>()>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__string___Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__string___Wrapper(const std::function<std::shared_ptr<Promise<std::string>>()>& func): _function(func) {}
+    explicit Func_std__shared_ptr_Promise_std__string___Wrapper(std::function<std::shared_ptr<Promise<std::string>>()>&& func): _function(std::move(func)) {}
+    inline std::shared_ptr<Promise<std::string>> call() const {
+      auto __result = _function();
+      return __result;
+    }
+  private:
+    std::function<std::shared_ptr<Promise<std::string>>()> _function;
+  };
+  inline Func_std__shared_ptr_Promise_std__string__ create_Func_std__shared_ptr_Promise_std__string__(void* _Nonnull closureHolder, std::shared_ptr<Promise<std::string>>(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) {
+    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
+    return Func_std__shared_ptr_Promise_std__string__([sharedClosureHolder, call]() -> std::shared_ptr<Promise<std::string>> {
+      auto __result = call(sharedClosureHolder.get());
+      return __result;
+    });
+  }
+  inline std::shared_ptr<Func_std__shared_ptr_Promise_std__string___Wrapper> share_Func_std__shared_ptr_Promise_std__string__(const Func_std__shared_ptr_Promise_std__string__& value) {
+    return std::make_shared<Func_std__shared_ptr_Promise_std__string___Wrapper>(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   */
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
+    return Promise<std::string>::create();
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>`.
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
index 6a9958923..803be496c 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
@@ -280,6 +280,14 @@ namespace margelo::nitro::image {
     inline void callWithOptional(std::optional<double> value, const std::function<void(std::optional<double> /* maybe */)>& callback) override {
       _swiftPart.callWithOptional(value, callback);
     }
+    inline std::shared_ptr<Promise<double>> getValueFromJSCallbackAndWait(const std::function<std::shared_ptr<Promise<double>>()>& getValue) override {
+      auto __result = _swiftPart.getValueFromJSCallbackAndWait(getValue);
+      return __result;
+    }
+    inline std::shared_ptr<Promise<void>> getValueFromJsCallback(const std::function<std::shared_ptr<Promise<std::string>>()>& callback, const std::function<void(const std::string& /* valueFromJs */)>& andThenCall) override {
+      auto __result = _swiftPart.getValueFromJsCallback(callback, andThenCall);
+      return __result;
+    }
     inline Car getCar() override {
       auto __result = _swiftPart.getCar();
       return __result;
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
index c4c4e34f1..5551071d1 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
@@ -71,6 +71,8 @@ public protocol HybridTestObjectSwiftKotlinSpec: AnyObject, HybridObjectSpec {
   func callCallback(callback: @escaping (() -> Void)) throws -> Void
   func callAll(first: @escaping (() -> Void), second: @escaping (() -> Void), third: @escaping (() -> Void)) throws -> Void
   func callWithOptional(value: Double?, callback: @escaping ((_ maybe: Double?) -> Void)) throws -> Void
+  func getValueFromJSCallbackAndWait(getValue: @escaping (() -> Promise<Double>)) throws -> Promise<Double>
+  func getValueFromJsCallback(callback: @escaping (() -> Promise<String>), andThenCall: @escaping ((_ valueFromJs: String) -> Void)) throws -> Promise<Void>
   func getCar() throws -> Car
   func isCarElectric(car: Car) throws -> Bool
   func getDriver(car: Car) throws -> Person?
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpecCxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpecCxx.swift
index fe89bf6d4..e39c3b136 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpecCxx.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpecCxx.swift
@@ -900,6 +900,167 @@ public class HybridTestObjectSwiftKotlinSpecCxx {
     }
   }
   
+  @inline(__always)
+  public func getValueFromJSCallbackAndWait(getValue: bridge.Func_std__shared_ptr_Promise_double__) -> bridge.std__shared_ptr_Promise_double__ {
+    do {
+      let __result = try self.__implementation.getValueFromJSCallbackAndWait(getValue: { () -> (() -> Promise<Double>) in
+        let __sharedClosure = bridge.share_Func_std__shared_ptr_Promise_double__(getValue)
+        return { () -> Promise<Double> in
+          let __result = __sharedClosure.pointee.call()
+          return { () -> Promise<Double> in
+            let __promise = Promise<Double>()
+            let __resolver = { (__result: Double) in
+              __promise.resolve(withResult: __result)
+            }
+            let __rejecter = { (__error: Error) in
+              __promise.reject(withError: __error)
+            }
+            let __resolverCpp = { () -> bridge.Func_void_double in
+              class ClosureHolder {
+                let closure: ((_ result: Double) -> Void)
+                init(wrappingClosure closure: @escaping ((_ result: Double) -> Void)) {
+                  self.closure = closure
+                }
+                func invoke(_ __result: Double) {
+                  self.closure(__result)
+                }
+              }
+            
+              let __closureHolder = Unmanaged.passRetained(ClosureHolder(wrappingClosure: __resolver)).toOpaque()
+              func __callClosure(__closureHolder: UnsafeMutableRawPointer, __result: Double) -> Void {
+                let closure = Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).takeUnretainedValue()
+                closure.invoke(__result)
+              }
+              func __destroyClosure(_ __closureHolder: UnsafeMutableRawPointer) -> Void {
+                Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).release()
+              }
+            
+              return bridge.create_Func_void_double(__closureHolder, __callClosure, __destroyClosure)
+            }()
+            let __rejecterCpp = { () -> bridge.Func_void_std__exception_ptr in
+              class ClosureHolder {
+                let closure: ((_ error: Error) -> Void)
+                init(wrappingClosure closure: @escaping ((_ error: Error) -> Void)) {
+                  self.closure = closure
+                }
+                func invoke(_ __error: Error) {
+                  self.closure(__error)
+                }
+              }
+            
+              let __closureHolder = Unmanaged.passRetained(ClosureHolder(wrappingClosure: __rejecter)).toOpaque()
+              func __callClosure(__closureHolder: UnsafeMutableRawPointer, __error: std.exception_ptr) -> Void {
+                let closure = Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).takeUnretainedValue()
+                closure.invoke(RuntimeError.from(cppError: __error))
+              }
+              func __destroyClosure(_ __closureHolder: UnsafeMutableRawPointer) -> Void {
+                Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).release()
+              }
+            
+              return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure)
+            }()
+            __result.pointee.addOnResolvedListenerCopy(__resolverCpp)
+            __result.pointee.addOnRejectedListener(__rejecterCpp)
+            return __promise
+          }()
+        }
+      }())
+      return { () -> bridge.std__shared_ptr_Promise_double__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_double__()
+        __result
+          .then({ __result in __promise.pointee.resolve(__result) })
+          .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
+        return __promise
+      }()
+    } catch {
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+    }
+  }
+  
+  @inline(__always)
+  public func getValueFromJsCallback(callback: bridge.Func_std__shared_ptr_Promise_std__string__, andThenCall: bridge.Func_void_std__string) -> bridge.std__shared_ptr_Promise_void__ {
+    do {
+      let __result = try self.__implementation.getValueFromJsCallback(callback: { () -> (() -> Promise<String>) in
+        let __sharedClosure = bridge.share_Func_std__shared_ptr_Promise_std__string__(callback)
+        return { () -> Promise<String> in
+          let __result = __sharedClosure.pointee.call()
+          return { () -> Promise<String> in
+            let __promise = Promise<String>()
+            let __resolver = { (__result: String) in
+              __promise.resolve(withResult: __result)
+            }
+            let __rejecter = { (__error: Error) in
+              __promise.reject(withError: __error)
+            }
+            let __resolverCpp = { () -> bridge.Func_void_std__string in
+              class ClosureHolder {
+                let closure: ((_ result: String) -> Void)
+                init(wrappingClosure closure: @escaping ((_ result: String) -> Void)) {
+                  self.closure = closure
+                }
+                func invoke(_ __result: String) {
+                  self.closure(__result)
+                }
+              }
+            
+              let __closureHolder = Unmanaged.passRetained(ClosureHolder(wrappingClosure: __resolver)).toOpaque()
+              func __callClosure(__closureHolder: UnsafeMutableRawPointer, __result: std.string) -> Void {
+                let closure = Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).takeUnretainedValue()
+                closure.invoke(String(__result))
+              }
+              func __destroyClosure(_ __closureHolder: UnsafeMutableRawPointer) -> Void {
+                Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).release()
+              }
+            
+              return bridge.create_Func_void_std__string(__closureHolder, __callClosure, __destroyClosure)
+            }()
+            let __rejecterCpp = { () -> bridge.Func_void_std__exception_ptr in
+              class ClosureHolder {
+                let closure: ((_ error: Error) -> Void)
+                init(wrappingClosure closure: @escaping ((_ error: Error) -> Void)) {
+                  self.closure = closure
+                }
+                func invoke(_ __error: Error) {
+                  self.closure(__error)
+                }
+              }
+            
+              let __closureHolder = Unmanaged.passRetained(ClosureHolder(wrappingClosure: __rejecter)).toOpaque()
+              func __callClosure(__closureHolder: UnsafeMutableRawPointer, __error: std.exception_ptr) -> Void {
+                let closure = Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).takeUnretainedValue()
+                closure.invoke(RuntimeError.from(cppError: __error))
+              }
+              func __destroyClosure(_ __closureHolder: UnsafeMutableRawPointer) -> Void {
+                Unmanaged<ClosureHolder>.fromOpaque(__closureHolder).release()
+              }
+            
+              return bridge.create_Func_void_std__exception_ptr(__closureHolder, __callClosure, __destroyClosure)
+            }()
+            __result.pointee.addOnResolvedListener(__resolverCpp)
+            __result.pointee.addOnRejectedListener(__rejecterCpp)
+            return __promise
+          }()
+        }
+      }(), andThenCall: { () -> ((String) -> Void) in
+        let __sharedClosure = bridge.share_Func_void_std__string(andThenCall)
+        return { (__valueFromJs: String) -> Void in
+          __sharedClosure.pointee.call(std.string(__valueFromJs))
+        }
+      }())
+      return { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        __result
+          .then({ __result in __promise.pointee.resolve() })
+          .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
+        return __promise
+      }()
+    } catch {
+      let __message = "\(error.localizedDescription)"
+      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+    }
+  }
+  
   @inline(__always)
   public func getCar() -> Car {
     do {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
index a22f4f4de..60484e1d3 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
@@ -48,8 +48,6 @@ namespace margelo::nitro::image {
       prototype.registerHybridMethod("getVariantTuple", &HybridTestObjectCppSpec::getVariantTuple);
       prototype.registerHybridMethod("flip", &HybridTestObjectCppSpec::flip);
       prototype.registerHybridMethod("passTuple", &HybridTestObjectCppSpec::passTuple);
-      prototype.registerHybridMethod("getValueFromJSCallbackAndWait", &HybridTestObjectCppSpec::getValueFromJSCallbackAndWait);
-      prototype.registerHybridMethod("getValueFromJsCallback", &HybridTestObjectCppSpec::getValueFromJsCallback);
       prototype.registerHybridMethod("newTestObject", &HybridTestObjectCppSpec::newTestObject);
       prototype.registerHybridMethod("simpleFunc", &HybridTestObjectCppSpec::simpleFunc);
       prototype.registerHybridMethod("addNumbers", &HybridTestObjectCppSpec::addNumbers);
@@ -77,6 +75,8 @@ namespace margelo::nitro::image {
       prototype.registerHybridMethod("callCallback", &HybridTestObjectCppSpec::callCallback);
       prototype.registerHybridMethod("callAll", &HybridTestObjectCppSpec::callAll);
       prototype.registerHybridMethod("callWithOptional", &HybridTestObjectCppSpec::callWithOptional);
+      prototype.registerHybridMethod("getValueFromJSCallbackAndWait", &HybridTestObjectCppSpec::getValueFromJSCallbackAndWait);
+      prototype.registerHybridMethod("getValueFromJsCallback", &HybridTestObjectCppSpec::getValueFromJsCallback);
       prototype.registerHybridMethod("getCar", &HybridTestObjectCppSpec::getCar);
       prototype.registerHybridMethod("isCarElectric", &HybridTestObjectCppSpec::isCarElectric);
       prototype.registerHybridMethod("getDriver", &HybridTestObjectCppSpec::getDriver);
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
index b686aee0b..38eb41fd2 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
@@ -43,10 +43,10 @@ namespace margelo::nitro::image { class HybridBaseSpec; }
 #include <variant>
 #include "Car.hpp"
 #include "Person.hpp"
-#include <NitroModules/Promise.hpp>
 #include <functional>
 #include <NitroModules/AnyMap.hpp>
 #include <exception>
+#include <NitroModules/Promise.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
 #include "HybridChildSpec.hpp"
 #include "HybridBaseSpec.hpp"
@@ -115,8 +115,6 @@ namespace margelo::nitro::image {
       virtual std::variant<std::tuple<double, double>, std::tuple<double, double, double>> getVariantTuple(const std::variant<std::tuple<double, double>, std::tuple<double, double, double>>& variant) = 0;
       virtual std::tuple<double, double, double> flip(const std::tuple<double, double, double>& tuple) = 0;
       virtual std::tuple<double, std::string, bool> passTuple(const std::tuple<double, std::string, bool>& tuple) = 0;
-      virtual std::shared_ptr<Promise<double>> getValueFromJSCallbackAndWait(const std::function<std::shared_ptr<Promise<double>>()>& getValue) = 0;
-      virtual std::shared_ptr<Promise<void>> getValueFromJsCallback(const std::function<std::shared_ptr<Promise<std::string>>()>& callback, const std::function<void(const std::string& /* valueFromJs */)>& andThenCall) = 0;
       virtual std::shared_ptr<margelo::nitro::image::HybridTestObjectCppSpec> newTestObject() = 0;
       virtual void simpleFunc() = 0;
       virtual double addNumbers(double a, double b) = 0;
@@ -144,6 +142,8 @@ namespace margelo::nitro::image {
       virtual void callCallback(const std::function<void()>& callback) = 0;
       virtual void callAll(const std::function<void()>& first, const std::function<void()>& second, const std::function<void()>& third) = 0;
       virtual void callWithOptional(std::optional<double> value, const std::function<void(std::optional<double> /* maybe */)>& callback) = 0;
+      virtual std::shared_ptr<Promise<double>> getValueFromJSCallbackAndWait(const std::function<std::shared_ptr<Promise<double>>()>& getValue) = 0;
+      virtual std::shared_ptr<Promise<void>> getValueFromJsCallback(const std::function<std::shared_ptr<Promise<std::string>>()>& callback, const std::function<void(const std::string& /* valueFromJs */)>& andThenCall) = 0;
       virtual Car getCar() = 0;
       virtual bool isCarElectric(const Car& car) = 0;
       virtual std::optional<Person> getDriver(const Car& car) = 0;
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
index dc459d06b..1d351c012 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
@@ -66,6 +66,8 @@ namespace margelo::nitro::image {
       prototype.registerHybridMethod("callCallback", &HybridTestObjectSwiftKotlinSpec::callCallback);
       prototype.registerHybridMethod("callAll", &HybridTestObjectSwiftKotlinSpec::callAll);
       prototype.registerHybridMethod("callWithOptional", &HybridTestObjectSwiftKotlinSpec::callWithOptional);
+      prototype.registerHybridMethod("getValueFromJSCallbackAndWait", &HybridTestObjectSwiftKotlinSpec::getValueFromJSCallbackAndWait);
+      prototype.registerHybridMethod("getValueFromJsCallback", &HybridTestObjectSwiftKotlinSpec::getValueFromJsCallback);
       prototype.registerHybridMethod("getCar", &HybridTestObjectSwiftKotlinSpec::getCar);
       prototype.registerHybridMethod("isCarElectric", &HybridTestObjectSwiftKotlinSpec::isCarElectric);
       prototype.registerHybridMethod("getDriver", &HybridTestObjectSwiftKotlinSpec::getDriver);
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
index 30b6336a7..fd28291cc 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
@@ -132,6 +132,8 @@ namespace margelo::nitro::image {
       virtual void callCallback(const std::function<void()>& callback) = 0;
       virtual void callAll(const std::function<void()>& first, const std::function<void()>& second, const std::function<void()>& third) = 0;
       virtual void callWithOptional(std::optional<double> value, const std::function<void(std::optional<double> /* maybe */)>& callback) = 0;
+      virtual std::shared_ptr<Promise<double>> getValueFromJSCallbackAndWait(const std::function<std::shared_ptr<Promise<double>>()>& getValue) = 0;
+      virtual std::shared_ptr<Promise<void>> getValueFromJsCallback(const std::function<std::shared_ptr<Promise<std::string>>()>& callback, const std::function<void(const std::string& /* valueFromJs */)>& andThenCall) = 0;
       virtual Car getCar() = 0;
       virtual bool isCarElectric(const Car& car) = 0;
       virtual std::optional<Person> getDriver(const Car& car) = 0;
diff --git a/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts b/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts
index d5887cf4e..7cfe107aa 100644
--- a/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts
+++ b/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts
@@ -103,6 +103,13 @@ interface SharedTestObjectProps {
     callback: (maybe: number | undefined) => void
   ): void
 
+  // Callbacks that return values
+  getValueFromJSCallbackAndWait(getValue: () => number): Promise<number>
+  getValueFromJsCallback(
+    callback: () => string,
+    andThenCall: (valueFromJs: string) => void
+  ): Promise<void>
+
   // Objects
   getCar(): Car
   isCarElectric(car: Car): boolean
@@ -146,13 +153,6 @@ export interface TestObjectCpp
   flip(tuple: Float3): Float3
   passTuple(tuple: TestTuple): [number, string, boolean]
 
-  // Callbacks that return values
-  getValueFromJSCallbackAndWait(getValue: () => number): Promise<number>
-  getValueFromJsCallback(
-    callback: () => string,
-    andThenCall: (valueFromJs: string) => void
-  ): Promise<void>
-
   // Other HybridObjects
   readonly thisObject: TestObjectCpp
   newTestObject(): TestObjectCpp