react-native-worklets 0.7.2 → 0.8.0-bundle-mode-preview-1

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

@@ -54,10 +54,8 @@ inline void scheduleOnUI(
   });
 }
 
-inline jsi::Value executeOnUIRuntimeSync(
-    const std::weak_ptr<WorkletRuntime> &weakUIWorkletRuntime,
-    jsi::Runtime &rt,
-    const jsi::Value &worklet) {
+inline jsi::Value
+runOnUISync(const std::weak_ptr<WorkletRuntime> &weakUIWorkletRuntime, jsi::Runtime &rt, const jsi::Value &worklet) {
   if (auto uiWorkletRuntime = weakUIWorkletRuntime.lock()) {
     auto serializableWorklet = extractSerializableOrThrow<SerializableWorklet>(
         rt, worklet, "[Worklets] Only worklets can be executed on UI runtime.");
@@ -67,6 +65,14 @@ inline jsi::Value executeOnUIRuntimeSync(
   return jsi::Value::undefined();
 }
 
+jsi::Value
+runOnRuntimeSync(jsi::Runtime &rt, const jsi::Value &workletRuntimeValue, const jsi::Value &serializableWorkletValue) {
+  auto workletRuntime = workletRuntimeValue.getObject(rt).getHostObject<WorkletRuntime>(rt);
+  auto worklet = extractSerializableOrThrow<SerializableWorklet>(
+      rt, serializableWorkletValue, "[Worklets] Only worklets can be executed on a worklet runtime.");
+  return workletRuntime->runSyncSerialized(worklet)->toJSValue(rt);
+}
+
 inline jsi::Value createWorkletRuntime(
     jsi::Runtime &originRuntime,
     const std::shared_ptr<RuntimeManager> &runtimeManager,
@@ -81,7 +87,7 @@ inline jsi::Value createWorkletRuntime(
   return jsi::Object::createFromHostObject(originRuntime, workletRuntime);
 }
 
-#ifdef WORKLETS_BUNDLE_MODE
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
 inline jsi::Value propagateModuleUpdate(
     const std::shared_ptr<RuntimeManager> &runtimeManager,
     const std::string &code,
@@ -96,7 +102,7 @@ inline jsi::Value propagateModuleUpdate(
   }
   return jsi::Value::undefined();
 }
-#endif // WORKLETS_BUNDLE_MODE
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
 inline jsi::Value reportFatalErrorOnJS(
     const std::shared_ptr<JSScheduler> &jsScheduler,
@@ -146,14 +152,15 @@ inline void registerCustomSerializable(
 
 JSIWorkletsModuleProxy::JSIWorkletsModuleProxy(
     const bool isDevBundle,
-    const std::shared_ptr<const JSBigStringBuffer> &script,
+    const std::shared_ptr<const ScriptBuffer> &script,
     const std::string &sourceUrl,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::shared_ptr<UIScheduler> &uiScheduler,
     const std::shared_ptr<MemoryManager> &memoryManager,
     const std::shared_ptr<RuntimeManager> &runtimeManager,
-    const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime)
+    const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings)
     : jsi::HostObject(),
       isDevBundle_(isDevBundle),
       script_(script),
@@ -163,19 +170,8 @@ JSIWorkletsModuleProxy::JSIWorkletsModuleProxy(
       uiScheduler_(uiScheduler),
       memoryManager_(memoryManager),
       runtimeManager_(runtimeManager),
-      uiWorkletRuntime_(uiWorkletRuntime) {}
-
-JSIWorkletsModuleProxy::JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other)
-    : jsi::HostObject(),
-      isDevBundle_(other.isDevBundle_),
-      script_(other.script_),
-      sourceUrl_(other.sourceUrl_),
-      jsQueue_(other.jsQueue_),
-      jsScheduler_(other.jsScheduler_),
-      uiScheduler_(other.uiScheduler_),
-      memoryManager_(other.memoryManager_),
-      runtimeManager_(other.runtimeManager_),
-      uiWorkletRuntime_(other.uiWorkletRuntime_) {}
+      uiWorkletRuntime_(uiWorkletRuntime),
+      runtimeBindings_(runtimeBindings) {}
 
 JSIWorkletsModuleProxy::~JSIWorkletsModuleProxy() = default;
 
@@ -203,7 +199,8 @@ std::vector<jsi::PropNameID> JSIWorkletsModuleProxy::getPropertyNames(jsi::Runti
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "registerCustomSerializable"));
 
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "scheduleOnUI"));
-  propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "executeOnUIRuntimeSync"));
+  propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "runOnUISync"));
+  propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "runOnRuntimeSync"));
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "createWorkletRuntime"));
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "scheduleOnRuntime"));
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "reportFatalErrorOnJS"));
@@ -218,9 +215,9 @@ std::vector<jsi::PropNameID> JSIWorkletsModuleProxy::getPropertyNames(jsi::Runti
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "synchronizableLock"));
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "synchronizableUnlock"));
 
