react-native-worklets 0.13.0-nightly-20260916-1fb70959f → 0.13.0

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

@@ -2,13 +2,41 @@
 
 #include <jsi/jsi.h>
 
+#include <cstdint>
+#include <utility>
+
 namespace worklets {
 
+/**
+ * Identifies the owner of a job, so that a queue shared between several owners
+ * can cancel the jobs of one of them without touching the jobs of the others.
+ *
+ * Worklet Runtimes send their RuntimeId as a token.
+ */
+using AbortToken = uint64_t;
+
+inline constexpr AbortToken defaultToken{0};
+
 class AsyncQueue : public facebook::jsi::NativeState {
  public:
   ~AsyncQueue() override = default;
 
   virtual void push(std::function<void()> &&job) = 0;
+
+  /**
+   * Pushes a job on behalf of the owner the token belongs to. The default
+   * implementation discards the token.
+   */
+  virtual void push(std::function<void()> &&job, AbortToken /* abortToken */) {
+    push(std::move(job));
+  }
+
+  /**
+   * Drops the jobs that are still pending, destroying them on the calling
+   * thread. A queue shared between several owners drops only the jobs pushed
+   * with this token. The default implementation keeps every job.
+   */
+  virtual void abortPending(AbortToken /* abortToken */) {}
 };
 
 } // namespace worklets

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

@@ -5,6 +5,7 @@
 #endif // ANDROID
 
 #include <memory>
+#include <queue>
 #include <string>
 #include <thread>
 #include <utility>
@@ -92,6 +93,14 @@ void AsyncQueueImpl::push(std::function<void()> &&job) {
   state_->cv.notify_one();
 }
 
