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

package/Common/cpp/worklets/AnimationFrameQueue/AnimationFrameBatchinator.cpp

@@ -47,9 +47,8 @@ void AnimationFrameBatchinator::flush() {
     auto &uiWorkletRuntime = strongThis->uiWorkletRuntime_;
     uiWorkletRuntime->runSync([&](jsi::Runtime &rt) {
       for (const auto &callback : callbacks) {
-        uiWorkletRuntime->runSync(*callback, timestampMs);
+        uiWorkletRuntime->runSyncAndDiscard(*callback, timestampMs);
       }
-      jsi_utils::triggerWeakRefCleanup(uiWorkletRuntime->getJSIRuntime());
     });
   });
 }

package/Common/cpp/worklets/AnimationFrameQueue/AnimationFrameBatchinator.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 

package/Common/cpp/worklets/Compat/StableApi.cpp

@@ -1,8 +1,24 @@
 #include <jsi/jsi.h>
 #include <worklets/Compat/Holders.h>
 #include <worklets/Compat/StableApi.h>
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/SharedItems/SerializableRemoteFunction.h>
+#include <worklets/SharedItems/Serializable/CustomSerializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+#include <worklets/SharedItems/Serializable/SerializableArray.h>
+#include <worklets/SharedItems/Serializable/SerializableArrayBuffer.h>
+#include <worklets/SharedItems/Serializable/SerializableBigInt.h>
+#include <worklets/SharedItems/Serializable/SerializableError.h>
+#include <worklets/SharedItems/Serializable/SerializableHostFunction.h>
+#include <worklets/SharedItems/Serializable/SerializableHostObject.h>
+#include <worklets/SharedItems/Serializable/SerializableImport.h>
+#include <worklets/SharedItems/Serializable/SerializableMap.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+#include <worklets/SharedItems/Serializable/SerializableRegExp.h>
+#include <worklets/SharedItems/Serializable/SerializableRemoteFunction.h>
+#include <worklets/SharedItems/Serializable/SerializableScalar.h>
+#include <worklets/SharedItems/Serializable/SerializableSet.h>
+#include <worklets/SharedItems/Serializable/SerializableString.h>
+#include <worklets/SharedItems/Serializable/SerializableTurboModuleLike.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>
 #include <worklets/SharedItems/Shareable.h>
 #include <worklets/SharedItems/Synchronizable.h>
 #include <worklets/Tools/JSISerializer.h>
