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

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

@@ -1,6 +1,7 @@
 #include <jsi/decorator.h>
 #include <jsi/jsi.h>
 #include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/Networking/NetworkingInstaller.h>
 #include <worklets/Tools/JSLogger.h>
 #include <worklets/WorkletRuntime/RuntimeHolder.h>
 #include <worklets/WorkletRuntime/ScriptLoader.h>
@@ -34,6 +35,7 @@ class AroundLock {
 
 class LockableRuntime : public jsi::WithRuntimeDecorator<AroundLock> {
   AroundLock aroundLock_;
+  const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
   std::shared_ptr<jsi::Runtime> runtime_;
 
  public:
@@ -42,7 +44,13 @@ class LockableRuntime : public jsi::WithRuntimeDecorator<AroundLock> {
       const std::shared_ptr<std::recursive_mutex> &runtimeMutex)
       : jsi::WithRuntimeDecorator<AroundLock>(*runtime, aroundLock_),
         aroundLock_(runtimeMutex),
+        runtimeMutex_(runtimeMutex),
         runtime_(std::move(runtime)) {}
+
+  ~LockableRuntime() override {
+    const std::lock_guard<std::recursive_mutex> lock(*runtimeMutex_);
+    runtime_.reset();
+  }
 };
 
 static std::shared_ptr<jsi::Runtime>
@@ -62,9 +70,11 @@ WorkletRuntime::WorkletRuntime(
     const std::string &name,
     const std::shared_ptr<AsyncQueue> &queue,
     bool enableEventLoop,
-    bool enableLocking)
+    bool enableLocking,
+    bool enableNetworking)
     : runtimeId_(runtimeId),
       enableLocking_(enableLocking),
+      enableNetworking_(enableNetworking),
       runtimeMutex_(std::make_shared<std::recursive_mutex>()),
       microtaskQueueEnabled_(enableEventLoop || runtimeKind == RuntimeData::RuntimeKind::UI),
       runtime_(makeRuntime(runtimeMutex_, enableLocking_, microtaskQueueEnabled_)),
@@ -78,11 +88,23 @@ WorkletRuntime::WorkletRuntime(
   jsi::Runtime &rt = *runtime_;
   WorkletRuntimeCollector::install(rt);
   if (enableEventLoop) {
-    eventLoop_ = std::make_shared<EventLoop>(name_, runtime_, queue_, runtimeMutex_);
+    eventLoop_ = std::make_shared<EventLoop>(name_, abortToken(), runtime_, queue_, runtimeMutex_);
     eventLoop_->run();
   }
 }
 
+WorkletRuntime::~WorkletRuntime() {
+  auto lock = acquireRuntimeLock();
+  if (eventLoop_) {
+    eventLoop_->abortPending();
+    eventLoop_.reset();
+  }
+  if (queue_) {
+    queue_->abortPending(abortToken());
+    queue_.reset();
+  }
+}
+
 void WorkletRuntime::init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWorkletsModuleProxy) {
   jsi::Runtime &rt = *runtime_;
 
@@ -99,7 +121,8 @@ void WorkletRuntime::init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWork
   const auto runtimeBindings = jsiWorkletsModuleProxy->getRuntimeBindings();
   const auto bundleModeEnabled = jsiWorkletsModuleProxy->isBundleModeEnabled();
   const auto unpackerLoader = jsiWorkletsModuleProxy->getUnpackerLoader();
-  const auto &nativeLoggingHook = runtimeBindings->nativeLoggingHook;
+  const auto nativeLoggingHook =
+      bundleModeEnabled ? runtimeBindings->nativeLoggingHook : RuntimeBindings::NativeLoggingHook{};
 
   WorkletRuntimeDecorator::decorate(
       rt,
@@ -107,12 +130,13 @@ void WorkletRuntime::init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWork
       name_,
       jsScheduler,
       isDevBundle,
+      microtaskQueueEnabled_,
       jsiWorkletsModuleProxy->toOptimizedObject(rt),
       eventLoop_,
       nativeLoggingHook);
 
   if (bundleModeEnabled) {
-    bundleModeInit(jsScheduler, script, sourceUrl, runtimeBindings);
+    bundleModeInit(jsScheduler, script, sourceUrl, jsiWorkletsModuleProxy->getNetworking());
   } else {
     legacyModeInit(unpackerLoader);
   }
@@ -128,16 +152,18 @@ void WorkletRuntime::bundleModeInit(
     const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::shared_ptr<const ScriptBuffer> &script,
     const std::string &sourceUrl,
-    const std::shared_ptr<RuntimeBindings> &runtimeBindings) {
+    const std::shared_ptr<Networking> &networking) {
   jsi::Runtime &rt = *runtime_;
 
   if (!script) {
     throw std::runtime_error("[Worklets] Expected to receive the bundle, but got nullptr instead.");
   }
 
-  ScriptLoader::loadScript(rt, script, sourceUrl);
+  if (networking && enableNetworking_) {
+    NetworkingInstaller::install(rt, networking, runtimeId_);
+  }
 
-  WorkletRuntimeDecorator::postEvaluateScript(rt, runtimeBindings);
+  ScriptLoader::loadScript(rt, script, sourceUrl);
 }
 
 void WorkletRuntime::legacyModeInit(const std::shared_ptr<UnpackerLoader> &unpackerLoader) {
@@ -158,15 +184,25 @@ void WorkletRuntime::schedule(std::shared_ptr<SerializableWorklet> worklet) cons
   });
 }
 