-#ifdef WORKLETS_BUNDLE_MODE
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "propagateModuleUpdate"));
-#endif // WORKLETS_BUNDLE_MODE
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   return propertyNames;
 }
@@ -385,14 +382,21 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
         });
   }
 
-  if (name == "executeOnUIRuntimeSync") {
+  if (name == "runOnUISync") {
     return jsi::Function::createFromHostFunction(
         rt,
         propName,
         1,
         [uiWorkletRuntime = uiWorkletRuntime_](
             jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
-          return executeOnUIRuntimeSync(uiWorkletRuntime, rt, args[0]);
+          return runOnUISync(uiWorkletRuntime, rt, args[0]);
+        });
+  }
+
+  if (name == "runOnRuntimeSync") {
+    return jsi::Function::createFromHostFunction(
+        rt, propName, 2, [](jsi::Runtime &rt, const jsi ::Value &thisValue, const jsi::Value *args, size_t count) {
+          return runOnRuntimeSync(rt, args[0], args[1]);
         });
   }
 
@@ -506,7 +510,7 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
         });
   }
 
-#ifdef WORKLETS_BUNDLE_MODE
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   if (name == "propagateModuleUpdate") {
     return jsi::Function::createFromHostFunction(
         rt,
@@ -520,7 +524,7 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
               /* sourceURL */ args[1].asString(rt).utf8(rt));
         });
   }
-#endif // WORKLETS_BUNDLE_MODE
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   if (name == "getStaticFeatureFlag") {
     return jsi::Function::createFromHostFunction(

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

@@ -8,6 +8,8 @@
 #include <worklets/SharedItems/MemoryManager.h>
 #include <worklets/SharedItems/Serializable.h>
 #include <worklets/Tools/Defs.h>
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/RuntimeManager.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
 
@@ -31,16 +33,17 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
  public:
   explicit JSIWorkletsModuleProxy(
       const bool isDevBundle,
-      const std::shared_ptr<const JSBigStringBuffer> &script,
+      const std::shared_ptr<const ScriptBuffer> &script,
       const std::string &sourceUrl,
       const std::shared_ptr<MessageQueueThread> &jsQueue,
       const std::shared_ptr<JSScheduler> &jsScheduler,
       const std::shared_ptr<UIScheduler> &uiScheduler,
       const std::shared_ptr<MemoryManager> &memoryManager,
       const std::shared_ptr<RuntimeManager> &runtimeManager,
-      const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime);
+      const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings);
 
-  JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other);
+  JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other) = default;
 
   ~JSIWorkletsModuleProxy() override;
 
@@ -64,7 +67,7 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
     return isDevBundle_;
   }
 
-  [[nodiscard]] std::shared_ptr<const JSBigStringBuffer> getScript() const {
+  [[nodiscard]] std::shared_ptr<const ScriptBuffer> getScript() const {
     return script_;
   }
 
@@ -80,9 +83,13 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
     return runtimeManager_;
   }
 
+  [[nodiscard]] std::shared_ptr<RuntimeBindings> getRuntimeBindings() const {
+    return runtimeBindings_;
+  }
+
  private:
   const bool isDevBundle_;
-  const std::shared_ptr<const JSBigStringBuffer> script_;
+  const std::shared_ptr<const ScriptBuffer> script_;
   const std::string sourceUrl_;
   const std::shared_ptr<MessageQueueThread> jsQueue_;
   const std::shared_ptr<JSScheduler> jsScheduler_;
@@ -90,6 +97,7 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
   const std::shared_ptr<MemoryManager> memoryManager_;
   const std::shared_ptr<RuntimeManager> runtimeManager_;
   const std::weak_ptr<WorkletRuntime> uiWorkletRuntime_;