@@ -70,7 +86,7 @@ std::shared_ptr<Serializable> extractSerializable(
     case Serializable::ValueType::RemoteFunctionType:
       return extractSerializableOrThrow<SerializableRemoteFunction>(rt, value, errorMessage);
     case Serializable::ValueType::HandleType:
-      return extractSerializableOrThrow<SerializableInitializer>(rt, value, errorMessage);
+      throw std::runtime_error("[Worklets] Not implemented.");
     case Serializable::ValueType::HostObjectType:
       return extractSerializableOrThrow<SerializableHostObject>(rt, value, errorMessage);
     case Serializable::ValueType::HostFunctionType:
@@ -101,14 +117,14 @@ std::shared_ptr<Serializable> extractSerializable(
 void runSyncOnRuntime(
     const std::shared_ptr<WorkletRuntime> &workletRuntime,
     const std::shared_ptr<Serializable> &worklet) {
-  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet));
+  workletRuntime->runSyncAndDiscard(std::static_pointer_cast<SerializableWorklet>(worklet));
 }
 
 void runSyncOnRuntime(
     const std::shared_ptr<WorkletRuntime> &workletRuntime,
     const std::shared_ptr<Serializable> &worklet,
     const facebook::jsi::Value &arg0) {
-  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet), arg0);
+  workletRuntime->runSyncAndDiscard(std::static_pointer_cast<SerializableWorklet>(worklet), arg0);
 }
 
 void runSyncOnRuntime(
@@ -116,18 +132,18 @@ void runSyncOnRuntime(
     const std::shared_ptr<Serializable> &worklet,
     const facebook::jsi::Value &arg0,
     const facebook::jsi::Value &arg1) {
-  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet), arg0, arg1);
+  workletRuntime->runSyncAndDiscard(std::static_pointer_cast<SerializableWorklet>(worklet), arg0, arg1);
 }
 
 void runSyncOnRuntime(const std::shared_ptr<WorkletRuntime> &workletRuntime, const facebook::jsi::Function &function) {
-  workletRuntime->runSync(function);
+  workletRuntime->runSyncAndDiscard(function);
 }
 
 void runSyncOnRuntime(
     const std::shared_ptr<WorkletRuntime> &workletRuntime,
     const facebook::jsi::Function &function,
     const facebook::jsi::Value &arg0) {
-  workletRuntime->runSync(function, arg0);
+  workletRuntime->runSyncAndDiscard(function, arg0);
 }
 
 std::shared_ptr<WorkletRuntime> getWorkletRuntimeFromHolder(

package/Common/cpp/worklets/Compat/StableApi.h

@@ -43,7 +43,7 @@ class Serializable {
     SetType,
     WorkletType,
     RemoteFunctionType,
-    HandleType,
+    HandleType, /* removed */
     HostObjectType,
     HostFunctionType,
     ArrayBufferType,

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.cpp

@@ -3,25 +3,43 @@
 #include <worklets/Compat/Holders.h>
 #include <worklets/Compat/StableApi.h>
 #include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/SharedItems/SerializableFactory.h>
-#include <worklets/SharedItems/SerializableRemoteFunction.h>
+#include <worklets/SharedItems/Serializable/CustomSerializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+#include <worklets/SharedItems/Serializable/SerializableArray.h>
+#include <worklets/SharedItems/Serializable/SerializableArrayBuffer.h>
+#include <worklets/SharedItems/Serializable/SerializableBigInt.h>
+#include <worklets/SharedItems/Serializable/SerializableError.h>
+#include <worklets/SharedItems/Serializable/SerializableHostFunction.h>
+#include <worklets/SharedItems/Serializable/SerializableHostObject.h>
+#include <worklets/SharedItems/Serializable/SerializableImport.h>
+#include <worklets/SharedItems/Serializable/SerializableMap.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+#include <worklets/SharedItems/Serializable/SerializableRegExp.h>
+#include <worklets/SharedItems/Serializable/SerializableRemoteFunction.h>
+#include <worklets/SharedItems/Serializable/SerializableScalar.h>
+#include <worklets/SharedItems/Serializable/SerializableSet.h>
+#include <worklets/SharedItems/Serializable/SerializableString.h>
+#include <worklets/SharedItems/Serializable/SerializableTurboModuleLike.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>
 #include <worklets/SharedItems/Shareable.h>
 #include <worklets/SharedItems/Synchronizable.h>
+#include <worklets/SharedItems/SynchronizableDynamic.h>
+#include <worklets/SharedItems/SynchronizableFixed.h>
 #include <worklets/Tools/FeatureFlags.h>
 #include <worklets/Tools/JSLogger.h>
 #include <worklets/Tools/WorkletsJSIUtils.h>
 #include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeData.h>
 
-#ifndef NDEBUG
-#include <algorithm>
-#endif // NDEBUG
 #include <memory>
 #include <optional>
+#include <sstream>
 #include <stdexcept>
 #include <string>
+#include <thread>
+#include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 using namespace facebook;
@@ -33,31 +51,26 @@ namespace {
 inline void scheduleOnUI(
     const std::weak_ptr<WorkletRuntime> &weakUIWorkletRuntime,
     jsi::Runtime &rt,
-    const jsi::Value &serializableArrayOfWorkletsValue
+    const jsi::Value &serializableArrayOfWorkletsValue,
+    const jsi::Value &serializableArrayOfArgumentsValue
 #ifndef NDEBUG
     ,
     const jsi::Value &scheduleStacksValue
 #endif // NDEBUG
 ) {
-  auto serializable = extractSerializableOrThrow(
+  auto serializableArrayOfWorklets = extractSerializableOrThrow<SerializableArray>(
       rt, serializableArrayOfWorkletsValue, "[Worklets] scheduleOnUI expects a serializable array of worklets.");
-  auto serializableArrayOfWorklets = std::static_pointer_cast<SerializableArray>(serializable);
-
-  const auto &workletsList = serializableArrayOfWorklets->getList();
-  std::vector<std::shared_ptr<SerializableWorklet>> worklets;
-  worklets.reserve(workletsList.size());
-  for (const auto &item : workletsList) {
-    worklets.push_back(std::static_pointer_cast<SerializableWorklet>(item));
-  }
+  auto serializableArrayOfArguments = extractSerializableOrThrow<SerializableArray>(
+      rt, serializableArrayOfArgumentsValue, "[Worklets] scheduleOnUI expects a serializable array of arguments.");
 
 #ifndef NDEBUG
-  std::vector<std::optional<std::string>> scheduleStacks(worklets.size());
+  std::vector<std::optional<std::string>> scheduleStacks;
   if (scheduleStacksValue.isObject()) {
     auto stacksObject = scheduleStacksValue.asObject(rt);
     if (stacksObject.isArray(rt)) {
       auto stacksArray = stacksObject.asArray(rt);
-      auto count = std::min<size_t>(stacksArray.size(rt), scheduleStacks.size());
-      for (size_t i = 0; i < count; i++) {
+      scheduleStacks.resize(stacksArray.size(rt));
+      for (size_t i = 0; i < scheduleStacks.size(); i++) {
         auto stackValue = stacksArray.getValueAtIndex(rt, i);
         if (stackValue.isString()) {
           scheduleStacks[i] = stackValue.asString(rt).utf8(rt);
@@ -72,9 +85,10 @@ inline void scheduleOnUI(
     return;
   }
 #ifndef NDEBUG
-  uiWorkletRuntime->scheduleWithStack(std::move(worklets), std::move(scheduleStacks));
+  uiWorkletRuntime->scheduleWithStack(
+      std::move(serializableArrayOfWorklets), std::move(serializableArrayOfArguments), std::move(scheduleStacks));
 #else
-  uiWorkletRuntime->schedule(std::move(worklets));
+  uiWorkletRuntime->schedule(std::move(serializableArrayOfWorklets), std::move(serializableArrayOfArguments));
 #endif // NDEBUG
 }
 
@@ -137,9 +151,10 @@ inline jsi::Value createWorkletRuntime(
     std::shared_ptr<SerializableWorklet> &initializer,
     const std::shared_ptr<AsyncQueue> &queue,
     bool enableEventLoop,
-    bool enableLocking) {
-  const auto workletRuntime =
-      runtimeManager->createWorkletRuntime(sourceProxy, name, initializer, queue, enableEventLoop, enableLocking);
+    bool enableLocking,
+    bool enableNetworking) {
+  const auto workletRuntime = runtimeManager->createWorkletRuntime(
+      sourceProxy, name, initializer, queue, enableEventLoop, enableLocking, enableNetworking);
   return jsi::Object::createFromHostObject(originRuntime, workletRuntime);
 }
 
@@ -168,6 +183,29 @@ inline std::shared_ptr<AsyncQueue> extractAsyncQueue(jsi::Runtime &rt, const jsi
   return asyncQueue;
 }
 
+inline jsi::Value synchronizableValueToJSValue(jsi::Runtime &rt, const SynchronizableValue &value) {
+  return std::visit(
+      [&rt](const auto &alternative) -> jsi::Value {
+        using TAlternative = std::decay_t<decltype(alternative)>;
+        if constexpr (std::is_same_v<TAlternative, std::shared_ptr<Serializable>>) {
+          return alternative->toJSValue(rt);
+        } else {
+          return jsi::Value(alternative);
+        }
+      },
+      value);
+}
+
+inline SynchronizableFixedValue jsValueToSynchronizableFixedValue(const jsi::Value &value) {
+  if (value.isBool()) {
+    return value.getBool();
+  }
+  if (value.isNumber()) {
+    return value.getNumber();
+  }
+  throw std::runtime_error("[Worklets] Expected a number or boolean for a fixed-type Synchronizable.");
+}
+
 inline void registerCustomSerializable(
     const std::shared_ptr<RuntimeManager> &runtimeManager,
     const std::shared_ptr<MemoryManager> &memoryManager,
@@ -267,11 +305,6 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
         return makeSerializableHostObject(rt, at<0>(args).asObject(rt).asHostObject(rt));
       });
 
-  jsi_utils::addMethod<1>(
-      rt, obj, "createSerializableInitializer", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[1]) {
-        return makeSerializableInitializer(rt, at<0>(args).asObject(rt));
-      });
-
   jsi_utils::addMethod<2>(
       rt, obj, "createSerializableArray", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) {
         return makeSerializableArray(rt, at<0>(args).asObject(rt).asArray(rt), at<1>(args));
@@ -426,15 +459,15 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
         }
       });
 
-  jsi_utils::addMethod<2>(
+  jsi_utils::addMethod<3>(
       rt,
       obj,
       "scheduleOnUI",
-      [uiWorkletRuntime = uiWorkletRuntime_](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) {
+      [uiWorkletRuntime = uiWorkletRuntime_](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[3]) {
 #ifndef NDEBUG
-        scheduleOnUI(uiWorkletRuntime, rt, at<0>(args), at<1>(args));
+        scheduleOnUI(uiWorkletRuntime, rt, at<0>(args), at<1>(args), at<2>(args));
 #else
-        scheduleOnUI(uiWorkletRuntime, rt, at<0>(args));
+        scheduleOnUI(uiWorkletRuntime, rt, at<0>(args), at<1>(args));
 #endif // NDEBUG
       });
 
@@ -493,11 +526,11 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
         return serializedResult->toJSValue(rt);
       });
 
-  jsi_utils::addMethod<6>(
+  jsi_utils::addMethod<7>(
       rt,
       obj,
       "createWorkletRuntime",
-      [sourceProxy = shared_from_this()](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[6]) {
+      [sourceProxy = shared_from_this()](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[7]) {
         const auto name = at<0>(args).getString(rt).utf8(rt);
         auto serializableInitializer = extractSerializableOrThrow<SerializableWorklet>(
             rt, at<1>(args), "[Worklets] Initializer must be a worklet.");
@@ -512,10 +545,19 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
 
         const auto enableEventLoop = at<4>(args).getBool();
         const auto enableLocking = at<5>(args).getBool();
+        const auto enableNetworking = at<6>(args).getBool();
         const auto runtimeManager = sourceProxy->getRuntimeManager();
 
         return createWorkletRuntime(
-            rt, runtimeManager, sourceProxy, name, serializableInitializer, asyncQueue, enableEventLoop, enableLocking);
+            rt,
+            runtimeManager,
+            sourceProxy,
+            name,
+            serializableInitializer,
+            asyncQueue,
+            enableEventLoop,
+            enableLocking,
+            enableNetworking);
       });
 
   jsi_utils::addMethod<3>(
@@ -596,41 +638,62 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
             /* value */ at<1>(args).asBool());
       });
 
-  jsi_utils::addMethod<1>(
-      rt, obj, "createSynchronizable", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[1]) {
-        auto initial = extractSerializableOrThrow(rt, at<0>(args), "[Worklets] Value must be a Serializable.");
-        auto synchronizable = std::make_shared<Synchronizable>(initial);
-        return SerializableJSRef::newNativeStateObject(rt, synchronizable);
+  jsi_utils::addMethod<0>(rt, obj, "getCurrentThreadId", [](jsi::Runtime &rt, const jsi::Value &) {
+    std::ostringstream stream;
+    stream << std::this_thread::get_id();
+    return jsi::String::createFromUtf8(rt, stream.str());
+  });
+
+  jsi_utils::addMethod<2>(
+      rt, obj, "createSynchronizable", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) {
+        if (at<1>(args).getBool()) {
+          return SerializableJSRef::newNativeStateObject(
+              rt, SynchronizableFixed::make(jsValueToSynchronizableFixedValue(at<0>(args))));
+        } else {
+          auto initial = extractSerializableOrThrow(rt, at<0>(args), "[Worklets] Value must be a Serializable.");
+          return SerializableJSRef::newNativeStateObject(rt, std::make_shared<SynchronizableDynamic>(initial));
+        }
       });
 
   jsi_utils::addMethod<1>(
       rt, obj, "synchronizableGetDirty", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[1]) {
-        auto synchronizable = extractSynchronizableOrThrow(rt, at<0>(args));
-        return synchronizable->getDirty()->toJSValue(rt);
+        return synchronizableValueToJSValue(
+            rt, Synchronizable::extractSynchronizableOrThrow(rt, at<0>(args))->getDirty());
       });
 
   jsi_utils::addMethod<1>(
       rt, obj, "synchronizableGetBlocking", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[1]) {
-        auto synchronizable = extractSynchronizableOrThrow(rt, at<0>(args));
-        return synchronizable->getBlocking()->toJSValue(rt);
+        return synchronizableValueToJSValue(
+            rt, Synchronizable::extractSynchronizableOrThrow(rt, at<0>(args))->getBlocking());
       });
 
   jsi_utils::addMethod<2>(
       rt, obj, "synchronizableSetBlocking", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) {
-        auto synchronizable = extractSynchronizableOrThrow(rt, at<0>(args));
-        auto newValue = extractSerializableOrThrow(rt, at<1>(args), "[Worklets] Value must be a Serializable.");
-        synchronizable->setBlocking(newValue);
+        auto synchronizable = Synchronizable::extractSynchronizableOrThrow(rt, at<0>(args));
+        const auto &newValue = at<1>(args);
+        if (synchronizable->isFixed()) {
+          synchronizable->setBlocking(jsValueToSynchronizableFixedValue(newValue));
+        } else {
+          synchronizable->setBlocking(
+              extractSerializableOrThrow(rt, newValue, "[Worklets] Value must be a Serializable."));
+        }
+      });
+
+  jsi_utils::addMethod<2>(
+      rt, obj, "synchronizableSetDirty", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) {
+        Synchronizable::extractSynchronizableOrThrow(rt, at<0>(args))
+            ->setDirty(jsValueToSynchronizableFixedValue(at<1>(args)));
       });
 
   jsi_utils::addMethod<1>(
       rt, obj, "synchronizableLock", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[1]) {
-        auto synchronizable = extractSynchronizableOrThrow(rt, at<0>(args));
+        auto synchronizable = Synchronizable::extractSynchronizableOrThrow(rt, at<0>(args));
         synchronizable->lock();
       });
 
   jsi_utils::addMethod<1>(
       rt, obj, "synchronizableUnlock", [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[1]) {
-        auto synchronizable = extractSynchronizableOrThrow(rt, at<0>(args));
+        auto synchronizable = Synchronizable::extractSynchronizableOrThrow(rt, at<0>(args));
         synchronizable->unlock();
       });
 

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.h

