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

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

@@ -10,10 +10,13 @@
 #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>
 
+#include <cstdint>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
 #include <type_traits>
@@ -26,13 +29,16 @@ 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>;
+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>>;
 
-template <typename TCallable>
-concept RuntimeCallable = requires(TCallable &&callable, jsi::Runtime &rt) {
-  { callable(rt) };
-} || ImplicitlySerializableCallable<TCallable>;
+template <typename TJob>
+concept RuntimeJob = !RuntimeCallable<TJob> && requires(TJob &&job, jsi::Runtime &rt) {
+  { job(rt) };
+};
+
+template <typename TResult>
+concept SyncCallResult = std::is_same_v<TResult, jsi::Value> || std::is_same_v<TResult, std::shared_ptr<Serializable>>;
 
 /**
  * Forward declaration to avoid circular dependencies.
@@ -41,105 +47,174 @@ 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;
+  /**
+   * Schedules a std::function to run asynchronously.
+   *
+   * Runs a single microtask checkpoint on completion.
+   */
   void schedule(std::function<void(jsi::Runtime &)> job) const;
 
-  /* #region runSync */
+  /**
+   * Schedules a jsi::Function to run asynchronously.
+   *
+   * The jsi::Function has to originate from this runtime, otherwise it will
+   crash.
+   *
+   * Runs a single microtask checkpoint on completion.
+   */
+  void schedule(jsi::Function &&function) const;
 
-  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 {
+  /**
+   * Schedules a serialized worklet to run asynchronously.
+   *
+   * Runs a single microtask checkpoint on completion.
+   */
+  void schedule(std::shared_ptr<SerializableWorklet> worklet) const;
+
+  /**
+   * Schedules a batch of serialized worklets to run asynchronously.
+   *
+   * Runs a single microtask checkpoint on completion of the batch.
+   */
+  void schedule(std::vector<std::shared_ptr<SerializableWorklet>> worklets) 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...);
+  /**
+   * Schedules a serialized worklet to run asynchronously on the worklet runtime,
+   * remembering the call site that scheduled it for error reporting.
+   *
+   * Runs a single microtask checkpoint on completion.
+   */
+  void scheduleWithStack(std::shared_ptr<SerializableWorklet> worklet, std::optional<std::string> scheduleStack) const;
+
+  /**
+   * Schedules a batch of serialized worklets to run asynchronously on the
+   * worklet runtime, remembering their scheduling call sites for error
+   * reporting.
+   *
+   * Runs a single microtask checkpoint on completion of the batch.
+   */
+  void scheduleWithStack(
+      std::vector<std::shared_ptr<SerializableWorklet>> worklets,
+      std::vector<std::optional<std::string>> scheduleStacks) const;
 #endif // NDEBUG
+
+  /**
+   * Runs a RuntimeJob synchronously and returns its result.
+   *
+   * Does not run a microtask checkpoint.
+   */
+  template <RuntimeJob TJob>
+  auto runSync(TJob &&job) const -> std::invoke_result_t<TJob, jsi::Runtime &> {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl(std::forward<TJob>(job));
   }
-#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);
+
+  /**
+   * Runs a jsi::Function or SerializableWorklet synchronously and returns a
+   * jsi::Value result.
+   *
+   * The returned jsi::Value originates from this runtime and cannot be used on
+   * another runtime unless it is a primitive value. Use runSyncSerialized to
+   * transfer the result to another runtime.
+   *
+   * Does not run a microtask checkpoint.
+   */
+  template <RuntimeCallable TCallable, typename... TArgs>
+  auto runSync(const TCallable &callable, TArgs &&...args) const -> jsi::Value {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl(callable, std::forward<TArgs>(args)...);
   }
 
-  /* #endregion */
+  /**
+   * Runs a jsi::Function or SerializableWorklet synchronously and returns its
+   * serialized result.
+   *
+   * Does not run a microtask checkpoint.
+   */
+  template <RuntimeCallable TCallable, typename... TArgs>
+  auto runSyncSerialized(const TCallable &callable, TArgs &&...args) const -> std::shared_ptr<Serializable> {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl<MicrotaskCheckpoint::Skip, std::shared_ptr<Serializable>>(
+        callable, std::forward<TArgs>(args)...);
+  }
 