+  const std::shared_ptr<RuntimeBindings> runtimeBindings_;
 };
 
 } // namespace worklets

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

@@ -5,6 +5,7 @@
 #include <worklets/RunLoop/AsyncQueueImpl.h>
 #include <worklets/SharedItems/Serializable.h>
 #include <worklets/Tools/Defs.h>
+#include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
 
@@ -28,15 +29,15 @@ WorkletsModuleProxy::WorkletsModuleProxy(
     const std::shared_ptr<CallInvoker> &jsCallInvoker,
     const std::shared_ptr<UIScheduler> &uiScheduler,
     std::function<bool()> &&isJavaScriptThread,
-    RuntimeBindings runtimeBindings,
-    const std::shared_ptr<const JSBigStringBuffer> &script,
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+    const std::shared_ptr<const ScriptBuffer> &script,
     const std::string &sourceUrl)
     : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
       jsQueue_(jsQueue),
       jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker, std::move(isJavaScriptThread))),
       uiScheduler_(uiScheduler),
       jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
-      runtimeBindings_(std::move(runtimeBindings)),
+      runtimeBindings_(runtimeBindings),
       script_(script),
       sourceUrl_(sourceUrl),
       memoryManager_(std::make_shared<MemoryManager>()),
@@ -50,7 +51,7 @@ WorkletsModuleProxy::WorkletsModuleProxy(
   uiWorkletRuntime_->init(createJSIWorkletsModuleProxy());
 
   animationFrameBatchinator_ =
-      std::make_shared<AnimationFrameBatchinator>(uiWorkletRuntime_, runtimeBindings_.requestAnimationFrame);
+      std::make_shared<AnimationFrameBatchinator>(uiWorkletRuntime_, runtimeBindings_->requestAnimationFrame);
 
   UIRuntimeDecorator::decorate(
       uiWorkletRuntime_->getJSIRuntime(), animationFrameBatchinator_->getJsiRequestAnimationFrame());
@@ -67,7 +68,8 @@ std::shared_ptr<JSIWorkletsModuleProxy> WorkletsModuleProxy::createJSIWorkletsMo
       uiScheduler_,
       memoryManager_,
       runtimeManager_,
-      uiWorkletRuntime_);
+      uiWorkletRuntime_,
+      runtimeBindings_);
 }
 
 WorkletsModuleProxy::~WorkletsModuleProxy() {

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

@@ -9,6 +9,7 @@
 #include <worklets/Tools/Defs.h>
 #include <worklets/Tools/JSLogger.h>
 #include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/Tools/SingleInstanceChecker.h>
 #include <worklets/Tools/UIScheduler.h>
 #include <worklets/WorkletRuntime/RuntimeManager.h>
@@ -27,8 +28,8 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
       const std::shared_ptr<CallInvoker> &jsCallInvoker,
       const std::shared_ptr<UIScheduler> &uiScheduler,
       std::function<bool()> &&isJavaScriptQueue,
-      RuntimeBindings runtimeBindings,
-      const std::shared_ptr<const JSBigStringBuffer> &script,
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+      const std::shared_ptr<const ScriptBuffer> &script,
       const std::string &sourceUrl);
 
   ~WorkletsModuleProxy();
@@ -65,8 +66,8 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
   const std::shared_ptr<JSScheduler> jsScheduler_;
   const std::shared_ptr<UIScheduler> uiScheduler_;
   const std::shared_ptr<JSLogger> jsLogger_;
-  const RuntimeBindings runtimeBindings_;
-  const std::shared_ptr<const JSBigStringBuffer> script_;
+  const std::shared_ptr<RuntimeBindings> runtimeBindings_;
+  const std::shared_ptr<const ScriptBuffer> script_;
   const std::string sourceUrl_;
   const std::shared_ptr<MemoryManager> memoryManager_;
   const std::shared_ptr<RuntimeManager> runtimeManager_;

package/Common/cpp/worklets/Resources/SynchronizableUnpacker.cpp