+void AsyncQueueImpl::abortPending(AbortToken /* abortToken */) {
+  std::queue<std::function<void()>> pendingJobs;
+  {
+    std::unique_lock<std::mutex> lock(state_->mutex);
+    std::swap(pendingJobs, state_->queue);
+  }
+}
+
 AsyncQueueUI::AsyncQueueUI(const std::shared_ptr<UIScheduler> &uiScheduler) : uiScheduler_(uiScheduler) {}
 
 void AsyncQueueUI::push(std::function<void()> &&job) {

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

@@ -25,8 +25,12 @@ class AsyncQueueImpl : public AsyncQueue {
 
   ~AsyncQueueImpl() override;
 
+  using AsyncQueue::push;
+
   void push(std::function<void()> &&job) override;
 
+  void abortPending(AbortToken abortToken) override;
+
  private:
   static void runLoop(const std::shared_ptr<AsyncQueueState> &state);
 
@@ -39,6 +43,8 @@ class AsyncQueueUI : public AsyncQueue {
 
   ~AsyncQueueUI() override = default;
 
+  using AsyncQueue::push;
+
   void push(std::function<void()> &&job) override;
 
  private:

package/Common/cpp/worklets/RunLoop/EventLoop.cpp

@@ -10,10 +10,12 @@ namespace worklets {
 
 EventLoop::EventLoop(
     const std::string &name,
+    const AbortToken abortToken,
     const std::shared_ptr<jsi::Runtime> &runtime,
     const std::shared_ptr<AsyncQueue> &queue,
     const std::shared_ptr<std::recursive_mutex> &runtimeMutex)
-    : runtime_(runtime),
+    : abortToken_(abortToken),
+      runtime_(runtime),
       queue_(queue),
       runtimeMutex_(runtimeMutex),
       timeoutsQueueState_(std::make_shared<TimeoutsQueueState>()),
@@ -88,12 +90,26 @@ void EventLoop::pushTask(std::function<void(jsi::Runtime &rt)> &&job) {
           job(*runtime);
           runtime->drainMicrotasks();
         }
-      });
+      },
+      abortToken_);
+}
+
+void EventLoop::abortPending() {
+  std::vector<Timeout> pendingTimeouts;
+  {
+    std::unique_lock<std::mutex> lock(timeoutsQueueState_->mutex);
+    timeoutsQueueState_->running = false;
+    std::swap(pendingTimeouts, timeoutsQueueState_->queue);
+  }
+  timeoutsQueueState_->cv.notify_all();
 }
 
 void EventLoop::pushTimeout(std::function<void(jsi::Runtime &rt)> &&job, int64_t delay) {
   {
     std::unique_lock<std::mutex> lock(timeoutsQueueState_->mutex);
+    if (!timeoutsQueueState_->running) {
+      return;
+    }
     const auto targetTime = getCurrentTimeInMs() + delay;
     const auto timeout = Timeout{std::move(job), targetTime};
     auto &queue = timeoutsQueueState_->queue;

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

@@ -33,6 +33,7 @@ class EventLoop : public std::enable_shared_from_this<EventLoop> {
  public:
   EventLoop(
       const std::string &name,
+      AbortToken abortToken,
       const std::shared_ptr<jsi::Runtime> &runtime,
       const std::shared_ptr<AsyncQueue> &queue,
       const std::shared_ptr<std::recursive_mutex> &runtimeMutex);
@@ -40,8 +41,10 @@ class EventLoop : public std::enable_shared_from_this<EventLoop> {
   void run();
   void pushTask(std::function<void(jsi::Runtime &rt)> &&job);
   void pushTimeout(std::function<void(jsi::Runtime &rt)> &&job, int64_t delay);
+  void abortPending();
 
  private:
+  const AbortToken abortToken_;
   const std::shared_ptr<jsi::Runtime> runtime_;
   const std::shared_ptr<AsyncQueue> queue_;
   const std::shared_ptr<std::recursive_mutex> runtimeMutex_;

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

@@ -1,13 +1,8 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <worklets/Compat/ReactNativeVersionCompat.h>
 
-#if REACT_NATIVE_VERSION_MINOR >= 84
 #include <cxxreact/JSBigString.h>
-#else
-#include <jsireact/JSIExecutor.h>
-#endif
 
 #include <memory>
 #include <utility>

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

@@ -183,21 +183,26 @@ void addMethod(jsi::Runtime &rt, jsi::Object &obj, const char *name, TFun &&func
           rt,
           jsi::PropNameID::forAscii(rt, name),
           TLength,
-          [func = std::forward<TFun>(func), name](
+          [func = std::forward<TFun>(func)](
               jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) mutable -> jsi::Value {
             using TReturn =
                 std::invoke_result_t<TFun &, jsi::Runtime &, const jsi::Value &, const jsi::Value(&)[TLength]>;
+            auto invoke = [&](const jsi::Value(&typed)[TLength]) -> jsi::Value {
+              if constexpr (std::is_void_v<TReturn>) {
+                func(rt, thisVal, typed);
+                return jsi::Value::undefined();
+              } else {
+                return func(rt, thisVal, typed);
+              }
+            };
             if (count < TLength) {
-              throw jsi::JSError(
-                  rt, std::string("[Worklets] ") + name + " expects " + std::to_string(TLength) + " arguments.");
-            }
-            auto &typed = *reinterpret_cast<const jsi::Value(*)[TLength]>(args);
-            if constexpr (std::is_void_v<TReturn>) {
-              func(rt, thisVal, typed);
-              return jsi::Value::undefined();
-            } else {
-              return func(rt, thisVal, typed);
+              jsi::Value padded[TLength];
+              for (size_t i = 0; i < count; ++i) {
+                padded[i] = jsi::Value(rt, args[i]);
+              }
+              return invoke(padded);
             }
+            return invoke(*reinterpret_cast<const jsi::Value(*)[TLength]>(args));
           }));
 }
 

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

@@ -88,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_;
 
@@ -244,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

@@ -261,6 +261,8 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
       bool enableLocking = true,
       bool enableNetworking = true);
 
+  ~WorkletRuntime() override;
+
   void init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWorkletsModuleProxy);
 
   /**
@@ -439,6 +441,10 @@ class WorkletRuntime : public jsi::HostObject, public std::enable_shared_from_th
 
   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_);

package/android/CMakeLists.txt

@@ -19,16 +19,10 @@ add_compile_options(${folly_FLAGS})
 string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_VERSION=${WORKLETS_VERSION}\
     -DWORKLETS_FEATURE_FLAGS=\"${WORKLETS_FEATURE_FLAGS}\"")
 
-# HERMES_V1_ENABLED is centralized in react-native-flags.cmake for RN >= 84.
-# Only define manually for older versions to avoid macro redefinition error.
-if(ReactAndroid_VERSION_MINOR LESS 84)
-  string(APPEND CMAKE_CXX_FLAGS " -DHERMES_V1_ENABLED=${HERMES_V1_ENABLED}")
-else()
-  # Reference the value so CMake records it as used, otherwise it warns:
-  # "Manually-specified variables were not used by the project:
-  # HERMES_V1_ENABLED"
-  set(HERMES_V1_ENABLED "${HERMES_V1_ENABLED}")
-endif()
+# HERMES_V1_ENABLED is centralized in react-native-flags.cmake. Reference the
+# value so CMake records it as used, otherwise it warns: "Manually-specified
+# variables were not used by the project: HERMES_V1_ENABLED"
+set(HERMES_V1_ENABLED "${HERMES_V1_ENABLED}")
 
 string(APPEND CMAKE_CXX_FLAGS " -fno-omit-frame-pointer -fstack-protector-all")
 
@@ -63,14 +57,8 @@ target_precompile_headers(worklets PRIVATE "${ANDROID_CPP_DIR}/WorkletsPCH.h")
 target_compile_options(
   worklets PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-Xclang;-fno-pch-timestamp>")
 
-if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
-  include(
-    "${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
-  target_compile_reactnative_options(worklets PUBLIC)
-else()
-  string(APPEND CMAKE_CXX_FLAGS
-         " -fexceptions -frtti -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
-endif()
+include("${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
+target_compile_reactnative_options(worklets PUBLIC)
 
 # includes
 target_include_directories(worklets PUBLIC "${COMMON_CPP_DIR}"
@@ -94,11 +82,7 @@ set_target_properties(worklets PROPERTIES LINKER_LANGUAGE CXX)
 target_link_libraries(worklets android log ReactAndroid::reactnative
                       ReactAndroid::jsi fbjni::fbjni)
 
-if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 82)
-  target_link_libraries(worklets hermes-engine::hermesvm)
-else()
-  target_link_libraries(worklets hermes-engine::libhermes)
-endif()
+target_link_libraries(worklets hermes-engine::hermesvm)
 
 if(${HERMES_ENABLE_DEBUGGER})
   string(APPEND CMAKE_CXX_FLAGS " -DHERMES_ENABLE_DEBUGGER=1")

package/android/build.gradle.kts

@@ -69,22 +69,13 @@ fun getReactNativeVersion(): String {
     return reactProperties.getProperty("VERSION_NAME")
 }
 
-fun getReactNativeMinorVersion(): Int {
-    val reactNativeVersion = getReactNativeVersion()
-    return if (reactNativeVersion.startsWith("0.0.0-")) 1000 else reactNativeVersion.split(".")[1].toInt()
-}
-
 fun getHermesV1Enabled(): Boolean {
     // Even though `HERMES_V1_ENABLED` is now centralized
-    // in `react-native-flags.cmake` for React Native >= 0.84
-    // that CMake file depends on definitions provided
-    // in local `externalNativeBuild` configuration of the LIBRARY.
+    // in `react-native-flags.cmake`, that CMake file depends
+    // on definitions provided in local `externalNativeBuild`
+    // configuration of the LIBRARY.
     // I hope this is only a temporary workaround.
-    return if (getReactNativeMinorVersion() >= 84) {
-        safeAppExtGet("hermesV1Enabled", true)?.toString()?.toBoolean() ?: true
-    } else {
-        safeAppExtGet("hermesV1Enabled", false)?.toString()?.toBoolean() ?: false
-    }
+    return safeAppExtGet("hermesV1Enabled", true)?.toString()?.toBoolean() ?: true
 }
 
 fun getWorkletsVersion(): String {

package/apple/worklets/apple/Networking/WorkletsURLSessionDelegate.h

@@ -26,7 +26,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)sendRequest:(worklets::RequestConfig &&)config
           requestId:(uint64_t)requestId
-           listener:(const std::shared_ptr<worklets::NetworkRequestListener> &)listener;
+           listener:(std::shared_ptr<worklets::NetworkRequestListener>)listener;
 - (void)abortRequest:(uint64_t)requestId;
 - (void)invalidate;
 

package/apple/worklets/apple/Networking/WorkletsURLSessionDelegate.mm

@@ -248,7 +248,7 @@ static BOOL isSameOrigin(NSURL *lhs, NSURL *rhs)
 
 - (void)sendRequest:(RequestConfig &&)config
           requestId:(uint64_t)requestId
-           listener:(const std::shared_ptr<NetworkRequestListener> &)listener
+           listener:(std::shared_ptr<NetworkRequestListener>)listener
 {
   NSString *urlString = [NSString stringWithUTF8String:config.url.c_str()];
   NSURL *url = urlString != nil ? [NSURL URLWithString:urlString] : nil;
@@ -287,22 +287,21 @@ static BOOL isSameOrigin(NSURL *lhs, NSURL *rhs)
   request.HTTPShouldHandleCookies = config.withCredentials;
   request.timeoutInterval = config.timeoutMs > 0 ? config.timeoutMs / 1000.0 : kNoTimeoutInterval;
 
-  const auto sharedListener = listener;
   const auto timeoutMs = config.timeoutMs;
   const auto withCredentials = config.withCredentials;
 
   [_delegateQueue addOperationWithBlock:^{
     if (atomic_load(&self->_invalidated)) {
-      sharedListener->onError(RequestError::Aborted, "The networking session was invalidated.");
+      listener->onError(RequestError::Aborted, "The networking session was invalidated.");
       return;
     }
     NSURLSessionDataTask *task = [[self sessionWithCredentials:withCredentials] dataTaskWithRequest:request];
     if (task == nil) {
-      sharedListener->onError(RequestError::Network, "Failed to create a data task for the request.");
+      listener->onError(RequestError::Network, "Failed to create a data task for the request.");
       return;
     }
     WorkletsRequestState *state = [WorkletsRequestState new];
-    state->listener = sharedListener;
+    state->listener = listener;
     state->data = [NSMutableData new];
     state->requestId = requestId;
     state->expectedContentLength = -1;

package/compatibility.json

@@ -1,9 +1,9 @@
 {
   "nightly": {
-    "react-native": ["0.83", "0.84", "0.85", "0.86", "0.87"]
+    "react-native": ["0.86", "0.87", "0.88"]
   },
   "0.13.x": {
-    "react-native": ["0.83", "0.84", "0.85", "0.86", "0.87"]
+    "react-native": ["0.86", "0.87", "0.88"]
   },
   "0.12.x": {
     "react-native": ["0.83", "0.84", "0.85", "0.86", "0.87"]

package/lib/module/debug/jsVersion.js

@@ -5,5 +5,5 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export const jsVersion = '0.13.0-nightly-20260916-1fb70959f';
+export const jsVersion = '0.13.0';
 //# sourceMappingURL=jsVersion.js.map

package/lib/module/debug/jsVersion.js.map

@@ -1 +1 @@
-{"version":3,"names":["jsVersion"],"sourceRoot":"../../../src","sources":["debug/jsVersion.ts"],"mappings":"AAAA,YAAY;;AAEZ;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,SAAS,GAAG,mCAAmC","ignoreList":[]}
+{"version":3,"names":["jsVersion"],"sourceRoot":"../../../src","sources":["debug/jsVersion.ts"],"mappings":"AAAA,YAAY;;AAEZ;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,SAAS,GAAG,QAAQ","ignoreList":[]}

package/lib/typescript/debug/jsVersion.d.ts

@@ -3,5 +3,5 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export declare const jsVersion = "0.13.0-nightly-20260916-1fb70959f";
+export declare const jsVersion = "0.13.0";
 //# sourceMappingURL=jsVersion.d.ts.map

package/lib/typescript/debug/jsVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsVersion.d.ts","sourceRoot":"","sources":["../../../src/debug/jsVersion.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,SAAS,sCAAsC,CAAC"}
+{"version":3,"file":"jsVersion.d.ts","sourceRoot":"","sources":["../../../src/debug/jsVersion.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,SAAS,WAAW,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-worklets",
-  "version": "0.13.0-nightly-20260916-1fb70959f",
+  "version": "0.13.0",
   "description": "The React Native multithreading library",
   "keywords": [
     "react-native",
@@ -9,7 +9,7 @@
     "worklets"
   ],
   "scripts": {
-    "build": "yarn workspace babel-plugin-worklets build && yarn set-version && yarn run --top-level bob build",
+    "build": "yarn workspace babel-plugin-worklets build && yarn workspace worklets-oxc-plugin build && yarn set-version && yarn run --top-level bob build",
     "circular-dependency-check": "yarn madge --extensions js,jsx --circular lib",
     "find-unused-code:js": "knip",
     "format": "yarn format:js && yarn format:plugin && yarn format:common && yarn format:android && yarn format:apple",
@@ -62,7 +62,7 @@
     "@babel/core": "*",
     "@react-native/metro-config": "*",
     "react": "*",
-    "react-native": "0.83 - 0.87"
+    "react-native": "0.86 - 0.88"
   },
   "dependencies": {
     "@babel/generator": "^7.27.1",
@@ -77,6 +77,7 @@
     "@babel/preset-typescript": "^7.28.5",
     "@babel/traverse": "^7.27.1",
     "@babel/types": "^7.27.1",
+    "@jridgewell/remapping": "^2.3.5",
     "convert-source-map": "^2.0.0",
     "semver": "^7.7.4",
     "whatwg-fetch": "^3.6.20"
@@ -85,8 +86,8 @@
     "@babel/cli": "7.28.3",
     "@babel/core": "7.29.6",
     "@react-native-community/cli": "20.2.0",
-    "@react-native/eslint-config": "0.87.0",
-    "@react-native/jest-preset": "0.87.0",
+    "@react-native/eslint-config": "0.88.0-rc.1",
+    "@react-native/jest-preset": "0.88.0-rc.1",
     "@types/node": "24.7.0",
     "@types/react": "19.2.18",
     "clang-format-node": "1.3.5",
@@ -94,8 +95,8 @@
     "is-tree-shakable": "0.5.0",
     "knip": "5.61.3",
     "madge": "8.0.0",
-    "react": "19.2.8",
-    "react-native": "0.87.0",
+    "react": "19.3.0",
+    "react-native": "0.88.0-rc.1",
     "typescript": "5.9.3"
   },
   "main": "./lib/module/index",
@@ -119,6 +120,11 @@
     "jest",
     "plugin/index.js",
     "plugin/index.d.ts",
+    "plugin-oxc/index.js",
+    "plugin-oxc/index.d.ts",
+    "plugin-oxc/babel.js",
+    "plugin-oxc/babel.d.ts",
+    "plugin-oxc/*.node",
     "Package.swift",
     "*.podspec",
     "react-native.config.js",

package/plugin-oxc/babel.d.ts

@@ -0,0 +1,7 @@
+import type * as babel from '@babel/core';
+
+declare function workletsPluginOxcBabelShim(
+  babelApi: typeof babel
+): babel.PluginObj;
+
+export = workletsPluginOxcBabelShim;

package/plugin-oxc/babel.js

@@ -0,0 +1,200 @@
+'use strict';
+
+const path = require('path');
+
+const oxc = require('./index.js');
+
+// Previous steps can pass their output sourcemap
+// it needs to be merged with this plugin's one
+// to preserve correct mappings
+const remapping = require('@jridgewell/remapping');
+
+const PARSE_ERROR_CODE = 'WORKLETS_ERR_PARSE';
+const FLOW_ERROR_CODE = 'WORKLETS_ERR_FLOW';
+
+let warnedAboutIgnoredOptions = false;
+let cachedWorkletsPkgDir;
+let cachedSyntaxJsx;
+let cachedSyntaxTypescript;
+
+/**
+ * @param {typeof import('@babel/core')} babelApi
+ * @returns {import('@babel/core').PluginObj}
+ */
+function workletsPluginOxcBabelShim(babelApi) {
+  return {
+    name: 'worklets-oxc-plugin',
+    visitor: {
+      Program: {
+        enter(programPath, state) {
+          if (state.file.__workletsOxcRan) {
+            return;
+          }
+          state.file.__workletsOxcRan = true;
+
+          const filename = state.filename;
+          if (filename == null) {
+            throw new Error(
+              '[Worklets] the OXC transform needs a filename to name worklets ' +
+                'and to place their generated files, but Babel was given none.'
+            );
+          }
+
+          const result = transform(state.file.code, filename, state);
+          if (!result.changed) {
+            return;
+          }
+
+          adoptSourceMap(result, state);
+          programPath.replaceWith(
+            reparse(babelApi, result.code, filename, state)
+          );
+        },
+      },
+    },
+  };
+}
+
+/**
+ * @param {string} sourceText
+ * @param {string} filename
+ * @param {import('@babel/core').PluginPass} state
+ * @returns {import('./index').TransformResult}
+ */
+function transform(sourceText, filename, state) {
+  warnAboutIgnoredOptions(state.opts);
+  try {
+    return oxc.transform(sourceText, filename, {
+      ...state.opts,
+      envName: state.file.opts.envName,
+      workletsPackageDir: resolveWorkletsPkgDir(),
+    });
+  } catch (error) {
+    const message = (error && error.message) || '';
+    if (message.includes(FLOW_ERROR_CODE)) {
+      return { code: sourceText, files: [], changed: false };
+    }
+    if (message.includes(PARSE_ERROR_CODE)) {
+      throw new Error(
+        `[Worklets] ${filename} could not be parsed, so no worklets in it ` +
+          `were compiled.\n${message}`
+      );
+    }
+    throw error;
+  }
+}
+
+/**
+ * @param {import('./index').PluginOptions} options
+ * @returns {void}
+ */
+function warnAboutIgnoredOptions(options) {
+  if (warnedAboutIgnoredOptions) {
+    return;
+  }
+  const hasExtras =
+    (options?.extraPlugins?.length ?? 0) > 0 ||
+    (options?.extraPresets?.length ?? 0) > 0;
+  if (!hasExtras) {
+    return;
+  }
+  warnedAboutIgnoredOptions = true;
+  console.warn(
+    '[Worklets] `extraPlugins`/`extraPresets` are accepted for option-surface ' +
+      'compatibility with `react-native-worklets/plugin` but ignored — the OXC transform ' +
+      'cannot dispatch arbitrary Babel plugins. Compose them around this plugin in ' +
+      'babel.config.js instead.'
+  );
+}
+
+/** @returns {string} */
+function resolveWorkletsPkgDir() {
+  if (cachedWorkletsPkgDir === undefined) {
+    try {
+      cachedWorkletsPkgDir = path.dirname(
+        require.resolve('react-native-worklets/package.json')
+      );
+    } catch (error) {
+      throw new Error(
+        "[Worklets] couldn't find the react-native-worklets package on disk, " +
+          'so the generated worklet files have nowhere to go. ' +
+          `Make sure it's installed. Cause: ${error.message}`
+      );
+    }
+  }
+  return cachedWorkletsPkgDir;
+}
+
+/**
+ * @param {import('./index').TransformResult} result
+ * @param {import('@babel/core').PluginPass} state
+ * @returns {void}
+ */
+function adoptSourceMap(result, state) {
+  if (!result.map) {
+    return;
+  }
+  const map = JSON.parse(result.map);
+  const sourceFileName = state.file.opts.generatorOpts?.sourceFileName;
+  if (sourceFileName) {
+    map.sources = [sourceFileName];
+  }
+  const previous = state.file.inputMap;
+  if (previous) {
+    const previousMap = previous.toObject();
+    const composed = remapping([map, previousMap], () => null, true);
+    state.file.inputMap = { toObject: () => composed };
+    return;
+  }
+  state.file.inputMap = { toObject: () => map };
+}
+
+/**
+ * @param {typeof import('@babel/core')} babelApi
+ * @param {string} code
+ * @param {string} filename
+ * @param {import('@babel/core').PluginPass} state
+ * @returns {import('@babel/types').Program}
+ */
+function reparse(babelApi, code, filename, state) {
+  const parse = (babelApi && babelApi.parse) || require('@babel/core').parse;
+  const parserOpts = state.file.opts.parserOpts ?? {};
+  const ast = parse(code, {
+    sourceType:
+      parserOpts.sourceType ?? state.file.opts.sourceType ?? 'unambiguous',
+    parserOpts: { ...parserOpts },
+    babelrc: false,
+    configFile: false,
+    plugins: reparseSyntaxPlugins(filename),
+  });
+  return ast.program;
+}
+
+/**
+ * @param {string} filename
+ * @returns {import('@babel/core').PluginItem[]}
+ */
+function reparseSyntaxPlugins(filename) {
+  if (filename.endsWith('.tsx')) {
+    return [[syntaxTypescript(), { isTSX: true }]];
+  }
+  if (/\.(ts|mts|cts)$/.test(filename)) {
+    return [[syntaxTypescript(), { isTSX: false }]];
+  }
+  return [[syntaxJsx()]];
+}
+
+/** @returns {string} */
+function syntaxTypescript() {
+  cachedSyntaxTypescript ??= require.resolve('@babel/plugin-syntax-typescript');
+  return cachedSyntaxTypescript;
+}
+
+/** @returns {string} */
+function syntaxJsx() {
+  cachedSyntaxJsx ??= require.resolve('@babel/plugin-syntax-jsx');
+  return cachedSyntaxJsx;
+}
+
+module.exports = workletsPluginOxcBabelShim;
+module.exports.default = workletsPluginOxcBabelShim;

package/plugin-oxc/index.d.ts

@@ -0,0 +1,33 @@
+export interface PluginOptions {
+  extraPlugins?: string[];
+  extraPresets?: string[];
+  importForwarding?: {
+    moduleNames?: string[];
+    relativePaths?: string[];
+  };
+}
+
+export interface TransformOptions extends PluginOptions {
+  envName?: string;
+  pluginVersion?: string;
+  workletsPackageDir?: string;
+}
+
+export interface EmittedFile {
+  path: string;
+  content: string;
+}
+
+export interface TransformResult {
+  code: string;
+  map?: string;
+  files: EmittedFile[];
+  /** Whether the transform rewrote anything; if not, the input AST still stands. */
+  changed: boolean;
+}
+
+export function transform(
+  sourceText: string,
+  filename: string,
+  options?: TransformOptions
+): TransformResult;

package/plugin-oxc/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { existsSync } = require('fs');
+const { join } = require('path');
+
+const platform = process.platform;
+const arch = process.arch;
+
+function candidates() {
+  return [
+    join(__dirname, `worklets-oxc-plugin.${platform}-${arch}.node`),
+    join(__dirname, 'worklets-oxc-plugin.node'),
+  ];
+}
+
+let binding = null;
+let lastError = null;
+for (const p of candidates()) {
+  if (existsSync(p)) {
+    try {
+      binding = require(p);
+      break;
+    } catch (e) {
+      lastError = e;
+    }
+  }
+}
+
+if (!binding) {
+  throw new Error(
+    `[Worklets] Could not load native binding. Run \`yarn build\` (or \`cargo build --release\`) in ${__dirname}. Last error: ${lastError && lastError.message}`
+  );
+}
+
+module.exports = binding;
+module.exports.default = binding;

package/src/debug/jsVersion.ts

@@ -5,4 +5,4 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export const jsVersion = '0.13.0-nightly-20260916-1fb70959f';
+export const jsVersion = '0.13.0';

package/Common/cpp/worklets/Compat/ReactNativeVersionCompat.h

@@ -1,7 +0,0 @@
-#pragma once
-
-#if __has_include(<React/Utils.h>)
-#include <React/Utils.h>
-#else
-#include <cxxreact/ReactNativeVersion.h>
-#endif