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

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

@@ -3,6 +3,7 @@
 #include <jsi/jsi.h>
 #include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
 #include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/Networking/Networking.h>
 #include <worklets/SharedItems/MemoryManager.h>
 #include <worklets/SharedItems/UnpackerLoader.h>
 #include <worklets/Tools/JSLogger.h>
@@ -16,20 +17,65 @@
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
+#include <optional>
 
 namespace worklets {
 
+/**
+ * The initialization is a sequence of steps. The steps which do not need the RN Runtime run on background threads
+ * before the bundle asks for the module. The steps which need the RN Runtime run on the JS thread.
+ *
+ * Every mode starts the same way:
+ *
+ *   1. Native module creation: the platform creates the native module before the bundle runs. The module creates a
+ *      `WorkletsModuleProxyInitializer` and dispatches `WorkletsModuleProxyInitializer::prepareProxy` to a
+ *      background thread.
+ *   2. Background thread: `prepareProxy` calls the constructor of this class. The constructor creates the UI Worklet
+ *      Runtime, but does not initialize it.
+ *
+ * Legacy Mode continues with:
+ *
+ *   3. JS thread: the bundle evaluates `NativeWorklets`, which calls `installTurboModule(false)`. The native module
+ *      calls `WorkletsModuleProxyInitializer::finalize`. It waits for step 2 and calls `attachToRNRuntime` with a
+ *      disabled Bundle Mode config. `attachToRNRuntime` creates the JSI proxy for the RN Runtime and installs it on
+ *      the RN Runtime.
+ *   4. JS thread: `NativeWorklets` hands the unpacker code to the JSI proxy.
+ *   5. JS thread: `NativeWorklets` calls `start`. It initializes the UI Worklet Runtime and evaluates the unpacker
+ *      code on it.
+ *
+ * Bundle Mode continues with:
+ *
+ *   3. JS thread: the `prepareBundleMode` polyfill runs before the first module of the bundle. The Worklets plugin
+ *      enables the polyfill only when Bundle Mode is on. The polyfill calls `prepareBundleMode` on the native
+ *      module. The module calls `WorkletsModuleProxyInitializer::beginBundleModeAOT` and dispatches
+ *      `WorkletsModuleProxyInitializer::prepareBundleModeAOT` to a background thread.
+ *   4. Background thread: `prepareBundleModeAOT` waits for step 2, loads the bundle and calls
+ *      `startUIRuntimeInBundleModeAOT`. It stores the Bundle Mode config, initializes the UI Worklet Runtime
+ * and evaluates the bundle on it. This runs in parallel with the JS thread, which evaluates the bundle on the RN
+ *      Runtime.
+ *   5. JS thread: the bundle evaluates `NativeWorklets`, which calls `installTurboModule(true)`. The native module
+ *      calls `WorkletsModuleProxyInitializer::finalize`. It waits for step 4 and calls `attachToRNRuntime` without
+ *      a Bundle Mode config, because step 4 already stored it. `attachToRNRuntime` creates the JSI proxy for the RN
+ *      Runtime and installs it on the RN Runtime.
+ *   6. JS thread: `NativeWorklets` calls `start`. It returns immediately, because step 4 already initialized the UI
+ *      Worklet Runtime.
+ *
+ * When Bundle Mode is enabled but the polyfill did not run, steps 3 and 4 are skipped. Step 5 then loads the bundle
+ * and passes the Bundle Mode config to `attachToRNRuntime`, and step 6 initializes the UI Worklet Runtime by
+ * evaluating the bundle on it, both on the JS thread.
+ */
 class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModuleProxy> {
  public:
+  void startUIRuntimeInBundleModeAOT(const BundleModeConfig &bundleModeConfig);
+
+  void attachToRNRuntime(jsi::Runtime &rnRuntime, const std::optional<BundleModeConfig> &bundleModeConfig);
+
   void start();
 
   explicit 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()> &&isJavaScriptQueue,
       const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-      const BundleModeConfig &bundleModeConfig,
       const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus);
 
   ~WorkletsModuleProxy();
@@ -55,19 +101,23 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
   }
 
  private:
-  const bool isDevBundle_;
+  void startUIRuntime(const std::shared_ptr<JSIWorkletsModuleProxy> &uiRuntimeProxy);
+
+  bool isDevBundle_;
   const std::shared_ptr<JSScheduler> jsScheduler_;
   const std::shared_ptr<UIScheduler> uiScheduler_;
   const std::shared_ptr<JSLogger> jsLogger_;
   const std::shared_ptr<RuntimeBindings> runtimeBindings_;
-  const BundleModeConfig bundleModeConfig_;
+  BundleModeConfig bundleModeConfig_;
   const std::shared_ptr<MemoryManager> memoryManager_;
   const std::shared_ptr<RuntimeManager> runtimeManager_;
   const std::shared_ptr<UnpackerLoader> unpackerLoader_;
   const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+  const std::shared_ptr<Networking> networking_;
   std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
-  const std::shared_ptr<JSIWorkletsModuleProxy> rnRuntimeProxy_;
+  std::shared_ptr<JSIWorkletsModuleProxy> rnRuntimeProxy_;
   std::shared_ptr<AnimationFrameBatchinator> animationFrameBatchinator_;
+  bool uiRuntimeStarted_;
 #ifndef NDEBUG
   SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
 #endif // NDEBUG

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxyInitializer.cpp