-  void callMicrotasks() const;
+  /**
+   * Runs a jsi::Function or SerializableWorklet synchronously and returns its
+   * serialized result.
+   *
+   * Runs a single microtask checkpoint on completion.
+   */
+  template <RuntimeJob TJob>
+  auto runSyncAndDrainMicrotasks(TJob &&job) const -> std::invoke_result_t<TJob, jsi::Runtime &> {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl<MicrotaskCheckpoint::Run>(std::forward<TJob>(job));
+  }
 
-  /* #region runSyncSerialized */
+  /**
+   * Runs a jsi::Function or SerializableWorklet synchronously and returns a
+   * jsi::Value result.
+   *
+   * The returned jsi::Value originates from this runtime and cannot be used on
+   * another runtime unless it is a primitive value. Use
+   * runSyncAndDrainMicrotasksSerialized to transfer the result to another
+   * runtime.
+   *
+   * Runs a single microtask checkpoint on completion.
+   */
+  template <RuntimeCallable TCallable, typename... TArgs>
+  auto runSyncAndDrainMicrotasks(const TCallable &callable, TArgs &&...args) const -> jsi::Value {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl<MicrotaskCheckpoint::Run>(callable, std::forward<TArgs>(args)...);
+  }
 
-  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;
+  /**
+   * Runs a jsi::Function or SerializableWorklet synchronously and returns its
+   * serialized result.
+   *
+   * Runs a single microtask checkpoint on completion.
+   */
+  template <RuntimeCallable TCallable, typename... TArgs>
+  auto runSyncAndDrainMicrotasksSerialized(const TCallable &callable, TArgs &&...args) const
+      -> std::shared_ptr<Serializable> {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl<MicrotaskCheckpoint::Run, std::shared_ptr<Serializable>>(callable, std::forward<TArgs>(args)...);
   }
+
 #ifndef NDEBUG
-  template <typename... Args>
-  std::shared_ptr<Serializable> runSyncSerializedWithStack(
-      const std::shared_ptr<SerializableWorklet> &worklet,
+  /**
+   * Synchronously invokes a jsi::Function or SerializableWorklet on the worklet
+   * runtime and returns TResult, remembering the call site that scheduled it
+   * for error reporting.
+   *
+   * TResult must be either jsi::Value or std::shared_ptr<Serializable>.
+   *
+   * Does not run a microtask checkpoint.
+   */
+  template <SyncCallResult TResult, RuntimeCallable TCallable, typename... TArgs>
+  auto runSyncWithStack(const TCallable &callable, const std::optional<std::string> &scheduleStack, TArgs &&...args)
+      const -> TResult {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl<MicrotaskCheckpoint::Skip, TResult, ScheduleStack::Requested>(
+        callable, scheduleStack, std::forward<TArgs>(args)...);
+  }
+
+  /**
+   * Synchronously invokes a jsi::Function or SerializableWorklet on the worklet
+   * runtime, runs any microtasks it queued, and returns TResult, remembering the
+   * call site that scheduled it for error reporting.
+   *
+   * TResult must be either jsi::Value or std::shared_ptr<Serializable>.
+   */
+  template <SyncCallResult TResult, RuntimeCallable TCallable, typename... TArgs>
+  auto runSyncWithStackAndDrainMicrotasks(
+      const TCallable &callable,
       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;
+      TArgs &&...args) const -> TResult {
+    auto lock = acquireRuntimeLock();
+    return runSyncImpl<MicrotaskCheckpoint::Run, TResult, ScheduleStack::Requested>(
+        callable, scheduleStack, std::forward<TArgs>(args)...);
   }
 #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;
 
@@ -161,63 +236,192 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
     return name_;
   }
 
+  [[nodiscard]] bool isLockingEnabled() const noexcept {
+    return enableLocking_;
+  }
+
   explicit WorkletRuntime(
       RuntimeData::RuntimeId runtimeId,
       RuntimeData::RuntimeKind runtimeKind,
       const std::string &name,
       const std::shared_ptr<AsyncQueue> &queue = nullptr,
-      bool enableEventLoop = true);
+      bool enableEventLoop = true,
+      bool enableLocking = true);
 
   void init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWorkletsModuleProxy);
 