-void WorkletRuntime::schedule(std::vector<std::shared_ptr<SerializableWorklet>> worklets) const {
-  scheduleImpl([worklets = std::move(worklets)](const WorkletRuntime &workletRuntime) {
-    workletRuntime.runSyncImpl<MicrotaskCheckpoint::Run>([&](jsi::Runtime &rt) {
-      const auto scope = jsi::Scope(rt);
-      for (const auto &worklet : worklets) {
-        workletRuntime.runSyncImpl(worklet);
-      }
-    });
-  });
+void WorkletRuntime::schedule(
+    std::shared_ptr<SerializableArray> serializableArrayOfWorklets,
+    std::shared_ptr<SerializableArray> serializableArrayOfArguments) const {
+  scheduleImpl(
+      [serializableArrayOfWorklets = std::move(serializableArrayOfWorklets),
+       serializableArrayOfArguments = std::move(serializableArrayOfArguments)](const WorkletRuntime &workletRuntime) {
+        workletRuntime.runSyncImpl<MicrotaskCheckpoint::Run>([&](jsi::Runtime &rt) {
+          const auto scope = jsi::Scope(rt);
+          const auto &worklets = serializableArrayOfWorklets->getList();
+          const auto &argumentArrays = serializableArrayOfArguments->getList();
+          react_native_assert(worklets.size() == argumentArrays.size());
+          for (size_t i = 0; i < worklets.size(); i++) {
+            const auto worklet = std::static_pointer_cast<SerializableWorklet>(worklets[i]);
+            const auto argumentArray = std::static_pointer_cast<SerializableArray>(argumentArrays[i]);
+            const auto args = argumentArray->getJSIValueArr(rt);
+            workletRuntime.runSyncImpl(worklet, args.data(), args.size());
+          }
+        });
+      });
 }
 
 #ifndef NDEBUG
@@ -180,16 +216,28 @@ void WorkletRuntime::scheduleWithStack(
 }
 
 void WorkletRuntime::scheduleWithStack(
-    std::vector<std::shared_ptr<SerializableWorklet>> worklets,
+    std::shared_ptr<SerializableArray> serializableArrayOfWorklets,
+    std::shared_ptr<SerializableArray> serializableArrayOfArguments,
     std::vector<std::optional<std::string>> scheduleStacks) const {
-  react_native_assert(worklets.size() == scheduleStacks.size());
-  scheduleImpl([worklets = std::move(worklets),
+  const auto batchSize = serializableArrayOfWorklets->getList().size();
+  if (scheduleStacks.empty()) {
+    scheduleStacks.resize(batchSize);
+  }
+  react_native_assert(batchSize == scheduleStacks.size());
+  scheduleImpl([serializableArrayOfWorklets = std::move(serializableArrayOfWorklets),
+                serializableArrayOfArguments = std::move(serializableArrayOfArguments),
                 scheduleStacks = std::move(scheduleStacks)](const WorkletRuntime &workletRuntime) {
     workletRuntime.runSyncImpl<MicrotaskCheckpoint::Run>([&](jsi::Runtime &rt) {
       const auto scope = jsi::Scope(rt);
+      const auto &worklets = serializableArrayOfWorklets->getList();
+      const auto &argumentArrays = serializableArrayOfArguments->getList();
+      react_native_assert(worklets.size() == argumentArrays.size());
       for (size_t i = 0; i < worklets.size(); i++) {
+        const auto worklet = std::static_pointer_cast<SerializableWorklet>(worklets[i]);
+        const auto argumentArray = std::static_pointer_cast<SerializableArray>(argumentArrays[i]);
+        const auto args = argumentArray->getJSIValueArr(rt);
         workletRuntime.runSyncImpl<MicrotaskCheckpoint::Skip, jsi::Value, ScheduleStack::Requested>(
-            worklets[i], scheduleStacks[i]);
+            worklet, scheduleStacks[i], args.data(), args.size());
       }
     });
   });
@@ -208,15 +256,17 @@ void WorkletRuntime::scheduleImpl(ScheduledJob job) const {
       "[Worklets] Tried to invoke `schedule` on a Worklet Runtime but the "
       "async queue is not set. Recreate the runtime with a valid async queue.");
 
-  queue_->push([job = std::move(job), weakThis = weak_from_this()] {
-    const auto strongThis = weakThis.lock();
-    if (!strongThis) {
-      return;
-    }
-
-    auto lock = strongThis->acquireRuntimeLock();
-    job(*strongThis);
-  });
+  queue_->push(
+      [job = std::move(job), weakThis = weak_from_this()] {
+        const auto strongThis = weakThis.lock();
+        if (!strongThis) {
+          return;
+        }
+
+        auto lock = strongThis->acquireRuntimeLock();
+        job(*strongThis);
+      },
+      abortToken());
 }
 
 /* #endregion */

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

@@ -5,12 +5,13 @@
 #include <worklets/RunLoop/AsyncQueue.h>
 #include <worklets/RunLoop/AsyncQueueImpl.h>
 #include <worklets/RunLoop/EventLoop.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+#include <worklets/SharedItems/Serializable/SerializableArray.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>
 #include <worklets/SharedItems/UnpackerLoader.h>
 #include <worklets/Tools/JSLogger.h>
 #include <worklets/Tools/JSScheduler.h>
 #include <worklets/Tools/ScriptBuffer.h>
-#include <worklets/Tools/WorkletsJSIUtils.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/RuntimeData.h>
 
@@ -28,6 +29,8 @@ namespace worklets {
 using namespace facebook;
 using namespace react;
 
+class Networking;
+
 template <typename TCallable>
 concept RuntimeCallable = std::is_same_v<std::remove_cvref_t<TCallable>, jsi::Function> ||
     std::is_same_v<std::remove_cvref_t<TCallable>, std::shared_ptr<SerializableWorklet>>;
@@ -76,7 +79,9 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
    *
    * Runs a single microtask checkpoint on completion of the batch.
    */
-  void schedule(std::vector<std::shared_ptr<SerializableWorklet>> worklets) const;
+  void schedule(
+      std::shared_ptr<SerializableArray> serializableArrayOfWorklets,
+      std::shared_ptr<SerializableArray> serializableArrayOfArguments) const;
 #ifndef NDEBUG
   /**
    * Schedules a serialized worklet to run asynchronously on the worklet runtime,
@@ -94,7 +99,8 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
    * Runs a single microtask checkpoint on completion of the batch.
    */
   void scheduleWithStack(
-      std::vector<std::shared_ptr<SerializableWorklet>> worklets,
+      std::shared_ptr<SerializableArray> serializableArrayOfWorklets,
+      std::shared_ptr<SerializableArray> serializableArrayOfArguments,
       std::vector<std::optional<std::string>> scheduleStacks) const;
 #endif // NDEBUG
 
@@ -120,11 +126,17 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
    * Does not run a microtask checkpoint.
    */
   template <RuntimeCallable TCallable, typename... TArgs>
-  auto runSync(const TCallable &callable, TArgs &&...args) const -> jsi::Value {
+  [[nodiscard]] auto runSync(const TCallable &callable, TArgs &&...args) const -> jsi::Value {
     auto lock = acquireRuntimeLock();
     return runSyncImpl(callable, std::forward<TArgs>(args)...);
   }
 
+  template <RuntimeCallable TCallable, typename... TArgs>
+  void runSyncAndDiscard(const TCallable &callable, TArgs &&...args) const {
+    auto lock = acquireRuntimeLock();
+    static_cast<void>(runSyncImpl(callable, std::forward<TArgs>(args)...));
+  }
+
   /**
    * Runs a jsi::Function or SerializableWorklet synchronously and returns its
    * serialized result.
@@ -162,7 +174,7 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
    * Runs a single microtask checkpoint on completion.
    */
   template <RuntimeCallable TCallable, typename... TArgs>
-  auto runSyncAndDrainMicrotasks(const TCallable &callable, TArgs &&...args) const -> jsi::Value {
+  [[nodiscard]] auto runSyncAndDrainMicrotasks(const TCallable &callable, TArgs &&...args) const -> jsi::Value {
     auto lock = acquireRuntimeLock();
     return runSyncImpl<MicrotaskCheckpoint::Run>(callable, std::forward<TArgs>(args)...);
   }
@@ -246,7 +258,10 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
       const std::string &name,
       const std::shared_ptr<AsyncQueue> &queue = nullptr,
       bool enableEventLoop = true,
-      bool enableLocking = true);
+      bool enableLocking = true,
+      bool enableNetworking = true);
+
+  ~WorkletRuntime() override;
 
   void init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWorkletsModuleProxy);
 
@@ -265,7 +280,9 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
    */
   void drainMicrotasks() const {
     auto lock = acquireRuntimeLock();
-    drainMicrotasksImpl();
+    if (microtaskQueueEnabled_) {
+      getJSIRuntime().drainMicrotasks();
+    }
   }
 
  private:
@@ -375,7 +392,9 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
     using Result = std::invoke_result_t<TInvoker>;
     const auto checkpoint = [&]() {
       if constexpr (TCheckpoint == MicrotaskCheckpoint::Run) {
-        drainMicrotasksImpl();
+        if (microtaskQueueEnabled_) {
+          getJSIRuntime().drainMicrotasks();
+        }
       }
     };
     if constexpr (std::is_void_v<Result>) {
@@ -388,15 +407,6 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
     }
   }
 
-  /**
-   * Assumes the caller acquired the runtime lock.
-   */
-  void drainMicrotasksImpl() const {
-    if (microtaskQueueEnabled_) {
-      jsi_utils::drainMicrotasks(getJSIRuntime());
-    }
-  }
-
   /**
    * Invokes the provided function, reporting any exception with the scheduling
    * stack carried by the provided stack context in debug builds.
@@ -427,10 +437,14 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
       const std::shared_ptr<JSScheduler> &jsScheduler,
       const std::shared_ptr<const ScriptBuffer> &script,
       const std::string &sourceUrl,
-      const std::shared_ptr<RuntimeBindings> &runtimeBindings);
+      const std::shared_ptr<Networking> &networking);
 
   void legacyModeInit(const std::shared_ptr<UnpackerLoader> &unpackerLoader);
 
+  [[nodiscard]] AbortToken abortToken() const noexcept {
+    return static_cast<AbortToken>(runtimeId_);
+  }
+
   [[nodiscard]] std::unique_lock<std::recursive_mutex> acquireRuntimeLock() const {
     if (enableLocking_) {
       return std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
@@ -440,6 +454,7 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
 
   const RuntimeData::RuntimeId runtimeId_;
   const bool enableLocking_;
+  const bool enableNetworking_;
   const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
   const bool microtaskQueueEnabled_;
   const std::shared_ptr<jsi::Runtime> runtime_;

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

@@ -1,6 +1,12 @@
 #include <jsi/jsi.h>
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/SharedItems/SerializableFactory.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+#include <worklets/SharedItems/Serializable/SerializableArray.h>
+#include <worklets/SharedItems/Serializable/SerializableBigInt.h>
+#include <worklets/SharedItems/Serializable/SerializableHostObject.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+#include <worklets/SharedItems/Serializable/SerializableScalar.h>
+#include <worklets/SharedItems/Serializable/SerializableString.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>
 #include <worklets/Tools/JSISerializer.h>
 #include <worklets/Tools/PlatformLogger.h>
 #include <worklets/Tools/WorkletsJSIUtils.h>
@@ -56,6 +62,7 @@ void WorkletRuntimeDecorator::decorate(
     const std::string &name,
     const std::shared_ptr<JSScheduler> &jsScheduler,
     const bool isDevBundle,
+    const bool enableMicrotaskQueue,
     jsi::Object &&jsiWorkletsModuleProxy,
     const std::shared_ptr<EventLoop> &eventLoop,
     const RuntimeBindings::NativeLoggingHook &nativeLoggingHook) {
@@ -175,10 +182,6 @@ void WorkletRuntimeDecorator::decorate(
     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));
   });
@@ -220,6 +223,10 @@ void WorkletRuntimeDecorator::decorate(
     return jsi::String::createFromUtf8(rt, path);
   });
 
+  if (enableMicrotaskQueue) {
+    jsi_utils::installJsiFunction(rt, "__drainMicrotasks", [](jsi::Runtime &rt) { rt.drainMicrotasks(); });
+  }
+
   jsi_utils::installJsiFunction(
       rt,
       "_scheduleTimeoutCallback",
@@ -237,84 +244,4 @@ void WorkletRuntimeDecorator::decorate(
       });
 }
 
-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

@@ -21,16 +21,10 @@ class WorkletRuntimeDecorator {
       const std::string &name,
       const std::shared_ptr<JSScheduler> &jsScheduler,
       const bool isDevBundle,
+      const bool enableMicrotaskQueue,
       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/Package.swift

@@ -0,0 +1,147 @@
+// swift-tools-version: 6.0
+
+import Foundation
+import PackageDescription
+
+let packageDirectory = Context.packageDirectory
+
+func readPackageVersion() -> String {
+    let url = URL(fileURLWithPath: packageDirectory).appendingPathComponent("package.json")
+    let data = try! Data(contentsOf: url)
+    let json = try! JSONSerialization.jsonObject(with: data) as! [String: Any]
+    return json["version"] as! String
+}
+
+func readJSONObject(at url: URL) -> [String: Any]? {
+    guard let data = try? Data(contentsOf: url) else {
+        return nil
+    }
+    let object = try? JSONSerialization.jsonObject(with: data)
+    return object as? [String: Any]
+}
+
+// NSNumber needs the CFBoolean check to tell booleans apart from integers.
+func stringifyFlagValue(_ value: Any) -> String? {
+    if let number = value as? NSNumber {
+        if CFGetTypeID(number) == CFBooleanGetTypeID() {
+            return number.boolValue ? "true" : "false"
+        }
+        return number.stringValue
+    }
+    if let string = value as? String {
+        return string
+    }
+    return nil
+}
+
+func isConsumerPackageJSON(at url: URL) -> Bool {
+    guard let json = readJSONObject(at: url),
+        let name = json["name"] as? String,
+        name != "react-native-worklets",
+        let section = json["worklets"] as? [String: Any],
+        section["staticFeatureFlags"] != nil
+    else {
+        return false
+    }
+    return true
+}
+
+// SPM autolinking uses ios/build/generated/autolinking/libs/<SwiftName>/ (symlink).
+func findConsumerPackageJSON() -> URL? {
+    var dir = URL(fileURLWithPath: packageDirectory).standardizedFileURL
+    while dir.path != "/" {
+        let candidate = dir.appendingPathComponent("package.json")
+        if isConsumerPackageJSON(at: candidate) {
+            return candidate
+        }
+        dir = dir.deletingLastPathComponent()
+    }
+    return nil
+}
+
+func readStaticFeatureFlags() -> [String: String] {
+    var flags: [String: String] = [:]
+
+    let defaultsURL = URL(fileURLWithPath: packageDirectory)
+        .appendingPathComponent("src/featureFlags/staticFlags.json")
+    if let defaults = readJSONObject(at: defaultsURL) {
+        for (key, value) in defaults {
+            if let stringValue = stringifyFlagValue(value) {
+                flags[key] = stringValue
+            }
+        }
+    }
+
+    if let consumerURL = findConsumerPackageJSON(),
+        let consumer = readJSONObject(at: consumerURL),
+        let section = consumer["worklets"] as? [String: Any],
+        let overrides = section["staticFeatureFlags"] as? [String: Any]
+    {
+        for (key, value) in overrides {
+            if let stringValue = stringifyFlagValue(value) {
+                flags[key] = stringValue
+            }
+        }
+    }
+
+    return flags
+}
+
+func formatFeatureFlags(_ flags: [String: String]) -> String {
+    return flags.keys.sorted().map { "[\($0):\(flags[$0]!)]" }.joined()
+}
+
+let version = readPackageVersion()
+let featureFlags = formatFeatureFlags(readStaticFeatureFlags())
+
+let reactHeaders: [Target.Dependency] = [
+    .product(name: "ReactHeaders", package: "ReactNative"),
+    .product(name: "ReactNativeHeaders", package: "ReactNative"),
+    .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+    .product(name: "ReactAppHeaders", package: "React-GeneratedCode"),
+]
+
+let package = Package(
+    name: "RNWorklets",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(name: "RNWorklets", targets: ["RNWorklets"]),
+    ],
+    dependencies: [
+        .package(name: "ReactNative", path: "../../../../xcframeworks"),
+        .package(name: "React-GeneratedCode", path: "../../../ios"),
+    ],
+    targets: [
+        .target(
+            name: "RNWorklets",
+            dependencies: reactHeaders,
+            path: ".",
+            sources: ["Common/cpp/worklets", "apple/worklets"],
+            publicHeadersPath: "Common/cpp",
+            cSettings: [
+                .headerSearchPath("."),
+                .headerSearchPath("Common/cpp"),
+                .headerSearchPath("apple"),
+                .define("WORKLETS_VERSION", to: version),
+                .define("WORKLETS_FEATURE_FLAGS", to: featureFlags),
+                .define("HERMES_ENABLE_DEBUGGER", to: "1", .when(configuration: .debug)),
+            ],
+            cxxSettings: [
+                .headerSearchPath("."),
+                .headerSearchPath("Common/cpp"),
+                .headerSearchPath("apple"),
+                .define("WORKLETS_VERSION", to: version),
+                .define("WORKLETS_FEATURE_FLAGS", to: featureFlags),
+                .define("HERMES_ENABLE_DEBUGGER", to: "1", .when(configuration: .debug)),
+                .define("DEBUG", .when(configuration: .debug)),
+                .define("NDEBUG", .when(configuration: .release)),
+            ],
+            linkerSettings: [
+                .linkedFramework("UIKit"),
+                .linkedFramework("Foundation"),
+                .linkedFramework("QuartzCore"),
+            ]
+        ),
+    ],
+    cxxLanguageStandard: .cxx20
+)

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/react-native-worklets
 
 | Field | Value |
 |-------|-------|
-| Original | [react-native-worklets](https://www.npmjs.com/package/react-native-worklets) @ 0.12.2 |
-| Processed | 2026-09-13 |
+| Original | [react-native-worklets](https://www.npmjs.com/package/react-native-worklets) @ 0.13.0 |
+| Processed | 2026-09-27 |
 | Smoke test | failed |
 | Deps updated | 13 |
 
@@ -22,7 +22,7 @@ npm install @depup/react-native-worklets
 
 | Dependency | From | To |
 |------------|------|-----|
-| @babel/generator | ^7.27.1 | ^8.0.5 |
+| @babel/generator | ^7.27.1 | ^8.0.6 |
 | @babel/plugin-transform-arrow-functions | ^7.27.1 | ^8.0.1 |
 | @babel/plugin-transform-class-properties | ^7.28.6 | ^8.0.1 |
 | @babel/plugin-transform-classes | ^7.28.6 | ^8.0.5 |
@@ -32,8 +32,8 @@ npm install @depup/react-native-worklets
 | @babel/plugin-transform-template-literals | ^7.27.1 | ^8.0.1 |
 | @babel/plugin-transform-unicode-regex | ^7.27.1 | ^8.0.1 |
 | @babel/preset-typescript | ^7.28.5 | ^8.0.1 |
-| @babel/traverse | ^7.27.1 | ^8.0.5 |
-| @babel/types | ^7.27.1 | ^8.0.5 |
+| @babel/traverse | ^7.27.1 | ^8.0.6 |
+| @babel/types | ^7.27.1 | ^8.0.6 |
 | semver | ^7.7.4 | ^7.8.5 |
 
 ---