@@ -0,0 +1,94 @@
+#include <worklets/NativeModules/WorkletsModuleProxyInitializer.h>
+
+#include <react/debug/react_native_assert.h>
+
+#include <exception>
+#include <future>
+#include <optional>
+#include <stdexcept>
+#include <utility>
+
+namespace worklets {
+
+WorkletsModuleProxyInitializer::WorkletsModuleProxyInitializer(
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+    const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus)
+    : jsScheduler_(jsScheduler),
+      uiScheduler_(uiScheduler),
+      runtimeBindings_(runtimeBindings),
+      rnRuntimeStatus_(rnRuntimeStatus),
+      preparedProxy_(preparedProxyPromise_.get_future().share()),
+      aotProxy_(aotProxyPromise_.get_future().share()) {}
+
+void WorkletsModuleProxyInitializer::prepareProxy() {
+  try {
+    preparedProxyPromise_.set_value(
+        std::make_shared<WorkletsModuleProxy>(jsScheduler_, uiScheduler_, runtimeBindings_, rnRuntimeStatus_));
+  } catch (const std::future_error &) {
+    throw std::runtime_error("[Worklets] prepareProxy must be called exactly once.");
+  } catch (...) {
+    preparedProxyPromise_.set_exception(std::current_exception());
+  }
+}
+
+void WorkletsModuleProxyInitializer::beginBundleModeAOT() {
+  react_native_assert(jsScheduler_->canInvokeSyncOnJS() && "beginBundleModeAOT must be called on the JS thread");
+  std::lock_guard lock(mutex_);
+  if (stage_ != Stage::Created) [[unlikely]] {
+    throw std::runtime_error("[Worklets] beginBundleModeAOT must be called at most once and before finalize.");
+  }
+  stage_ = Stage::AOTBegun;
+}
+
+void WorkletsModuleProxyInitializer::prepareBundleModeAOT(const BundleModeConfigLoader &loadBundleModeConfig) {
+  try {
+    auto proxy = preparedProxy_.get();
+    proxy->startUIRuntimeInBundleModeAOT(loadBundleModeConfig());
+    aotProxyPromise_.set_value(std::move(proxy));
+  } catch (const std::future_error &) {
+    throw std::runtime_error("[Worklets] prepareBundleModeAOT must be called exactly once.");
+  } catch (...) {
+    aotProxyPromise_.set_exception(std::current_exception());
+  }
+}
+
+std::shared_ptr<WorkletsModuleProxy> WorkletsModuleProxyInitializer::finalize(
+    jsi::Runtime &rnRuntime,
+    const bool bundleModeEnabled,
+    const BundleModeConfigLoader &loadBundleModeConfig) {
+  react_native_assert(jsScheduler_->canInvokeSyncOnJS() && "finalize must be called on the JS thread");
+  bool startedAOT = false;
+  {
+    std::lock_guard lock(mutex_);
+    if (stage_ == Stage::Finalized || stage_ == Stage::Invalidated) [[unlikely]] {
+      throw std::runtime_error("[Worklets] finalize must be called at most once and before invalidate.");
+    }
+    startedAOT = stage_ == Stage::AOTBegun;
+    stage_ = Stage::Finalized;
+  }
+  auto proxy = (startedAOT ? aotProxy_ : preparedProxy_).get();
+  if (startedAOT) {
+    proxy->attachToRNRuntime(rnRuntime, std::nullopt);
+  } else {
+    proxy->attachToRNRuntime(
+        rnRuntime, bundleModeEnabled ? loadBundleModeConfig() : BundleModeConfig{.enabled = false});
+  }
+  return proxy;
+}
+
+void WorkletsModuleProxyInitializer::invalidate() {
+  bool startedAOT = false;
+  {
+    std::lock_guard lock(mutex_);
+    startedAOT = stage_ == Stage::AOTBegun;
+    stage_ = Stage::Invalidated;
+  }
+  if (startedAOT) {
+    aotProxy_.wait();
+  }
+  preparedProxy_.wait();
+}
+
+} // namespace worklets

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

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+
+#include <functional>
+#include <future>
+#include <memory>
+#include <mutex>
+
+namespace worklets {
+
+class WorkletsModuleProxyInitializer {
+ public:
+  using BundleModeConfigLoader = std::function<BundleModeConfig()>;
+
+  WorkletsModuleProxyInitializer(
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+      const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus);
+
+  void prepareProxy();
+
+  void beginBundleModeAOT();
+
+  void prepareBundleModeAOT(const BundleModeConfigLoader &loadBundleModeConfig);
+
+  std::shared_ptr<WorkletsModuleProxy>
+  finalize(jsi::Runtime &rnRuntime, bool bundleModeEnabled, const BundleModeConfigLoader &loadBundleModeConfig);
+
+  void invalidate();
+
+ private:
+  enum class Stage { Created, AOTBegun, Finalized, Invalidated };
+
+  using ProxyPromise = std::promise<std::shared_ptr<WorkletsModuleProxy>>;
+  using ProxyFuture = std::shared_future<std::shared_ptr<WorkletsModuleProxy>>;
+
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  const std::shared_ptr<RuntimeBindings> runtimeBindings_;
+  const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+
+  std::mutex mutex_;
+  Stage stage_{Stage::Created};
+  ProxyPromise preparedProxyPromise_;
+  ProxyFuture preparedProxy_;
+  ProxyPromise aotProxyPromise_;
+  ProxyFuture aotProxy_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Networking/Networking.cpp

@@ -0,0 +1,283 @@
+#include <worklets/Networking/Networking.h>
+#include <worklets/Networking/TextDecoding.h>
+#include <worklets/SharedItems/Serializable/SerializableRemoteFunction.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+namespace {
+
+class VectorBuffer final : public jsi::MutableBuffer {
+ public:
+  explicit VectorBuffer(std::vector<uint8_t> &&data) : data_(std::move(data)) {}
+
+  size_t size() const override {
+    return data_.size();
+  }
+
+  uint8_t *data() override {
+    return data_.data();
+  }
+
+ private:
+  std::vector<uint8_t> data_;
+};
+
+const char *errorName(const RequestError error) {
+  switch (error) {
+    case RequestError::Timeout:
+      return "timeout";
+    case RequestError::Aborted:
+      return "aborted";
+    case RequestError::Network:
+    default:
+      return "network";
+  }
+}
+
+std::vector<std::pair<std::string, std::string>> parseHeaders(jsi::Runtime &rt, const jsi::Object &config) {
+  std::vector<std::pair<std::string, std::string>> headers;
+  auto headersArray = config.getProperty(rt, "headers").asObject(rt).asArray(rt);
+  const auto length = headersArray.size(rt);
+  headers.reserve(length);
+  for (size_t i = 0; i < length; i++) {
+    auto pair = headersArray.getValueAtIndex(rt, i).asObject(rt).asArray(rt);
+    headers.emplace_back(
+        pair.getValueAtIndex(rt, 0).asString(rt).utf8(rt), pair.getValueAtIndex(rt, 1).asString(rt).utf8(rt));
+  }
+  return headers;
+}
+
+std::optional<std::vector<uint8_t>> parseBody(jsi::Runtime &rt, const jsi::Object &config) {
+  const auto body = config.getProperty(rt, "body");
+  if (body.isString()) {
+    const auto utf8 = body.asString(rt).utf8(rt);
+    return std::vector<uint8_t>(utf8.begin(), utf8.end());
+  }
+  if (body.isObject()) {
+    const auto bodyObject = body.asObject(rt);
+    if (bodyObject.isArrayBuffer(rt)) {
+      auto arrayBuffer = bodyObject.getArrayBuffer(rt);
+      const auto *data = arrayBuffer.data(rt);
+      return std::vector<uint8_t>(data, data + arrayBuffer.size(rt));
+    }
+  }
+  return std::nullopt;
+}
+
+jsi::Value headersToJsi(jsi::Runtime &rt, const std::vector<std::pair<std::string, std::string>> &headers) {
+  auto result = jsi::Array(rt, headers.size());
+  for (size_t i = 0; i < headers.size(); i++) {
+    auto pair = jsi::Array(rt, 2);
+    pair.setValueAtIndex(rt, 0, jsi::String::createFromUtf8(rt, text::toValidUtf8(headers[i].first)));
+    pair.setValueAtIndex(rt, 1, jsi::String::createFromUtf8(rt, text::toValidUtf8(headers[i].second)));
+    result.setValueAtIndex(rt, i, std::move(pair));
+  }
+  return result;
+}
+
+void emitEvent(
+    const std::weak_ptr<WorkletRuntime> &weakRuntime,
+    const std::shared_ptr<SerializableRemoteFunction> &callback,
+    const char *type,
+    std::function<jsi::Value(jsi::Runtime &)> &&payloadFactory) {
+  const auto workletRuntime = weakRuntime.lock();
+  if (!workletRuntime) {
+    return;
+  }
+  workletRuntime->schedule([callback, type, payloadFactory = std::move(payloadFactory)](jsi::Runtime &rt) mutable {
+    callback->toJSValue(rt).asObject(rt).asFunction(rt).call(
+        rt, jsi::String::createFromAscii(rt, type), payloadFactory(rt));
+  });
+}
+
+} // namespace
+
+class Networking::RequestListener final : public NetworkRequestListener {
+ public:
+  RequestListener(
+      const std::weak_ptr<Networking> &weakNetworking,
+      const std::shared_ptr<RequestRecord> &record,
+      const std::shared_ptr<SerializableRemoteFunction> &callback,
+      const uint64_t requestId)
+      : weakNetworking_(weakNetworking), record_(record), callback_(callback), requestId_(requestId) {}
+
+  ~RequestListener() override {
+    if (!callback_) {
+      return;
+    }
+    const auto workletRuntime = record_->weakRuntime.lock();
+    if (!workletRuntime) {
+      return;
+    }
+    workletRuntime->schedule([callback = std::move(callback_)](jsi::Runtime &) {});
+  }
+
+  void onResponse(ResponseInfo &&responseInfo) override {
+    emitEvent(record_->weakRuntime, callback_, "response", [responseInfo = std::move(responseInfo)](jsi::Runtime &rt) {
+      auto payload = jsi::Object(rt);
+      payload.setProperty(rt, "status", jsi::Value(responseInfo.status));
+      payload.setProperty(
+          rt, "statusText", jsi::String::createFromUtf8(rt, text::toValidUtf8(responseInfo.statusText)));
+      payload.setProperty(rt, "headers", headersToJsi(rt, responseInfo.headers));
+      payload.setProperty(rt, "url", jsi::String::createFromUtf8(rt, text::toValidUtf8(responseInfo.url)));
+      return jsi::Value(std::move(payload));
+    });
+  }
+
+  void onUploadProgress(const int64_t sent, const int64_t total) override {
+    emitProgress("uploadProgress", sent, total);
+  }
+
+  void onDownloadProgress(const int64_t received, const int64_t total) override {
+    emitProgress("downloadProgress", received, total);
+  }
+
+  void onComplete(std::vector<uint8_t> &&body) override {
+    if (settle()) {
+      return;
+    }
+    emitEvent(record_->weakRuntime, callback_, "done", [body = std::move(body)](jsi::Runtime &rt) mutable {
+      auto payload = jsi::Object(rt);
+      payload.setProperty(rt, "body", jsi::ArrayBuffer(rt, std::make_shared<VectorBuffer>(std::move(body))));
+      return jsi::Value(std::move(payload));
+    });
+  }
+
+  void onError(const RequestError error, std::string &&message) override {
+    if (settle()) {
+      return;
+    }
+    emitEvent(record_->weakRuntime, callback_, "done", [error, message = std::move(message)](jsi::Runtime &rt) {
+      auto payload = jsi::Object(rt);
+      payload.setProperty(rt, "error", jsi::String::createFromAscii(rt, errorName(error)));
+      payload.setProperty(rt, "message", jsi::String::createFromUtf8(rt, text::toValidUtf8(message)));
+      return jsi::Value(std::move(payload));
+    });
+  }
+
+ private:
+  void emitProgress(const char *type, const int64_t loaded, const int64_t total) {
+    if (record_->settled.load()) {
+      return;
+    }
+    emitEvent(record_->weakRuntime, callback_, type, [loaded, total](jsi::Runtime &rt) {
+      auto payload = jsi::Object(rt);
+      payload.setProperty(rt, "loaded", jsi::Value(static_cast<double>(loaded)));
+      payload.setProperty(rt, "total", jsi::Value(static_cast<double>(total)));
+      return jsi::Value(std::move(payload));
+    });
+  }
+
+  bool settle() {
+    if (record_->settled.exchange(true)) {
+      return true;
+    }
+    if (const auto networking = weakNetworking_.lock()) {
+      networking->unregisterRequest(requestId_);
+    }
+    return false;
+  }
+
+  const std::weak_ptr<Networking> weakNetworking_;
+  const std::shared_ptr<RequestRecord> record_;
+  std::shared_ptr<SerializableRemoteFunction> callback_;
+  const uint64_t requestId_;
+};
+
+Networking::Networking(const std::shared_ptr<NetworkingBackend> &backend) : backend_(backend) {}
+
+uint64_t Networking::sendRequest(jsi::Runtime &rt, const jsi::Object &config, jsi::Function &&callback) {
+  const auto weakRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt);
+  const auto workletRuntime = weakRuntime.lock();
+  if (!workletRuntime) {
+    throw jsi::JSError(rt, "[Worklets] Cannot send a request from a dying Worklet Runtime.");
+  }
+
+  const auto serializableCallback = std::make_shared<SerializableRemoteFunction>(
+      rt, "workletsNetworkingCallback", std::move(callback), workletRuntime->getRuntimeId());
+
+  RequestConfig requestConfig{
+      .method = config.getProperty(rt, "method").asString(rt).utf8(rt),
+      .url = config.getProperty(rt, "url").asString(rt).utf8(rt),
+      .headers = parseHeaders(rt, config),
+      .body = parseBody(rt, config),
+      .timeoutMs = config.getProperty(rt, "timeoutMs").asNumber(),
+      .withCredentials = config.getProperty(rt, "withCredentials").asBool(),
+  };
+
+  const auto requestId = nextRequestId_.fetch_add(1);
+  const auto record = std::make_shared<RequestRecord>(weakRuntime, workletRuntime->getRuntimeId());
+  {
+    const std::lock_guard<std::mutex> lock(requestsMutex_);
+    requests_.emplace(requestId, record);
+  }
+
+  backend_->sendRequest(
+      requestId,
+      std::move(requestConfig),
+      std::make_shared<RequestListener>(weak_from_this(), record, serializableCallback, requestId));
+
+  return requestId;
+}
+
+void Networking::abortRequest(jsi::Runtime &rt, const uint64_t requestId) {
+  const auto workletRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt).lock();
+  if (!workletRuntime) {
+    return;
+  }
+  {
+    const std::lock_guard<std::mutex> lock(requestsMutex_);
+    const auto record = requests_.find(requestId);
+    if (record == requests_.end() || record->second->runtimeId != workletRuntime->getRuntimeId()) {
+      return;
+    }
+  }
+  backend_->abortRequest(requestId);
+}
+
+void Networking::abortAllForRuntime(const RuntimeData::RuntimeId runtimeId) {
+  std::vector<uint64_t> requestIds;
+  {
+    const std::lock_guard<std::mutex> lock(requestsMutex_);
+    for (const auto &[requestId, record] : requests_) {
+      if (record->runtimeId == runtimeId) {
+        requestIds.push_back(requestId);
+      }
+    }
+  }
+  for (const auto requestId : requestIds) {
+    backend_->abortRequest(requestId);
+  }
+}
+
+void Networking::abortAll() {
+  std::vector<uint64_t> requestIds;
+  {
+    const std::lock_guard<std::mutex> lock(requestsMutex_);
+    requestIds.reserve(requests_.size());
+    for (const auto &[requestId, record] : requests_) {
+      requestIds.push_back(requestId);
+    }
+  }
+  for (const auto requestId : requestIds) {
+    backend_->abortRequest(requestId);
+  }
+}
+
+std::optional<std::string>
+Networking::decodeTextWithPlatform(const uint8_t *data, const size_t size, const std::string &label) {
+  return backend_->decodeText(data, size, label);
+}
+
+void Networking::unregisterRequest(const uint64_t requestId) {
+  const std::lock_guard<std::mutex> lock(requestsMutex_);
+  requests_.erase(requestId);
+}
+
+} // namespace worklets