-  /* #region deprecated */
+  /**
+   * Retrieves a weak reference to the WorkletRuntime associated with the
+   * provided jsi::Runtime.
+   *
+   * Throws when invoked with a non-worklet runtime.
+   */
+  static std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(jsi::Runtime &rt);
 
-  /** @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)...);
+  /**
+   * Runs the worklet runtime's pending microtasks.
+   *
+   * The runtime lock is held until the microtask checkpoint completes.
+   */
+  void drainMicrotasks() const {
+    auto lock = acquireRuntimeLock();
+    drainMicrotasksImpl();
   }
 
-  /** @deprecated Use `schedule` instead. */
-  void runAsyncGuarded(const std::shared_ptr<SerializableWorklet> &worklet);
+ private:
+  enum class MicrotaskCheckpoint : std::uint8_t {
+    Skip,
+    Run,
+  };
 
-  /** @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;
+  enum class ScheduleStack : std::uint8_t {
+    NotRequested,
+#ifndef NDEBUG
+    Requested,
+#endif // NDEBUG
+  };
 
-  /* #endregion */
+  struct NoScheduleStack {};
+
+#ifndef NDEBUG
+  struct RequestedScheduleStack {
+    const std::optional<std::string> &value;
+  };
+#endif // NDEBUG
+
+  using ScheduledJob = std::function<void(const WorkletRuntime &)>;
 
   /**
-   * Retrieves a weak reference to the WorkletRuntime associated with the
-   * provided jsi::Runtime.
-   *
-   * Throws when invoked with a non-worklet runtime.
+   * Queues a job and acquires the runtime lock immediately before invoking it.
    *
-   * Available only on React Native 0.81 and higher.
+   * Scheduled jobs must use the unlocked implementation methods.
    */
-  static std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(jsi::Runtime &rt);
+  void scheduleImpl(ScheduledJob job) const;
 