@@ -2,7 +2,7 @@
 
 #include <jsi/jsi.h>
 #include <worklets/SharedItems/MemoryManager.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/SharedItems/UnpackerLoader.h>
 #include <worklets/Tools/RNRuntimeStatus.h>
 #include <worklets/Tools/ScriptBuffer.h>
@@ -18,6 +18,7 @@ using namespace facebook;
 
 namespace worklets {
 
+class Networking;
 class WorkletRuntime;
 
 class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsModuleProxy> {
@@ -30,6 +31,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
       const std::shared_ptr<RuntimeManager> &runtimeManager,
       const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
       const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+      const std::shared_ptr<Networking> &networking,
       const BundleModeConfig &bundleModeConfig,
       const std::shared_ptr<UnpackerLoader> &unpackerLoader,
       const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus,
@@ -42,6 +44,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
         runtimeManager_(runtimeManager),
         uiWorkletRuntime_(uiWorkletRuntime),
         runtimeBindings_(runtimeBindings),
+        networking_(networking),
         unpackerLoader_(unpackerLoader),
         rnRuntimeStatus_(rnRuntimeStatus),
         hostRuntimeId_(hostRuntimeId) {}
@@ -57,6 +60,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
         sourceProxy->runtimeManager_,
         sourceProxy->uiWorkletRuntime_,
         sourceProxy->runtimeBindings_,
+        sourceProxy->networking_,
         sourceProxy->bundleModeConfig_,
         sourceProxy->unpackerLoader_,
         sourceProxy->rnRuntimeStatus_,
@@ -105,6 +109,10 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
     return runtimeBindings_;
   }
 
+  [[nodiscard]] std::shared_ptr<Networking> getNetworking() const {
+    return networking_;
+  }
+
   [[nodiscard]] std::shared_ptr<UnpackerLoader> getUnpackerLoader() const {
     return unpackerLoader_;
   }
@@ -118,6 +126,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
   const std::shared_ptr<RuntimeManager> runtimeManager_;
   const std::weak_ptr<WorkletRuntime> uiWorkletRuntime_;
   const std::shared_ptr<RuntimeBindings> runtimeBindings_;
+  const std::shared_ptr<Networking> networking_;
   const std::shared_ptr<UnpackerLoader> unpackerLoader_;
   const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
   const RuntimeData::RuntimeId hostRuntimeId_;

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp

@@ -6,8 +6,10 @@
 #include <worklets/WorkletRuntime/RuntimeData.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
 
+#include <react/debug/react_native_assert.h>
+
 #include <memory>
-#include <utility>
+#include <stdexcept>
 
 using namespace facebook;
 
@@ -18,64 +20,120 @@ bool isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) {
   return rtDev.isBool() && rtDev.asBool();
 }
 