package/Common/cpp/worklets/Networking/Networking.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Networking/NetworkingBackend.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntime;
+
+class Networking : public std::enable_shared_from_this<Networking> {
+ public:
+  explicit Networking(const std::shared_ptr<NetworkingBackend> &backend);
+
+  uint64_t sendRequest(jsi::Runtime &rt, const jsi::Object &config, jsi::Function &&callback);
+  void abortRequest(jsi::Runtime &rt, uint64_t requestId);
+  void abortAllForRuntime(RuntimeData::RuntimeId runtimeId);
+  void abortAll();
+  std::optional<std::string> decodeTextWithPlatform(const uint8_t *data, size_t size, const std::string &label);
+
+ private:
+  struct RequestRecord {
+    RequestRecord(std::weak_ptr<WorkletRuntime> weakRuntime, RuntimeData::RuntimeId runtimeId)
+        : weakRuntime(std::move(weakRuntime)), runtimeId(runtimeId) {}
+
+    const std::weak_ptr<WorkletRuntime> weakRuntime;
+    const RuntimeData::RuntimeId runtimeId;
+    std::atomic<bool> settled{false};
+  };
+
+  class RequestListener;
+
+  void unregisterRequest(uint64_t requestId);
+
+  const std::shared_ptr<NetworkingBackend> backend_;
+  std::atomic<uint64_t> nextRequestId_{1};
+  std::mutex requestsMutex_;
+  std::unordered_map<uint64_t, std::shared_ptr<RequestRecord>> requests_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Networking/NetworkingBackend.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <worklets/Networking/NetworkingTypes.h>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace worklets {
+
+/**
+ * Implemented by the networking core. Backends may invoke the methods from any
+ * thread. Exactly one of `onComplete` or `onError` must be invoked per request,
+ * as the last call for that request.
+ */
+class NetworkRequestListener {
+ public:
+  virtual void onResponse(ResponseInfo &&responseInfo) = 0;
+  virtual void onUploadProgress(int64_t sent, int64_t total) = 0;
+  virtual void onDownloadProgress(int64_t received, int64_t total) = 0;
+  virtual void onComplete(std::vector<uint8_t> &&body) = 0;
+  virtual void onError(RequestError error, std::string &&message) = 0;
+  virtual ~NetworkRequestListener() = default;
+};
+
+class NetworkingBackend {
+ public:
+  virtual void
+  sendRequest(uint64_t requestId, RequestConfig &&config, const std::shared_ptr<NetworkRequestListener> &listener) = 0;
+  virtual void abortRequest(uint64_t requestId) = 0;
+
+  /**
+   * Decodes bytes with a legacy encoding the shared C++ decoders don't cover,
+   * using the platform's own tables. Returns `std::nullopt` when the label is
+   * unknown to the platform. The result must be valid UTF-8.
+   */
+  virtual std::optional<std::string>
+  decodeText(const uint8_t * /*data*/, size_t /*size*/, const std::string & /*label*/) {
+    return std::nullopt;
+  }
+
+  virtual ~NetworkingBackend() = default;
+};
+
+} // namespace worklets