- private:
+  /**
+   * Assumes the caller acquired the runtime lock.
+   */
+  template <
+      MicrotaskCheckpoint TCheckpoint = MicrotaskCheckpoint::Skip,
+      SyncCallResult TResult = jsi::Value,
+      ScheduleStack TScheduleStack = ScheduleStack::NotRequested,
+      typename TCallable,
+      typename... TArgs>
+    requires RuntimeJob<TCallable> || RuntimeCallable<TCallable>
+  auto runSyncImpl(TCallable &&callable, TArgs &&...args) const -> decltype(auto) {
+    jsi::Runtime &rt = getJSIRuntime();
+    if constexpr (std::is_same_v<std::remove_cvref_t<TCallable>, std::shared_ptr<SerializableWorklet>>) {
+      auto function = callable->toJSValue(rt).getObject(rt).getFunction(rt);
+      return runSyncImpl<TCheckpoint, TResult, TScheduleStack>(function, std::forward<TArgs>(args)...);
+    } else {
+      auto stackPolicyInvocation = [&]<typename TScheduleStackContext, typename... TCallArgs>(
+                                       TScheduleStackContext &&scheduleStackContext,
+                                       TCallArgs &&...callArgs) -> decltype(auto) {
+        auto microtaskPolicyInvocation = [&]() -> decltype(auto) {
+          if constexpr (RuntimeJob<TCallable>) {
+            return std::forward<TCallable>(callable)(rt);
+          } else {
+            auto result = this->invoke(
+                rt,
+                callable,
+                std::forward<TScheduleStackContext>(scheduleStackContext),
+                std::forward<TCallArgs>(callArgs)...);
+            if constexpr (std::is_same_v<TResult, std::shared_ptr<Serializable>>) {
+              return extractSerializableOrThrow(rt, result);
+            } else {
+              return result;
+            }
+          }
+        };
+
+        return invokeWithMicrotaskCheckpointPolicyImpl<TCheckpoint>(std::move(microtaskPolicyInvocation));
+      };
+
+      return invokeWithStackPolicyImpl<TScheduleStack, TCallable>(
+          std::move(stackPolicyInvocation), std::forward<TArgs>(args)...);
+    }
+  }
+
+  /**
+   * Assumes the caller acquired the runtime lock.
+   */
+  template <ScheduleStack TScheduleStack, typename TCallable, typename TInvoker, typename... TArgs>
+  static auto invokeWithStackPolicyImpl(TInvoker &&invoke, TArgs &&...args) -> decltype(auto) {
+#ifndef NDEBUG
+    if constexpr (TScheduleStack == ScheduleStack::Requested) {
+      static_assert(RuntimeCallable<TCallable>, "[Worklets] Scheduling stacks can be used only with worklet calls.");
+      static_assert(sizeof...(TArgs) > 0, "[Worklets] A scheduling stack argument is required.");
+      return [&]<typename TScheduleStackArg, typename... TCallArgs>(
+                 TScheduleStackArg &&scheduleStack, TCallArgs &&...callArgs) -> decltype(auto) {
+        static_assert(
+            std::is_same_v<std::remove_cvref_t<TScheduleStackArg>, std::optional<std::string>>,
+            "[Worklets] The first argument must be an optional scheduling stack.");
+        return std::forward<TInvoker>(invoke)(
+            RequestedScheduleStack{std::forward<TScheduleStackArg>(scheduleStack)},
+            std::forward<TCallArgs>(callArgs)...);
+      }(std::forward<TArgs>(args)...);
+    } else
+#endif // NDEBUG
+    {
+      return std::forward<TInvoker>(invoke)(NoScheduleStack{}, std::forward<TArgs>(args)...);
+    }
+  }
+
+  /**
+   * Assumes the caller acquired the runtime lock.
+   */
+  template <MicrotaskCheckpoint TCheckpoint, typename TInvoker>
+  auto invokeWithMicrotaskCheckpointPolicyImpl(TInvoker &&invoke) const -> std::invoke_result_t<TInvoker> {
+    using Result = std::invoke_result_t<TInvoker>;
+    const auto checkpoint = [&]() {
+      if constexpr (TCheckpoint == MicrotaskCheckpoint::Run) {
+        drainMicrotasksImpl();
+      }
+    };
+    if constexpr (std::is_void_v<Result>) {
+      std::forward<TInvoker>(invoke)();
+      checkpoint();
+    } else {
+      Result result = std::forward<TInvoker>(invoke)();
+      checkpoint();
+      return std::forward<Result>(result);
+    }
+  }
+
+  /**
+   * 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.
+   */
+  template <typename TScheduleStackContext, typename... TArgs>
+  jsi::Value invoke(
+      jsi::Runtime &rt,
+      const jsi::Function &function,
+      const TScheduleStackContext &scheduleStackContext,
+      TArgs &&...args) const {
 #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...);
+      return function.call(rt, std::forward<TArgs>(args)...);
     } catch (jsi::JSError &e) {
-      JSLogger::handleJSError(jsScheduler_, rt, name_, e, scheduleStack);
+      if constexpr (std::is_same_v<TScheduleStackContext, RequestedScheduleStack>) {
+        JSLogger::handleJSError(jsScheduler_, rt, name_, e, scheduleStackContext.value);
+      } else {
+        JSLogger::handleJSError(jsScheduler_, rt, name_, e, std::nullopt);
+      }
       return jsi::Value::undefined();
     }
-  }
+#else
+    return function.call(rt, std::forward<TArgs>(args)...);
 #endif // NDEBUG