@@ -8,9 +8,9 @@ namespace worklets {
 
 const char SynchronizableUnpackerCode[] =
     R"DELIMITER__((function () {
-  var serializer = !globalThis._WORKLET || globalThis._WORKLETS_BUNDLE_MODE ? function (value, _) {
-    return (0, _serializable.createSerializable)(value);
-  } : globalThis._createSerializable;
+  var serializer = !globalThis._WORKLET || globalThis._WORKLETS_BUNDLE_MODE_ENABLED ? _serializable.createSerializable : function (value) {
+    return globalThis.__serializer(value);
+  };
   function synchronizableUnpacker(synchronizableRef) {
     var synchronizable = synchronizableRef;
     var proxy = globalThis.__workletsModuleProxy;
@@ -28,12 +28,12 @@ const char SynchronizableUnpackerCode[] =
         synchronizable.lock();
         var prev = synchronizable.getBlocking();
         newValue = func(prev);
-        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, undefined));
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue));
         synchronizable.unlock();
       } else {
         var value = valueOrFunction;
         newValue = value;
-        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, undefined));
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue));
       }
     };
     synchronizable.lock = function () {

package/Common/cpp/worklets/RunLoop/AsyncQueueImpl.cpp

@@ -1,5 +1,10 @@
 #include <worklets/RunLoop/AsyncQueueImpl.h>
 
+#if defined(ANDROID) && defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+#include <fbjni/detail/Environment.h>
+#include <jni.h>
+#endif // defined(ANDROID) && defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+
 #include <memory>
 #include <string>
 #include <thread>
@@ -7,30 +12,48 @@
 
 namespace worklets {
 
+using namespace facebook;
+
+void AsyncQueueImpl::runLoop(const std::shared_ptr<AsyncQueueState> &state) {
+  while (state->running) {
+    std::unique_lock<std::mutex> lock(state->mutex);
+    state->cv.wait(lock, [state] { return !state->queue.empty() || !state->running; });
+    if (!state->running) {
+      return;
+    }
+    if (state->queue.empty()) {
+      continue;
+    }
+    auto job = std::move(state->queue.front());
+    state->queue.pop();
+    lock.unlock();
+    job();
+  }
+}
+
 AsyncQueueImpl::AsyncQueueImpl(const std::string &name) : state_(std::make_shared<AsyncQueueState>()) {
+#if defined(ANDROID) && defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+  auto *env = jni::Environment::current();
+  JavaVM *jvm = nullptr;
+  env->GetJavaVM(&jvm);
+  auto thread = std::thread([name, state = state_, jvm] {
+    jvm->AttachCurrentThread(nullptr, nullptr);
+    jni::ThreadScope::WithClassLoader([state]() { AsyncQueueImpl::runLoop(state); });
+    jvm->DetachCurrentThread();
+  });
+  pthread_setname_np(thread.native_handle(), name.c_str());
+  thread.detach();
+#elif defined(ANDROID)
+  auto thread = std::thread([name, state = state_] { AsyncQueueImpl::runLoop(state); });
+  pthread_setname_np(thread.native_handle(), name.c_str());
+  thread.detach();
+#else
   auto thread = std::thread([name, state = state_] {
-#if __APPLE__
     pthread_setname_np(name.c_str());
-#endif
-    while (state->running) {
-      std::unique_lock<std::mutex> lock(state->mutex);
-      state->cv.wait(lock, [state] { return !state->queue.empty() || !state->running; });
-      if (!state->running) {
-        return;
-      }
-      if (state->queue.empty()) {
-        continue;
-      }
-      auto job = std::move(state->queue.front());
-      state->queue.pop();
-      lock.unlock();
-      job();
-    }
+    AsyncQueueImpl::runLoop(state);
   });
-#ifdef ANDROID
-  pthread_setname_np(thread.native_handle(), name.c_str());
-#endif
   thread.detach();
+#endif // defined(ANDROID) && defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
 }
 
 AsyncQueueImpl::~AsyncQueueImpl() {

package/Common/cpp/worklets/RunLoop/AsyncQueueImpl.h

@@ -28,6 +28,8 @@ class AsyncQueueImpl : public AsyncQueue {
   void push(std::function<void()> &&job) override;
 
  private:
+  static void runLoop(const std::shared_ptr<AsyncQueueState> &state);
+
   const std::shared_ptr<AsyncQueueState> state_;
 };
 

package/Common/cpp/worklets/Tools/Defs.h

@@ -9,7 +9,7 @@ so we have to check if headers are available.
 #define JS_RUNTIME_HERMES 1
 #endif
 
-#if REACT_NATIVE_MINOR_VERSION >= 84
+#if REACT_NATIVE_MINOR_VERSION >= 84 || defined(WORKLETS_BUNDLE_MODE_ENABLED)
 #include <cxxreact/JSBigString.h>
 namespace worklets {
 using JSBigStringBuffer = facebook::react::JSBigString;
@@ -19,4 +19,4 @@ using JSBigStringBuffer = facebook::react::JSBigString;
 namespace worklets {
 using JSBigStringBuffer = facebook::react::BigStringBuffer;
 }
-#endif // REACT_NATIVE_MINOR_VERSION >= 84
+#endif // REACT_NATIVE_MINOR_VERSION >= 84 || defined(WORKLETS_BUNDLE_MODE_ENABLED)

package/Common/cpp/worklets/Tools/ScriptBuffer.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <cxxreact/JSBigString.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace facebook::react;
+
+/**
+  * Our custom copyable structure that is accepted by
+  * Hermes Runtime for evaluation.
+ */
+class ScriptBuffer : public jsi::Buffer {
+ public:
+  explicit ScriptBuffer(std::shared_ptr<const JSBigString> script) : script_(std::move(script)) {}
+
+  size_t size() const override {
+    return script_->size();
+  }
+
+  const uint8_t *data() const override {
+    return reinterpret_cast<const uint8_t *>(script_->c_str());
+  }
+
+ private:
+  std::shared_ptr<const JSBigString> script_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/RuntimeBindings.h

@@ -12,6 +12,30 @@ struct RuntimeBindings {
   using RequestAnimationFrame = std::function<void(std::function<void(const double)>)>;
 
   const RequestAnimationFrame requestAnimationFrame;
+
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+  using AbortRequest = std::function<void(jsi::Runtime &rt, double requestId)>;
+  using ClearCookies = std::function<void(jsi::Runtime &rt, jsi::Function &&responseSender)>;
+#ifdef ANDROID
+  using SendRequest = std::function<void(
+      jsi::Runtime &rt,
+      jsi::String &method,
+      jsi::String &url,
+      double requestId,
+      jsi::Array &headers,
+      jsi::Object &data,
+      jsi::String &responseType,
+      bool incrementalUpdates,
+      double timeout,
+      bool withCredentials)>;
+#else
+  using SendRequest = std::function<void(jsi::Runtime &rt, const jsi::Value &query, jsi::Function &&responseSender)>;
+#endif // ANDROID
+
+  const AbortRequest abortRequest;
+  const ClearCookies clearCookies;
+  const SendRequest sendRequest;
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
 };
 
 } // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.cpp

@@ -100,32 +100,37 @@ void WorkletRuntime::init(std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsMod
   const auto jsScheduler = jsiWorkletsModuleProxy->getJSScheduler();
   const auto isDevBundle = jsiWorkletsModuleProxy->isDevBundle();
   const auto memoryManager_ = jsiWorkletsModuleProxy->getMemoryManager();
-#ifdef WORKLETS_BUNDLE_MODE
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   auto script = jsiWorkletsModuleProxy->getScript();
   const auto &sourceUrl = jsiWorkletsModuleProxy->getSourceUrl();
-#endif // WORKLETS_BUNDLE_MODE
+  auto runtimeBindings = jsiWorkletsModuleProxy->getRuntimeBindings();
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   auto optimizedJsiWorkletsModuleProxy = jsi_utils::optimizedFromHostObject(rt, std::move(jsiWorkletsModuleProxy));
 
   WorkletRuntimeDecorator::decorate(
       rt, name_, jsScheduler, isDevBundle, std::move(optimizedJsiWorkletsModuleProxy), eventLoop_);
 
-#ifdef WORKLETS_BUNDLE_MODE
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   if (!script) {
     throw std::runtime_error("[Worklets] Expected to receive the bundle, but got nullptr instead.");
   }
 
   try {
     rt.evaluateJavaScript(script, sourceUrl);
-  } catch (facebook::jsi::JSError error) {
+  } catch (facebook::jsi::JSError &error) {
     const auto &message = error.getMessage();
     const auto &stack = error.getStack();
     if (!message.starts_with("[Worklets] Worklets initialized successfully")) {
-      const auto newMessage = "[Worklets] Failed to initialize runtime. Reason: " + message;
+      const auto newMessage = "[Worklets] Failed to initialize runtime. Reason: " + message + " " + stack;
       JSLogger::reportFatalErrorOnJS(
           jsScheduler, {.message = newMessage, .stack = stack, .name = "WorkletsError", .jsEngine = "Worklets"});
+      return;
     }
   }
+
+  WorkletRuntimeDecorator::postEvaluateScript(rt, runtimeBindings);
+
 #else
   // Legacy behavior
   auto valueUnpackerBuffer = std::make_shared<const jsi::StringBuffer>(ValueUnpackerCode);
@@ -136,7 +141,7 @@ void WorkletRuntime::init(std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsMod
 
   auto customSerializableUnpackerBuffer = std::make_shared<const jsi::StringBuffer>(CustomSerializableUnpackerCode);
   rt.evaluateJavaScript(customSerializableUnpackerBuffer, "customSerializableUnpacker");
-#endif // WORKLETS_BUNDLE_MODE
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
   try {
     memoryManager_->loadAllCustomSerializables(shared_from_this());
   } catch (jsi::JSError &e) {

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.cpp

@@ -226,4 +226,86 @@ void WorkletRuntimeDecorator::decorate(
       });
 }
 
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
+void WorkletRuntimeDecorator::postEvaluateScript(
+    jsi::Runtime &rt,
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings) {
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+  installNetworking(rt, runtimeBindings);
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+}
+
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+void WorkletRuntimeDecorator::installNetworking(
+    jsi::Runtime &rt,
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings) {
+  auto TurboModules = rt.global().getPropertyAsObject(rt, "TurboModules");
+
+  auto Networking = TurboModules.getPropertyAsFunction(rt, "get").callWithThis(rt, TurboModules, "Networking");
+
+#ifdef ANDROID
+  auto jsiSendRequest = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "sendRequest"),
+      9,
+      [sendRequest = runtimeBindings->sendRequest](
+          jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+        auto method = args[0].asString(rt);
+        auto url = args[1].asString(rt);
+        auto requestId = args[2].asNumber();
+        auto headers = args[3].asObject(rt).asArray(rt);
+        auto data = args[4].asObject(rt);
+        auto responseType = args[5].asString(rt);
+        auto incrementalUpdates = args[6].asBool();
+        auto timeout = args[7].asNumber();
+        auto withCredentials = args[8].asBool();
+        sendRequest(
+            rt, method, url, requestId, headers, data, responseType, incrementalUpdates, timeout, withCredentials);
+        return jsi::Value::undefined();
+      });
+#else
+  auto jsiSendRequest = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "sendRequest"),
+      2,
+      [sendRequest = runtimeBindings->sendRequest](
+          jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+        auto &query = args[0];
+        auto responseSender = args[1].asObject(rt).asFunction(rt);
+        sendRequest(rt, query, std::move(responseSender));
+        return jsi::Value::undefined();
+      });
+#endif // ANDROID
+
+  Networking.asObject(rt).setProperty(rt, "sendRequest", std::move(jsiSendRequest));
+
+  auto jsiAbortRequest = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "abortRequest"),
+      1,
+      [abortRequest = runtimeBindings->abortRequest](
+          jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+        auto requestID = args[0].asNumber();
+        abortRequest(rt, requestID);
+        return jsi::Value::undefined();
+      });
+
+  Networking.asObject(rt).setProperty(rt, "abortRequest", std::move(jsiAbortRequest));
+
+  auto jsiClearCookies = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "clearCookies"),
+      1,
+      [clearCookies = runtimeBindings->clearCookies](
+          jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+        auto responseSender = args[0].asObject(rt).asFunction(rt);
+        clearCookies(rt, std::move(responseSender));
+        return jsi::Value::undefined();
+      });
+
+  Networking.asObject(rt).setProperty(rt, "clearCookies", std::move(jsiClearCookies));
+}
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
+
 } // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.h

@@ -2,6 +2,9 @@
 
 #include <worklets/RunLoop/EventLoop.h>
 #include <worklets/Tools/JSScheduler.h>
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
 #include <jsi/jsi.h>
 
@@ -21,6 +24,15 @@ class WorkletRuntimeDecorator {
       const bool isDevBundle,
       jsi::Object &&jsiWorkletsModuleProxy,
       const std::shared_ptr<EventLoop> &eventLoop);
+
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
+  static void postEvaluateScript(jsi::Runtime &rt, const std::shared_ptr<RuntimeBindings> &runtimeBindings);
+
+ private:
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+  static void installNetworking(jsi::Runtime &rt, const std::shared_ptr<RuntimeBindings> &runtimeBindings);
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
 };
 
 } // namespace worklets