-/**
- * This method is required outside of Bundle Mode to make sure we start creating
- * Worklet Runtimes only after unpackers code was loaded from the RN Runtime.
- *
- * In Bundle Mode unpackers are installed during bundle evaluation instead.
- */
 void WorkletsModuleProxy::start() {
-  /**
-   * We call additional `init` method here because
-   * JSIWorkletsModuleProxy needs a weak_ptr to the UI Runtime.
-   */
-  const auto uiRuntimeProxy = JSIWorkletsModuleProxy::createForNewRuntime(rnRuntimeProxy_, RuntimeData::uiRuntimeId);
-  uiWorkletRuntime_->init(uiRuntimeProxy);
+  react_native_assert(jsScheduler_->canInvokeSyncOnJS() && "start must be called on the JS thread");
+  if (!rnRuntimeProxy_) [[unlikely]] {
+    throw std::runtime_error("[Worklets] WorkletsModuleProxy must be attached to the RN runtime before start.");
+  }
+  if (uiRuntimeStarted_) {
+    return;
+  }
 
-  animationFrameBatchinator_ =
-      std::make_shared<AnimationFrameBatchinator>(uiWorkletRuntime_, runtimeBindings_->requestAnimationFrame);
-
-  UIRuntimeDecorator::decorate(
-      uiWorkletRuntime_->getJSIRuntime(), animationFrameBatchinator_->getJsiRequestAnimationFrame());
+  startUIRuntime(JSIWorkletsModuleProxy::createForNewRuntime(rnRuntimeProxy_, RuntimeData::uiRuntimeId));
 }
 
 WorkletsModuleProxy::WorkletsModuleProxy(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::shared_ptr<UIScheduler> &uiScheduler,
-    std::function<bool()> &&isJavaScriptThread,
     const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-    const BundleModeConfig &bundleModeConfig,
     const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus)