+  }
 
   void bundleModeInit(
       const std::shared_ptr<JSScheduler> &jsScheduler,
@@ -227,8 +431,17 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
 
   void legacyModeInit(const std::shared_ptr<UnpackerLoader> &unpackerLoader);
 
+  [[nodiscard]] std::unique_lock<std::recursive_mutex> acquireRuntimeLock() const {
+    if (enableLocking_) {
+      return std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+    }
+    return {};
+  }
+
   const RuntimeData::RuntimeId runtimeId_;
+  const bool enableLocking_;
   const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
+  const bool microtaskQueueEnabled_;
   const std::shared_ptr<jsi::Runtime> runtime_;
   std::shared_ptr<JSScheduler> jsScheduler_;
   const RuntimeData::RuntimeKind runtimeKind_;

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.11.4 |
-| Processed | 2026-08-16 |
+| Original | [react-native-worklets](https://www.npmjs.com/package/react-native-worklets) @ 0.12.2 |
+| Processed | 2026-09-13 |
 | Smoke test | failed |
 | Deps updated | 13 |
 
@@ -22,18 +22,18 @@ npm install @depup/react-native-worklets
 
 | Dependency | From | To |
 |------------|------|-----|
-| @babel/generator | ^7.27.1 | ^8.0.0 |
+| @babel/generator | ^7.27.1 | ^8.0.5 |
 | @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.1 |
+| @babel/plugin-transform-classes | ^7.28.6 | ^8.0.5 |
 | @babel/plugin-transform-nullish-coalescing-operator | ^7.28.6 | ^8.0.1 |
-| @babel/plugin-transform-optional-chaining | ^7.28.6 | ^8.0.1 |
+| @babel/plugin-transform-optional-chaining | ^7.28.6 | ^8.0.5 |
 | @babel/plugin-transform-shorthand-properties | ^7.27.1 | ^8.0.1 |
 | @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.4 |
-| @babel/types | ^7.27.1 | ^8.0.4 |
+| @babel/traverse | ^7.27.1 | ^8.0.5 |
+| @babel/types | ^7.27.1 | ^8.0.5 |
 | semver | ^7.7.4 | ^7.8.5 |
 
 ---

package/android/build.gradle.kts

@@ -8,7 +8,21 @@ plugins {
     id("com.android.library")
     id("maven-publish")
     id("com.diffplug.spotless") version "8.1.0"
-    id("org.jetbrains.kotlin.android")
+    id("org.jetbrains.kotlin.android") apply false
+}
+
+fun shouldApplyKotlinAndroidPlugin(): Boolean {
+    val agpMajorVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.substringBefore('.').toInt()
+    if (agpMajorVersion <= 8) {
+        return true
+    }
+
+    val builtInKotlin = providers.gradleProperty("android.builtInKotlin").orNull?.toBoolean() ?: true
+    return !builtInKotlin
+}
+
+if (shouldApplyKotlinAndroidPlugin()) {
+    apply(plugin = "org.jetbrains.kotlin.android")
 }
 
 fun safeExtGet(prop: String, fallback: Any?): Any? =
@@ -159,7 +173,7 @@ apply(from = "./fix-prefab.gradle.kts")
 apply(from = "./generate-stub-pch.gradle.kts")
 
 android {
-    compileSdk = safeExtGet("compileSdkVersion", 36) as Int
+    compileSdk = safeExtGet("compileSdkVersion", 37) as Int
 
     namespace = "com.swmansion.worklets"
 
@@ -274,11 +288,11 @@ android {
 
     sourceSets {
         getByName("main") {
-            java {
+            kotlin {
                 if (FETCH_PREVIEW_ENABLED) {
-                    srcDir("src/networking")
+                    directories.add("src/networking")
                 } else {
-                    srcDir("src/no-networking")
+                    directories.add("src/no-networking")
                 }
             }
         }
@@ -290,7 +304,7 @@ android {
 }
 
 if (project != rootProject) {
-    kotlin {
+    extensions.configure<org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension> {
         compilerOptions {
             jvmTarget = JvmTarget.fromTarget("17")
         }

package/android/src/main/cpp/worklets/android/AndroidUIScheduler.cpp

@@ -7,18 +7,25 @@ namespace worklets {
 using namespace facebook;
 using namespace react;
 
-static thread_local bool tls_isOnUIThread = false;
-
 class UISchedulerWrapper : public UIScheduler {
  private:
   jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler_;
 
+  bool queryIsOnUIThread() const override {
+    static const auto method = androidUiScheduler_->getClass()->getMethod<jboolean()>("isOnUIThread");
+    return method(androidUiScheduler_);
+  }
+
  public:
   explicit UISchedulerWrapper(jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler)
       : androidUiScheduler_(std::move(androidUiScheduler)) {}
 
+  void triggerUI() override {
+    UIScheduler::triggerUI();
+  }
+
   void scheduleOnUI(std::function<void()> job) override {
-    if (tls_isOnUIThread) {
+    if (isOnUIThread()) {
       job();
       return;
     }
@@ -29,11 +36,6 @@ class UISchedulerWrapper : public UIScheduler {
       method(androidUiScheduler_);
     }
   }
-
-  void triggerUI() override {
-    tls_isOnUIThread = true;
-    UIScheduler::triggerUI();
-  }
 };
 
 AndroidUIScheduler::AndroidUIScheduler(const jni::alias_ref<AndroidUIScheduler::jhybridobject> &jThis)