@depup/react-native-worklets 0.11.3-depup.0 → 0.12.1-depup.0

package/android/src/main/cpp/worklets/android/JScriptBufferWrapper.cpp

@@ -25,21 +25,13 @@ jni::local_ref<JScriptBufferWrapper::jhybriddata> JScriptBufferWrapper::initHybr
 
 jni::local_ref<JScriptBufferWrapper::jhybriddata> JScriptBufferWrapper::initHybridFromFile(
     jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
-    const std::string &fileName) {
+    const std::string &fileName,
+    const std::string &sourceURL) {
   std::shared_ptr<const ScriptBuffer> script;
   RecoverableError::runRethrowingAsRecoverable<std::system_error>([&fileName, &script]() {
     auto bigString = JSBigFileString::fromPath(fileName);
     script = std::make_shared<ScriptBuffer>(std::move(bigString));
   });
-  return makeCxxInstance(std::move(script), fileName);
-}
-
-jni::local_ref<JScriptBufferWrapper::jhybriddata> JScriptBufferWrapper::initHybridFromString(
-    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
-    const std::string &scriptStr,
-    const std::string &sourceURL) {
-  auto bigString = std::make_shared<JSBigStdString>(scriptStr);
-  auto script = std::make_shared<ScriptBuffer>(std::move(bigString));
   return makeCxxInstance(std::move(script), sourceURL);
 }
 
@@ -60,7 +52,6 @@ void JScriptBufferWrapper::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybridFromAssets", JScriptBufferWrapper::initHybridFromAssets),
       makeNativeMethod("initHybridFromFile", JScriptBufferWrapper::initHybridFromFile),
-      makeNativeMethod("initHybridFromString", JScriptBufferWrapper::initHybridFromString),
   });
 }
 } // namespace worklets

package/android/src/main/cpp/worklets/android/JScriptBufferWrapper.h

@@ -31,11 +31,8 @@ class JScriptBufferWrapper : public jni::HybridClass<JScriptBufferWrapper> {
       jni::alias_ref<jhybridobject> jThis,
       jni::alias_ref<JAssetManager::javaobject> assetManager,
       const std::string &assetURL);
-  static jni::local_ref<JScriptBufferWrapper::jhybriddata> initHybridFromFile(
-      jni::alias_ref<jhybridobject> jThis,
-      const std::string &fileName);
   static jni::local_ref<JScriptBufferWrapper::jhybriddata>
-  initHybridFromString(jni::alias_ref<jhybridobject> jThis, const std::string &script, const std::string &sourceURL);
+  initHybridFromFile(jni::alias_ref<jhybridobject> jThis, const std::string &fileName, const std::string &sourceURL);
 
   friend HybridBase;
 

package/android/src/main/java/com/swmansion/worklets/AndroidUIScheduler.kt

