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

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

@@ -0,0 +1,256 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/RunLoop/AsyncQueue.h>
+#include <worklets/RunLoop/AsyncQueueImpl.h>
+#include <worklets/RunLoop/EventLoop.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/UnpackerLoader.h>
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+template <typename TCallable>
+concept ImplicitlySerializableCallable = std::is_assignable_v<const jsi::Function &, TCallable> ||
+    std::is_assignable_v<const std::shared_ptr<SerializableWorklet> &, TCallable>;
+
+template <typename TCallable>
+concept RuntimeCallable = requires(TCallable &&callable, jsi::Runtime &rt) {
+  { callable(rt) };
+} || ImplicitlySerializableCallable<TCallable>;
+
+/**
+ * Forward declaration to avoid circular dependencies.
+ */
+class JSIWorkletsModuleProxy;
+
+class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_this<WorkletRuntime> {
+ public:
+  void schedule(jsi::Function &&function) const;
+  void schedule(std::shared_ptr<SerializableWorklet> worklet) const;
+#ifndef NDEBUG
+  void schedule(std::shared_ptr<SerializableWorklet> worklet, std::optional<std::string> scheduleStack) const;
+#endif // NDEBUG
+  void schedule(std::function<void()> job) const;
+  void schedule(std::function<void(jsi::Runtime &)> job) const;
+
+  /* #region runSync */
+
+  template <RuntimeCallable TCallable, typename... Args>
+  std::invoke_result_t<TCallable, Args...> runSync(TCallable &&callable, Args &&...args) const;
+  template <typename... Args>
+  jsi::Value runSync(const jsi::Function &function, Args &&...args) const {
+#ifndef NDEBUG
+    return callGuarded(function, std::nullopt, std::forward<Args>(args)...);
+#else
+    return function.call(*runtime_, args...);
+#endif // NDEBUG
+  }
+  template <typename... Args>
+  jsi::Value runSync(const std::shared_ptr<SerializableWorklet> &worklet, Args &&...args) const {
+#ifndef NDEBUG
+    return runSyncWithStack(worklet, std::nullopt, std::forward<Args>(args)...);
+#else
+    jsi::Runtime &rt = *runtime_;
+    auto function = worklet->toJSValue(rt).asObject(rt).asFunction(rt);
+    return function.call(rt, args...);
+#endif // NDEBUG
+  }
+#ifndef NDEBUG
+  template <typename... Args>
+  jsi::Value runSyncWithStack(
+      const std::shared_ptr<SerializableWorklet> &worklet,
+      const std::optional<std::string> &scheduleStack,
+      Args &&...args) const {
+    jsi::Runtime &rt = *runtime_;
+    auto function = worklet->toJSValue(rt).asObject(rt).asFunction(rt);
+    return callGuarded(function, scheduleStack, std::forward<Args>(args)...);
+  }
+#endif // NDEBUG
+  template <RuntimeCallable TCallable>
+  std::invoke_result_t<TCallable, jsi::Runtime &> runSync(TCallable &&job) const {
+    jsi::Runtime &rt = getJSIRuntime();
+    auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+    return job(rt);
+  }
+
+  /* #endregion */
+
+  void callMicrotasks() const;
+
+  /* #region runSyncSerialized */
+
+  template <ImplicitlySerializableCallable TCallable, typename... Args>
+  std::shared_ptr<Serializable> runSyncSerialized(TCallable &&callable, Args &&...args) const;
+  template <typename... Args>
+  std::shared_ptr<Serializable> runSyncSerialized(const jsi::Function &function, Args &&...args) const {
+    jsi::Runtime &rt = getJSIRuntime();
+    auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+    auto result = runSync(function, std::forward<Args>(args)...);
+    auto serializableResult = extractSerializableOrThrow(
+        rt,
+        result,
+        "[Worklets] Function passed to `runSyncSerialized`"
+        "must return a value serialized with `createSerializable`.");
+    return serializableResult;
+  }
+#ifndef NDEBUG
+  template <typename... Args>
+  std::shared_ptr<Serializable> runSyncSerializedWithStack(
+      const std::shared_ptr<SerializableWorklet> &worklet,
+      const std::optional<std::string> &scheduleStack,
+      Args &&...args) const {
+    jsi::Runtime &rt = getJSIRuntime();
+    auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+    auto result = runSyncWithStack(worklet, scheduleStack, std::forward<Args>(args)...);
+    auto serializableResult = extractSerializableOrThrow(
+        rt,
+        result,
+        "[Worklets] Worklet passed to `runSyncSerialized`"
+        "must return a value serialized with `createSerializable`.");
+    return serializableResult;
+  }
+#endif // NDEBUG
+  template <typename... Args>
+  std::shared_ptr<Serializable> runSyncSerialized(const std::shared_ptr<SerializableWorklet> &worklet, Args &&...args)
+      const {
+    jsi::Runtime &rt = getJSIRuntime();
+    auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+    auto result = runSync(worklet, std::forward<Args>(args)...);
+    auto serializableResult = extractSerializableOrThrow(
+        rt,
+        result,
+        "[Worklets] Worklet passed to `runSyncSerialized`"
+        "must return a value serialized with `createSerializable`.");
+    return serializableResult;
+  }
+  /* #endregion */
+
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  [[nodiscard]] std::string toString() const noexcept {
+    return "[WorkletRuntime \"" + name_ + "\"]";
+  }
+
+  [[nodiscard]] jsi::Runtime &getJSIRuntime() const noexcept {
+    return *runtime_;
+  }
+
+  [[nodiscard]] RuntimeData::RuntimeId getRuntimeId() const noexcept {
+    return runtimeId_;
+  }
+
+  [[nodiscard]] std::string getRuntimeName() const noexcept {
+    return name_;
+  }
+
+  explicit WorkletRuntime(
+      RuntimeData::RuntimeId runtimeId,
+      RuntimeData::RuntimeKind runtimeKind,
+      const std::string &name,
+      const std::shared_ptr<AsyncQueue> &queue = nullptr,
+      bool enableEventLoop = true);
+
+  void init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWorkletsModuleProxy);
+
+  /* #region deprecated */
+
+  /** @deprecated Use `runSync` instead. */
+  template <typename... Args>
+  jsi::Value runGuarded(const std::shared_ptr<SerializableWorklet> &worklet, Args &&...args) const {
+    return runSync(worklet, std::forward<Args>(args)...);
+  }
+
+  /** @deprecated Use `schedule` instead. */
+  void runAsyncGuarded(const std::shared_ptr<SerializableWorklet> &worklet);
+
+  /** @deprecated Use `runSyncSerialized` and extract to `jsi::Value` with
+   * `extractSerializableOrThrow` instead. */
+  jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const;
+  /** @deprecated Use `runSync` instead. */
+  jsi::Value executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const;
+  /** @deprecated Use `runSync` instead. */
+  jsi::Value executeSync(const std::function<jsi::Value(jsi::Runtime &)> &job) const;
+
+  /* #endregion */
+
+  /**
+   * Retrieves a weak reference to the WorkletRuntime associated with the
+   * provided jsi::Runtime.
+   *
+   * Throws when invoked with a non-worklet runtime.
+   *
+   * Available only on React Native 0.81 and higher.
+   */
+  static std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(jsi::Runtime &rt);
+
+ private:
+#ifndef NDEBUG
+  // Wraps the provided function in a try/catch so an exception thrown on the
+  // worklet runtime can be reported on the RN Runtime LogBox with a
+  // stack pointing back to the JS call site that scheduled the worklet.
+  template <typename... Args>
+  jsi::Value callGuarded(const jsi::Function &function, const std::optional<std::string> &scheduleStack, Args &&...args)
+      const {
+    auto &rt = *runtime_;
+    try {
+      return function.call(rt, args...);
+    } catch (jsi::JSError &e) {
+      JSLogger::handleJSError(jsScheduler_, rt, name_, e, scheduleStack);
+      return jsi::Value::undefined();
+    }
+  }
+#endif // NDEBUG
+
+  void bundleModeInit(
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<const ScriptBuffer> &script,
+      const std::string &sourceUrl,
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings);
+
+  void legacyModeInit(const std::shared_ptr<UnpackerLoader> &unpackerLoader);
+
+  const RuntimeData::RuntimeId runtimeId_;
+  const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
+  const std::shared_ptr<jsi::Runtime> runtime_;
+  std::shared_ptr<JSScheduler> jsScheduler_;
+  const RuntimeData::RuntimeKind runtimeKind_;
+  const std::string name_;
+  std::shared_ptr<AsyncQueue> queue_;
+  std::shared_ptr<EventLoop> eventLoop_;
+};
+
+// This function needs to be non-inline to avoid problems with dynamic_cast on
+// Android
+std::shared_ptr<WorkletRuntime> extractWorkletRuntime(jsi::Runtime &rt, const jsi::Value &value);
+
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &serializableWorkletValue);
+#ifndef NDEBUG
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &serializableWorkletValue,
+    const std::optional<std::string> &scheduleStack);
+#endif // NDEBUG
+
+} // namespace worklets

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace worklets {
+
+class WorkletRuntimeCollector : public jsi::HostObject {
+  // When worklet runtime is created, we inject an instance of this class as a
+  // `jsi::HostObject` into the global object. When worklet runtime is
+  // terminated, the object is garbage-collected, which runs the C++ destructor.
+  // In the destructor, we unregister the worklet runtime from the registry.
+
+ public:
+  explicit WorkletRuntimeCollector(jsi::Runtime &runtime) : runtime_(runtime) {
+    WorkletRuntimeRegistry::registerRuntime(runtime_);
+  }
+
+  ~WorkletRuntimeCollector() override {
+    WorkletRuntimeRegistry::unregisterRuntime(runtime_);
+  }
+
+  static void install(jsi::Runtime &rt) {
+    auto collector = std::make_shared<WorkletRuntimeCollector>(rt);
+    auto object = jsi::Object::createFromHostObject(rt, collector);
+    rt.global().setProperty(rt, "__workletRuntimeCollector", object);
+  }
+
+ private:
+  jsi::Runtime &runtime_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,320 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/SerializableFactory.h>
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/PlatformLogger.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/WorkletRuntime/HermesProfiling.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
+
+#ifdef ANDROID
+#include <android/trace.h>
+#endif
+
+#if defined(__APPLE__)
+#include <os/trace_base.h>
+#if OS_LOG_TARGET_HAS_10_15_FEATURES
+#include <os/log.h>
+#include <os/signpost.h>
+#endif
+#endif
+
+#include <chrono>
+#include <memory>
+#include <string>
+#include <utility>
+
+#if defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES
+static os_log_t workletsInstrumentsLogHandle = nullptr;
+static thread_local os_signpost_id_t tls_signpostId = OS_SIGNPOST_ID_INVALID;
+static thread_local std::string tls_signpostName;
+
+static os_log_t getWorkletsInstrumentsLogHandle() {
+  if (!workletsInstrumentsLogHandle) {
+    workletsInstrumentsLogHandle = os_log_create("dev.worklets.instruments", OS_LOG_CATEGORY_POINTS_OF_INTEREST);
+  }
+  return workletsInstrumentsLogHandle;
+}
+#endif
+
+namespace worklets {
+
+static inline double performanceNow() {
+  // copied from JSExecutor.cpp
+  auto time = std::chrono::steady_clock::now();
+  auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(time.time_since_epoch()).count();
+
+  constexpr double NANOSECONDS_IN_MILLISECOND = 1000000.0;
+  return duration / NANOSECONDS_IN_MILLISECOND;
+}
+
+void WorkletRuntimeDecorator::decorate(
+    jsi::Runtime &rt,
+    const RuntimeData::RuntimeKind runtimeKind,
+    const std::string &name,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const bool isDevBundle,
+    jsi::Object &&jsiWorkletsModuleProxy,
+    const std::shared_ptr<EventLoop> &eventLoop,
+    const RuntimeBindings::NativeLoggingHook &nativeLoggingHook) {
+  // resolves "ReferenceError: Property 'global' doesn't exist at ..."
+  rt.global().setProperty(rt, "global", rt.global());
+
+  rt.global().setProperty(rt, RuntimeData::runtimeKindBindingName, static_cast<int>(runtimeKind));
+
+  rt.global().setProperty(rt, "_WORKLET", true);
+
+  rt.global().setProperty(rt, RuntimeData::runtimeNameBindingName, jsi::String::createFromAscii(rt, name));
+
+  rt.global().setProperty(rt, "__DEV__", isDevBundle);
+
+  rt.global().setProperty(rt, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
+
+#ifndef NDEBUG
+  auto evalWithSourceUrl =
+      [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value {
+    auto code = std::make_shared<const jsi::StringBuffer>(args[0].asString(rt).utf8(rt));
+    std::string url;
+    if (count > 1 && args[1].isString()) {
+      url = args[1].asString(rt).utf8(rt);
+    }
+    return rt.evaluateJavaScript(code, url);
+  };
+  rt.global().setProperty(
+      rt,
+      "evalWithSourceUrl",
+      jsi::Function::createFromHostFunction(
+          rt, jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"), 1, evalWithSourceUrl));
+#endif // NDEBUG
+
+  jsi_utils::installJsiFunction(
+      rt, "_log", [](jsi::Runtime &rt, const jsi::Value &value) { PlatformLogger::log(stringifyJSIValue(rt, value)); });
+
+  if (nativeLoggingHook) {
+    rt.global().setProperty(
+        rt,
+        "nativeLoggingHook",
+        jsi::Function::createFromHostFunction(
+            rt, jsi::PropNameID::forAscii(rt, "nativeLoggingHook"), 2, nativeLoggingHook));
+  }
+
+  jsi_utils::installJsiFunction(rt, "_toString", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return jsi::String::createFromUtf8(rt, stringifyJSIValue(rt, value));
+  });
+
+  jsi_utils::installJsiFunction(rt, "_beginSection", [](jsi::Runtime &rt, const jsi::Value &nameValue) {
+#ifdef ANDROID
+    ATrace_beginSection(nameValue.asString(rt).utf8(rt).c_str());
+#elif defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES
+    os_log_t logHandle = getWorkletsInstrumentsLogHandle();
+    if (os_signpost_enabled(logHandle)) {
+      tls_signpostName = nameValue.asString(rt).utf8(rt);
+      tls_signpostId = os_signpost_id_make_with_pointer(logHandle, &tls_signpostId);
+      os_signpost_interval_begin(logHandle, tls_signpostId, "Worklets", "%s", tls_signpostName.c_str());
+    }
+#endif
+    return jsi::Value::undefined();
+  });
+
+  jsi_utils::installJsiFunction(rt, "_endSection", [](jsi::Runtime &rt) {
+#ifdef ANDROID
+    ATrace_endSection();
+#elif defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES
+    os_log_t logHandle = getWorkletsInstrumentsLogHandle();
+    if (os_signpost_enabled(logHandle) && tls_signpostId != OS_SIGNPOST_ID_INVALID) {
+      os_signpost_interval_end(logHandle, tls_signpostId, "Worklets", "%s end", tls_signpostName.c_str());
+      tls_signpostId = OS_SIGNPOST_ID_INVALID;
+    }
+#endif
+    return jsi::Value::undefined();
+  });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableHostObject", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableHostObject(rt, value.asObject(rt).asHostObject(rt));
+  });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableString", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableString(rt, value.asString(rt));
+  });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableNumber", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableNumber(rt, value.asNumber());
+  });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableBoolean", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableBoolean(rt, value.asBool());
+  });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableBigInt", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableBigInt(rt, value.asBigInt(rt));
+  });
+
+  jsi_utils::installJsiFunction(
+      rt, "_createSerializableUndefined", [](jsi::Runtime &rt) { return makeSerializableUndefined(rt); });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableArray", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableArray(rt, value.asObject(rt).asArray(rt), false);
+  });
+
+  jsi_utils::installJsiFunction(
+      rt, "_createSerializableNull", [](jsi::Runtime &rt) { return makeSerializableNull(rt); });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_createSerializableObject",
+      [](jsi::Runtime &rt,
+         const jsi::Value &value,
+         const jsi::Value &shouldRetainRemote,
+         const jsi::Value &nativeStateSource) {
+        return makeSerializableObject(rt, value.getObject(rt), shouldRetainRemote.getBool(), nativeStateSource);
+      });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableWorklet", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableWorklet(rt, value.asObject(rt), false);
+  });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableInitializer", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return makeSerializableInitializer(rt, value.asObject(rt));
+  });
+
+  jsi_utils::installJsiFunction(rt, "_createSerializableSynchronizable", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return SerializableJSRef::newNativeStateObject(rt, extractSerializableOrThrow(rt, value));
+  });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleOnRuntime",
+      [](jsi::Runtime &rt, const jsi::Value &workletRuntimeValue, const jsi::Value &serializableWorkletValue) {
+        scheduleOnRuntime(rt, workletRuntimeValue, serializableWorkletValue);
+      });
+
+  jsi::Object performance(rt);
+  performance.setProperty(
+      rt,
+      "now",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "now"),
+          0,
+          [](jsi::Runtime &runtime, const jsi::Value &, const jsi::Value *args, size_t count) {
+            return jsi::Value(performanceNow());
+          }));
+  rt.global().setProperty(rt, "performance", performance);
+
+  rt.global().setProperty(
+      rt,
+      "_startProfiling",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "_startProfiling"),
+          1,
+          [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
+            const double meanHzFreq = (count > 0 && !args[0].isUndefined()) ? args[0].asNumber() : 100.0;
+            startProfiling(rt, meanHzFreq);
+            return jsi::Value::undefined();
+          }));
+  jsi_utils::installJsiFunction(rt, "_stopProfiling", [](jsi::Runtime &rt) {
+    std::string path = stopProfiling(rt);
+    return jsi::String::createFromUtf8(rt, path);
+  });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleTimeoutCallback",
+      [weakEventLoop = std::weak_ptr<EventLoop>(eventLoop)](
+          jsi::Runtime &rt, const jsi::Value &delayJs, const jsi::Value &handlerIdJs) -> jsi::Value {
+        const auto delay = delayJs.asNumber();
+        const auto handlerId = handlerIdJs.asNumber();
+        const auto job = [handlerId](jsi::Runtime &rt) {
+          rt.global().getPropertyAsFunction(rt, "__runTimeoutCallback").call(rt, handlerId);
+        };
+        if (auto strongEventLoop = weakEventLoop.lock()) {
+          strongEventLoop->pushTimeout(job, delay);
+        }
+        return jsi::Value::undefined();
+      });
+}
+
+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
+
+} // namespace worklets

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/RunLoop/EventLoop.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeDecorator {
+ public:
+  static void decorate(
+      jsi::Runtime &rt,
+      const RuntimeData::RuntimeKind runtimeKind,
+      const std::string &name,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const bool isDevBundle,
+      jsi::Object &&jsiWorkletsModuleProxy,
+      const std::shared_ptr<EventLoop> &eventLoop,
+      const RuntimeBindings::NativeLoggingHook &nativeLoggingHook);
+
+  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
+};
+
+} // namespace worklets

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2024 nobody
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.