-    : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
-      jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker, std::move(isJavaScriptThread))),
+    : isDevBundle_(false),
+      jsScheduler_(jsScheduler),
       uiScheduler_(uiScheduler),
       jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
       runtimeBindings_(runtimeBindings),
-      bundleModeConfig_(bundleModeConfig),
+      bundleModeConfig_{.enabled = false},
       memoryManager_(std::make_shared<MemoryManager>()),
       runtimeManager_(std::make_shared<RuntimeManager>()),
       unpackerLoader_(std::make_shared<UnpackerLoader>()),
       rnRuntimeStatus_(rnRuntimeStatus),
+      networking_(
+          runtimeBindings->networkingBackend ? std::make_shared<Networking>(runtimeBindings->networkingBackend)
+                                             : nullptr),
       uiWorkletRuntime_(runtimeManager_->createUninitializedUIRuntime(std::make_shared<AsyncQueueUI>(uiScheduler_))),
-      rnRuntimeProxy_(std::make_shared<JSIWorkletsModuleProxy>(
-          isDevBundle_,
-          jsScheduler_,
-          uiScheduler_,
-          memoryManager_,
-          runtimeManager_,
-          uiWorkletRuntime_,
-          runtimeBindings_,
-          bundleModeConfig_,
-          unpackerLoader_,
-          rnRuntimeStatus_,
-          RuntimeData::rnRuntimeId)) {
+      uiRuntimeStarted_(false) {}
+
+void WorkletsModuleProxy::startUIRuntimeInBundleModeAOT(const BundleModeConfig &bundleModeConfig) {
+  if (!bundleModeConfig.enabled) [[unlikely]] {
+    throw std::runtime_error("[Worklets] startUIRuntimeInBundleModeAOT requires Bundle Mode.");
+  }
+  if (rnRuntimeProxy_) [[unlikely]] {
+    throw std::runtime_error("[Worklets] startUIRuntimeInBundleModeAOT must be called before attachToRNRuntime.");
+  }
+  if (uiRuntimeStarted_) [[unlikely]] {
+    throw std::runtime_error("[Worklets] The UI Worklet Runtime was already started.");
+  }
+
+  bundleModeConfig_ = bundleModeConfig;
+  startUIRuntime(std::make_shared<JSIWorkletsModuleProxy>(
+      false, /* isDevBundle_ */
+      jsScheduler_,
+      uiScheduler_,
+      memoryManager_,
+      runtimeManager_,
+      uiWorkletRuntime_,
+      runtimeBindings_,
+      networking_,
+      bundleModeConfig_,
+      unpackerLoader_,
+      rnRuntimeStatus_,
+      RuntimeData::uiRuntimeId));
+}
+
+void WorkletsModuleProxy::attachToRNRuntime(
+    jsi::Runtime &rnRuntime,
+    const std::optional<BundleModeConfig> &bundleModeConfig) {
+  react_native_assert(jsScheduler_->canInvokeSyncOnJS() && "attachToRNRuntime must be called on the JS thread");
+  if (rnRuntimeProxy_) [[unlikely]] {
+    throw std::runtime_error("[Worklets] WorkletsModuleProxy is already attached to the RN runtime.");
+  }
+  if (uiRuntimeStarted_ && bundleModeConfig.has_value()) [[unlikely]] {
+    throw std::runtime_error("[Worklets] The Bundle Mode config was already set by startUIRuntimeInBundleModeAOT.");
+  }
+  if (!uiRuntimeStarted_ && !bundleModeConfig.has_value()) [[unlikely]] {
+    throw std::runtime_error(
+        "[Worklets] attachToRNRuntime requires a Bundle Mode config unless startUIRuntimeInBundleModeAOT was called.");
+  }
+
+  isDevBundle_ = isDevBundleFromRNRuntime(rnRuntime);
+  if (bundleModeConfig.has_value()) {
+    bundleModeConfig_ = *bundleModeConfig;
+  }
+  rnRuntimeProxy_ = std::make_shared<JSIWorkletsModuleProxy>(
+      isDevBundle_,
+      jsScheduler_,
+      uiScheduler_,
+      memoryManager_,
+      runtimeManager_,
+      uiWorkletRuntime_,
+      runtimeBindings_,
+      networking_,
+      bundleModeConfig_,
+      unpackerLoader_,
+      rnRuntimeStatus_,
+      RuntimeData::rnRuntimeId);
+
   RNRuntimeWorkletDecorator::decorate(rnRuntime, rnRuntimeProxy_->toOptimizedObject(rnRuntime), jsLogger_);
 }
 
 WorkletsModuleProxy::~WorkletsModuleProxy() {
+  if (networking_) {
+    networking_->abortAll();
+  }
   animationFrameBatchinator_.reset();
   uiWorkletRuntime_.reset();
 }
 
+void WorkletsModuleProxy::startUIRuntime(const std::shared_ptr<JSIWorkletsModuleProxy> &uiRuntimeProxy) {
+  uiWorkletRuntime_->init(uiRuntimeProxy);
+
+  animationFrameBatchinator_ =
+      std::make_shared<AnimationFrameBatchinator>(uiWorkletRuntime_, runtimeBindings_->requestAnimationFrame);
+
+  UIRuntimeDecorator::decorate(
+      uiWorkletRuntime_->getJSIRuntime(), animationFrameBatchinator_->getJsiRequestAnimationFrame());
+
+  uiRuntimeStarted_ = true;
+}
+
 } // namespace worklets