@@ -31,6 +31,9 @@ class AndroidUIScheduler(
 
     private external fun initHybrid(): HybridData
 
+    @DoNotStrip
+    private fun isOnUIThread(): Boolean = UiThreadUtil.isOnUiThread()
+
     external fun triggerUI()
 
     external fun invalidate()

package/android/src/main/java/com/swmansion/worklets/ScriptBufferWrapper.kt

@@ -1,13 +1,16 @@
 package com.swmansion.worklets
 
 import android.annotation.SuppressLint
+import android.content.Context
 import android.content.res.AssetManager
-import android.os.Build
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.ReactApplication
+import org.json.JSONException
+import org.json.JSONObject
+import java.io.File
 import java.io.IOException
-import java.io.InputStream
 import java.net.HttpURLConnection
 import java.net.URL
 import java.nio.charset.StandardCharsets
@@ -17,13 +20,18 @@ import java.nio.charset.StandardCharsets
 @SuppressLint("MissingNativeLoadLibrary")
 @DoNotStripAny
 class ScriptBufferWrapper(
-    uri: String,
-    assetManager: AssetManager,
+    uri: String?,
+    context: Context,
 ) {
     @field:DoNotStrip
     private val mHybridData: HybridData
 
     init {
+        checkNotNull(uri) {
+            "[Worklets] No script URL provided. Make sure the packager is running or you have " +
+                "embedded a JS bundle in your application bundle."
+        }
+
         val filePrefix = "file://"
         val absPathPrefix = "/"
         val assetsPrefix = "assets://"
@@ -32,23 +40,20 @@ class ScriptBufferWrapper(
             when {
                 uri.startsWith(filePrefix) -> {
                     val fileName = uri.substring(filePrefix.length)
-                    initHybridFromFile(fileName)
+                    initHybridFromFile(fileName, fileName)
                 }
                 uri.startsWith(assetsPrefix) -> {
                     val assetURL = uri.substring(assetsPrefix.length)
-                    initHybridFromAssets(assetManager, assetURL)
+                    initHybridFromAssets(context.assets, assetURL)
                 }
                 uri.startsWith(absPathPrefix) -> {
-                    initHybridFromFile(uri)
+                    initHybridFromFile(uri, uri)
                 }
                 else -> {
-                    val scriptContent =
-                        try {
-                            downloadScript(uri)
-                        } catch (e: IOException) {
-                            throw RuntimeException(e)
-                        }
-                    initHybridFromString(scriptContent, uri)
+                    val bundleFile =
+                        reactNativeDownloadedBundleFile(context)
+                            ?: File(context.cacheDir, DEV_BUNDLE_FILE_NAME).also { downloadScriptToFile(uri, it) }
+                    initHybridFromFile(bundleFile.absolutePath, uri)
                 }
             }
     }
@@ -58,45 +63,84 @@ class ScriptBufferWrapper(
         assetURL: String,
     ): HybridData
 
-    private external fun initHybridFromFile(fileName: String): HybridData
-
-    private external fun initHybridFromString(
-        script: String,
-        url: String,
+    private external fun initHybridFromFile(
+        fileName: String,
+        sourceURL: String,
     ): HybridData
 
     companion object {
-        private fun downloadScript(url: String): String {
-            val scriptUrl = URL(url)
-            val connection = scriptUrl.openConnection() as HttpURLConnection
-            try {
-                val content: ByteArray
+        private const val DEV_BUNDLE_FILE_NAME = "WorkletsDevBundle.js"
+        private const val CONNECT_TIMEOUT_MS = 5_000
 
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                    content = connection.inputStream.readAllBytes()
-                } else {
-                    content = readBytes(connection.inputStream)
-                }
+        private fun reactNativeDownloadedBundleFile(context: Context): File? {
+            val reactApplication = context.applicationContext as? ReactApplication ?: return null
+            val bundlePath =
+                reactApplication.reactHost
+                    ?.devSupportManager
+                    ?.downloadedJSBundleFile ?: return null
+            return File(bundlePath).takeIf { it.exists() }
+        }
 
-                return String(content, StandardCharsets.UTF_8)
+        private fun downloadScriptToFile(
+            url: String,
+            outputFile: File,
+        ) {
+            val connection = URL(url).openConnection() as HttpURLConnection
+            connection.connectTimeout = CONNECT_TIMEOUT_MS
+            try {
+                val statusCode =
+                    try {
+                        connection.responseCode
+                    } catch (e: IOException) {
+                        throw RuntimeException("[Worklets] Could not connect to development server.\n", e)
+                    }
+                if (statusCode != 200) {
+                    throw RuntimeException(serverErrorMessage(url, statusCode, connection))
+                }
+                try {
+                    val tmpFile = File(outputFile.path + ".tmp")
+                    connection.inputStream.use { input ->
+                        tmpFile.outputStream().use { output -> input.copyTo(output) }
+                    }
+                    if (!tmpFile.renameTo(outputFile)) {
+                        throw IOException("Couldn't rename $tmpFile to $outputFile")
+                    }
+                } catch (e: IOException) {
+                    throw RuntimeException(
+                        "[Worklets] Failed to store worklets bundle from URL $url: ${e.message}",
+                        e,
+                    )
+                }
             } finally {
                 connection.disconnect()
             }
         }
 
-        /** Reads all bytes from an InputStream into a byte array for SDKs below 33. */
-        private fun readBytes(inputStream: InputStream): ByteArray {
-            val bufferSize = 4096
-            try {
-                val byteBuffer = java.io.ByteArrayOutputStream()
-                val buffer = ByteArray(bufferSize)
-                var len: Int
-                while (inputStream.read(buffer).also { len = it } != -1) {
-                    byteBuffer.write(buffer, 0, len)
-                }
-                return byteBuffer.toByteArray()
-            } finally {
-                inputStream.close()
+        private fun serverErrorMessage(
+            url: String,
+            statusCode: Int,
+            connection: HttpURLConnection,
+        ): String {
+            val body = connection.errorStream?.use { String(it.readBytes(), StandardCharsets.UTF_8) }
+            val metroMessage = parseMetroError(body)
+            if (metroMessage != null) {
+                return "[Worklets] $metroMessage"
+            }
+            return "[Worklets] The development server returned response error code: $statusCode\n\n" +
+                "URL: $url\n\n" +
+                "Body:\n$body"
+        }
+
+        private fun parseMetroError(body: String?): String? {
+            if (body.isNullOrEmpty()) {
+                return null
+            }
+            return try {
+                val json = JSONObject(body)
+                val fileName = json.getString("filename").substringAfterLast('/')
+                "${json.getString("message")}\n  at $fileName:${json.getInt("lineNumber")}:${json.getInt("column")}"
+            } catch (e: JSONException) {
+                null
             }
         }
     }

package/android/src/networking/com/swmansion/worklets/WorkletsModule.kt

@@ -14,7 +14,6 @@ import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 import com.facebook.soloader.SoLoader
 import com.swmansion.worklets.runloop.AnimationFrameCallback
 import com.swmansion.worklets.runloop.AnimationFrameQueue
-import java.util.concurrent.atomic.AtomicBoolean
 
 @Suppress("KotlinJniMissingFunction")
 @ReactModule(name = WorkletsModule.NAME)
@@ -50,7 +49,8 @@ class WorkletsModule(
      * Invalidating concurrently could be fatal. It shouldn't happen in a normal flow, but it doesn't
      * cost us much to add synchronization for extra safety.
      */
-    private val mInvalidated = AtomicBoolean(false)
+    private val mInvalidationLock = Any()
+    private var mInvalidated = false
 
     @OptIn(FrameworkAPI::class)
     private external fun initHybrid(
@@ -71,11 +71,9 @@ class WorkletsModule(
         val jsContext = checkNotNull(context.javaScriptContextHolder).get()
         val jsCallInvokerHolder = context.jsCallInvokerHolder as CallInvokerHolderImpl
 
-        val sourceURL = context.sourceURL
-
         val scriptBufferWrapper: ScriptBufferWrapper? =
             if (bundleModeEnabled) {
-                ScriptBufferWrapper(sourceURL!!, context.assets)
+                ScriptBufferWrapper(context.sourceURL, context)
             } else {
                 null
             }
@@ -161,9 +159,17 @@ class WorkletsModule(
         return mSlowAnimationsEnabled
     }
 
+    override fun initialize() {
+        reactApplicationContext.addLifecycleEventListener(this)
+    }
+
     override fun invalidate() {
-        if (mInvalidated.getAndSet(true)) {
-            return
+        synchronized(mInvalidationLock) {
+            if (mInvalidated) {
+                return
+            }
+            mInvalidated = true
+            reactApplicationContext.removeLifecycleEventListener(this)
         }
         if (mHybridData != null && mHybridData!!.isValid) {
             invalidateCpp()
@@ -176,11 +182,21 @@ class WorkletsModule(
     private external fun startCpp()
 
     override fun onHostResume() {
-        mAnimationFrameQueue.resume()
+        synchronized(mInvalidationLock) {
+            if (mInvalidated) {
+                return
+            }
+            mAnimationFrameQueue.resume()
+        }
     }
 
     override fun onHostPause() {
-        mAnimationFrameQueue.pause()
+        synchronized(mInvalidationLock) {
+            if (mInvalidated) {
+                return
+            }
+            mAnimationFrameQueue.pause()
+        }
     }
 
     override fun onHostDestroy() {}

package/android/src/no-networking/com/swmansion/worklets/WorkletsModule.kt

@@ -11,7 +11,6 @@ import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 import com.facebook.soloader.SoLoader
 import com.swmansion.worklets.runloop.AnimationFrameCallback
 import com.swmansion.worklets.runloop.AnimationFrameQueue
-import java.util.concurrent.atomic.AtomicBoolean
 
 @Suppress("KotlinJniMissingFunction")
 @ReactModule(name = WorkletsModule.NAME)
@@ -46,7 +45,8 @@ class WorkletsModule(
      * Invalidating concurrently could be fatal. It shouldn't happen in a normal flow, but it doesn't
      * cost us much to add synchronization for extra safety.
      */
-    private val mInvalidated = AtomicBoolean(false)
+    private val mInvalidationLock = Any()
+    private var mInvalidated = false
 
     @OptIn(FrameworkAPI::class)
     private external fun initHybrid(
@@ -67,11 +67,9 @@ class WorkletsModule(
         val jsContext = checkNotNull(context.javaScriptContextHolder).get()
         val jsCallInvokerHolder = context.jsCallInvokerHolder as CallInvokerHolderImpl
 
-        val sourceURL = context.sourceURL
-
         val scriptBufferWrapper: ScriptBufferWrapper? =
             if (bundleModeEnabled) {
-                ScriptBufferWrapper(sourceURL!!, context.assets)
+                ScriptBufferWrapper(context.sourceURL, context)
             } else {
                 null
             }
@@ -117,9 +115,17 @@ class WorkletsModule(
         return mSlowAnimationsEnabled
     }
 
+    override fun initialize() {
+        reactApplicationContext.addLifecycleEventListener(this)
+    }
+
     override fun invalidate() {
-        if (mInvalidated.getAndSet(true)) {
-            return
+        synchronized(mInvalidationLock) {
+            if (mInvalidated) {
+                return
+            }
+            mInvalidated = true
+            reactApplicationContext.removeLifecycleEventListener(this)
         }
         if (mHybridData != null && mHybridData!!.isValid) {
             invalidateCpp()
@@ -132,11 +138,21 @@ class WorkletsModule(
     private external fun startCpp()
 
     override fun onHostResume() {
-        mAnimationFrameQueue.resume()
+        synchronized(mInvalidationLock) {
+            if (mInvalidated) {
+                return
+            }
+            mAnimationFrameQueue.resume()
+        }
     }
 
     override fun onHostPause() {
-        mAnimationFrameQueue.pause()
+        synchronized(mInvalidationLock) {
+            if (mInvalidated) {
+                return
+            }
+            mAnimationFrameQueue.pause()
+        }
     }
 
     override fun onHostDestroy() {}

package/apple/worklets/apple/IOSUIScheduler.h

@@ -9,6 +9,9 @@ using namespace worklets;
 class IOSUIScheduler : public UIScheduler, public std::enable_shared_from_this<IOSUIScheduler> {
  public:
   void scheduleOnUI(std::function<void()> job) override;
+
+ protected:
+  bool queryIsOnUIThread() const override;
 };
 
 } // namespace worklets

package/apple/worklets/apple/IOSUIScheduler.mm

@@ -5,9 +5,14 @@ namespace worklets {
 using namespace facebook;
 using namespace react;
 
+bool IOSUIScheduler::queryIsOnUIThread() const
+{
+  return [NSThread isMainThread];
+}
+
 void IOSUIScheduler::scheduleOnUI(std::function<void()> job)
 {
-  if ([NSThread isMainThread]) {
+  if (isOnUIThread()) {
     job();
     return;
   }

package/apple/worklets/apple/ScriptLoader.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+#import <worklets/Tools/ScriptBuffer.h>
+
+#import <memory>
+
+namespace worklets {
+
+std::shared_ptr<const ScriptBuffer> getScript(NSURL *url);
+
+} // namespace worklets

package/apple/worklets/apple/ScriptLoader.mm

@@ -0,0 +1,124 @@
+#import <worklets/apple/ScriptLoader.h>
+
+namespace worklets {
+namespace {
+
+class NSDataScript : public JSBigString {
+ public:
+  explicit NSDataScript(NSData *data) : data_(data), size_([data length]) {}
+
+  bool isAscii() const override
+  {
+    return false;
+  }
+
+  const char *c_str() const override
+  {
+    return static_cast<const char *>(data_.bytes);
+  }
+
+  size_t size() const override
+  {
+    return size_;
+  }
+
+ private:
+  NSData *data_;
+  size_t size_;
+};
+
+NSData *loadScriptFromFile(NSURL *url)
+{
+  NSError *error;
+  NSData *data = [NSData dataWithContentsOfFile:url.path options:NSDataReadingMappedIfSafe error:&error];
+
+  if (data == nil) [[unlikely]] {
+    NSString *errorMsg = [NSString stringWithFormat:@"[Worklets] Failed to load worklets bundle from file %@: %@",
+                                                    url.path,
+                                                    error.localizedDescription];
+    NSLog(@"%@", errorMsg);
+    throw std::runtime_error([errorMsg UTF8String]);
+  }
+
+  return data;
+}
+
+NSData *downloadScript(NSURL *url)
+{
+  dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+  __block NSData *data = nil;
+  __block NSURLResponse *response = nil;
+  __block NSError *error = nil;
+
+  NSURLSessionDataTask *task = [[NSURLSession sharedSession]
+        dataTaskWithURL:url
+      completionHandler:^(NSData *taskData, NSURLResponse *taskResponse, NSError *taskError) {
+        data = taskData;
+        response = taskResponse;
+        error = taskError;
+        dispatch_semaphore_signal(semaphore);
+      }];
+  [task resume];
+  dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+
+  if (error != nil) [[unlikely]] {
+    NSString *errorMsg;
+    if ([error.domain isEqualToString:NSURLErrorDomain]) {
+      errorMsg = @"[Worklets] Could not connect to development server.\n";
+    } else {
+      errorMsg = [NSString stringWithFormat:@"[Worklets] Failed to load worklets bundle from URL %@: %@",
+                                            url,
+                                            error.localizedDescription];
+    }
+    NSLog(@"%@", errorMsg);
+    throw std::runtime_error([errorMsg UTF8String]);
+  }
+
+  NSInteger statusCode =
+      [response isKindOfClass:[NSHTTPURLResponse class]] ? [(NSHTTPURLResponse *)response statusCode] : 200;
+  if (statusCode != 200) [[unlikely]] {
+    NSString *description = nil;
+    NSDictionary *jsonError = data != nil ? [NSJSONSerialization JSONObjectWithData:data options:0 error:nil] : nil;
+    if ([jsonError isKindOfClass:[NSDictionary class]] && [jsonError[@"message"] isKindOfClass:[NSString class]] &&
+        [jsonError[@"message"] length] > 0) {
+      description = jsonError[@"message"];
+    } else {
+      description = [NSString stringWithFormat:@"Received status code %ld while fetching the bundle", (long)statusCode];
+    }
+    NSString *errorMsg =
+        [NSString stringWithFormat:@"[Worklets] Failed to load worklets bundle from URL %@: %@", url, description];
+    NSLog(@"%@", errorMsg);
+    throw std::runtime_error([errorMsg UTF8String]);
+  }
+
+  NSString *mimeType = response.MIMEType;
+  if (![mimeType isEqualToString:@"application/javascript"] && ![mimeType isEqualToString:@"text/javascript"])
+      [[unlikely]] {
+    NSString *errorMsg = [NSString
+        stringWithFormat:
+            @"[Worklets] Expected MIME-Type of the worklets bundle to be 'application/javascript' or 'text/javascript', but got '%@'",
+            mimeType];
+    NSLog(@"%@", errorMsg);
+    throw std::runtime_error([errorMsg UTF8String]);
+  }
+
+  return data;
+}
+
+} // namespace
+
+std::shared_ptr<const ScriptBuffer> getScript(NSURL *url)
+{
+  if (url == nil) [[unlikely]] {
+    NSString *errorMsg =
+        @"[Worklets] No script URL provided. Make sure the packager is running or you have embedded a "
+        @"JS bundle in your application bundle.";
+    NSLog(@"%@", errorMsg);
+    throw std::runtime_error([errorMsg UTF8String]);
+  }
+
+  NSData *data = url.isFileURL ? loadScriptFromFile(url) : downloadScript(url);
+  return std::make_shared<const ScriptBuffer>(std::make_shared<const NSDataScript>(data));
+}
+
+} // namespace worklets

package/apple/worklets/apple/WorkletsModule.h

@@ -6,22 +6,7 @@
 
 #import <worklets/NativeModules/WorkletsModuleProxy.h>
 
-#if __has_include(<React/RCTBundleConsumer.h>)
-// Bundle mode
-#import <React/NSBigStringBuffer.h>
-#import <React/RCTBundleConsumer.h>
-#endif // __has_include(<React/RCTBundleConsumer.h>)
-
-@interface WorkletsModule : RCTEventEmitter <
-                                NativeWorkletsModuleSpec,
-                                RCTCallInvokerModule,
-                                RCTInvalidating
-#if __has_include(<React/RCTBundleConsumer.h>)
-                                // Bundle mode
-                                ,
-                                RCTBundleConsumer
-#endif // __has_include(<React/RCTBundleConsumer.h>)
-                                >
+@interface WorkletsModule : RCTEventEmitter <NativeWorkletsModuleSpec, RCTCallInvokerModule, RCTInvalidating>
 
 - (std::shared_ptr<worklets::WorkletsModuleProxy>)getWorkletsModuleProxy;
 

package/apple/worklets/apple/WorkletsModule.mm

@@ -7,8 +7,11 @@
 #import <worklets/apple/AssertJavaScriptQueue.h>
 #import <worklets/apple/AssertTurboModuleManagerQueue.h>
 #import <worklets/apple/IOSUIScheduler.h>
+#import <worklets/apple/ScriptLoader.h>
 #import <worklets/apple/WorkletsModule.h>
 
+#import <Foundation/Foundation.h>
+
 #import <React/RCTBridge+Private.h>
 #import <React/RCTCallInvoker.h>
 
@@ -64,7 +67,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(installTurboModule : (BOOL)bundleModeEnab
 
   if (bundleModeEnabled) {
     NSURL *url = bundleManager_.bundleURL;
-    script = [self getScript:url];
+    script = getScript(url);
     sourceURL = [[url absoluteString] UTF8String];
   }
 
@@ -127,21 +130,6 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(toggleSlowAnimationsOnUIRuntime)
   return std::make_shared<facebook::react::NativeWorkletsModuleSpecJSI>(params);
 }
 
-- (std::shared_ptr<const ScriptBuffer>)getScript:(NSURL *)url
-{
-  NSData *data = [NSData dataWithContentsOfURL:url];
-
-  if (!data) [[unlikely]] {
-    NSString *errorMsg = [NSString stringWithFormat:@"[Worklets] Failed to load worklets bundle from URL: %@", url];
-    NSLog(@"%@", errorMsg);
-    throw std::runtime_error([errorMsg UTF8String]);
-  }
-
-  auto str = std::string(reinterpret_cast<const char *>([data bytes]), [data length]);
-  auto bigString = std::make_shared<const JSBigStdString>(str);
-  return std::make_shared<const ScriptBuffer>(bigString);
-}
-
 - (std::shared_ptr<RuntimeBindings>)getRuntimeBindings:(jsi::Runtime &)rnRuntime
                                      bundleModeEnabled:(BOOL)bundleModeEnabled
 {

package/changes.json

@@ -53,6 +53,6 @@
       "to": "^7.8.5"
     }
   },
-  "timestamp": "2026-07-26T00:57:50.717Z",
+  "timestamp": "2026-08-23T00:27:36.320Z",
   "totalUpdated": 13
 }

package/compatibility.json

@@ -1,6 +1,9 @@
 {
   "nightly": {
-    "react-native": ["0.83", "0.84", "0.85", "0.86"]
+    "react-native": ["0.83", "0.84", "0.85", "0.86", "0.87"]
+  },
+  "0.12.x": {
+    "react-native": ["0.83", "0.84", "0.85", "0.86", "0.87"]
   },
   "0.11.x": {
     "react-native": ["0.83", "0.84", "0.85", "0.86"]

package/lib/module/WorkletsModule/NativeWorklets.native.js

@@ -124,8 +124,8 @@ See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting
   runOnUISync(worklet, scheduleStack) {
     return this.#workletsModuleProxy.runOnUISync(worklet, scheduleStack);
   }
-  createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop) {
-    return this.#workletsModuleProxy.createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop);
+  createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop, enableLocking) {
+    return this.#workletsModuleProxy.createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop, enableLocking);
   }
   scheduleOnRuntime(workletRuntime, serializableWorklet, scheduleStack) {
     return this.#workletsModuleProxy.scheduleOnRuntime(workletRuntime, serializableWorklet, scheduleStack);