react-native-worklets 0.3.0 → 0.4.0-bundle-mode-preview-1

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

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <shared_mutex>
+#include <string>
+#include <vector>
+
+namespace worklets {
+
+/**
+ * Forward declaration to avoid circular dependencies.
+ */
+class JSIWorkletsModuleProxy;
+
+/**
+ * Unused, but kept for possible future use.
+ */
+constexpr uint64_t rnRuntimeId{0};
+constexpr uint64_t uiRuntimeId{1};
+extern const std::string uiRuntimeName;
+
+class RuntimeManager {
+ public:
+  std::shared_ptr<WorkletRuntime> getRuntime(uint64_t runtimeId);
+  std::shared_ptr<WorkletRuntime> getRuntime(const std::string &name);
+
+  std::vector<std::shared_ptr<WorkletRuntime>> getAllRuntimes();
+
+  std::shared_ptr<WorkletRuntime> getUIRuntime();
+
+  std::shared_ptr<WorkletRuntime> createWorkletRuntime(
+      std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy,
+      const bool supportsLocking,
+      const std::string &name,
+      std::shared_ptr<ShareableWorklet> initializer = nullptr);
+
+  std::shared_ptr<WorkletRuntime> createUninitializedUIRuntime(
+      const std::shared_ptr<MessageQueueThread> &jsQueue);
+
+ private:
+  uint64_t getNextRuntimeId();
+
+  std::atomic_uint64_t nextRuntimeId_{uiRuntimeId + 1};
+  std::map<uint64_t, std::weak_ptr<WorkletRuntime>> weakRuntimes_;
+  std::shared_mutex weakRuntimesMutex_;
+  std::map<std::string, uint64_t> nameToRuntimeId_;
+};
+
+} // namespace worklets

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

@@ -10,6 +10,7 @@
 #include <hermes/hermes.h>
 #include <jsi/decorator.h>
 #include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
 
 #include <atomic>
 #include <memory>
@@ -61,13 +62,15 @@ struct WorkletsReentrancyCheck {
       // Returns true if tid and expected were the same.  If they
       // were, then the stored tid referred to no thread, and we
       // atomically saved this thread's tid.  Now increment depth.
-      assert(depth == 0 && "[Worklets] No thread id, but depth != 0");
+      react_native_assert(
+          depth == 0 && "[Worklets] No thread id, but depth != 0");
       ++depth;
     } else if (expected == this_id) {
       // If the stored tid referred to a thread, expected was set to
       // that value.  If that value is this thread's tid, that's ok,
       // just increment depth again.
-      assert(depth != 0 && "[Worklets] Thread id was set, but depth == 0");
+      react_native_assert(
+          depth != 0 && "[Worklets] Thread id was set, but depth == 0");
       ++depth;
     } else {
       // The stored tid was some other thread.  This indicates a bad
@@ -79,7 +82,7 @@ struct WorkletsReentrancyCheck {
   }
 
   void after() {
-    assert(
+    react_native_assert(
         tid.load(std::memory_order_relaxed) == std::this_thread::get_id() &&
         "[Worklets] No thread id in after()");
     if (--depth == 0) {
@@ -87,7 +90,8 @@ struct WorkletsReentrancyCheck {
       std::thread::id expected = std::this_thread::get_id();
       bool didWrite = tid.compare_exchange_strong(
           expected, std::thread::id(), std::memory_order_relaxed);
-      assert(didWrite && "[Worklets] Decremented to zero, but no tid write");
+      react_native_assert(
+          didWrite && "[Worklets] Decremented to zero, but no tid write");
     }
   }
 

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

@@ -1,6 +1,9 @@
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
 #include <worklets/Resources/ValueUnpacker.h>
 #include <worklets/Tools/Defs.h>
 #include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
@@ -14,8 +17,6 @@
 
 #if JS_RUNTIME_HERMES
 #include <worklets/WorkletRuntime/WorkletHermesRuntime.h>
-#elif JS_RUNTIME_V8
-#include <v8runtime/V8RuntimeFactory.h>
 #else
 #include <jsc/JSCRuntime.h>
 #endif // JS_RUNTIME
@@ -52,24 +53,16 @@ class LockableRuntime : public jsi::WithRuntimeDecorator<AroundLock> {
 };
 
 static std::shared_ptr<jsi::Runtime> makeRuntime(
-    jsi::Runtime &rnRuntime,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::string &name,
     const bool supportsLocking,
     const std::shared_ptr<std::recursive_mutex> &runtimeMutex) {
   std::shared_ptr<jsi::Runtime> jsiRuntime;
 #if JS_RUNTIME_HERMES
-  (void)rnRuntime; // used only by V8
   auto hermesRuntime = facebook::hermes::makeHermesRuntime();
   jsiRuntime = std::make_shared<WorkletHermesRuntime>(
       std::move(hermesRuntime), jsQueue, name);
-#elif JS_RUNTIME_V8
-  auto config = std::make_unique<rnv8::V8RuntimeConfig>();
-  config->enableInspector = false;
-  config->appName = name;
-  jsiRuntime = rnv8::createSharedV8Runtime(&rnRuntime, std::move(config));
 #else
-  (void)rnRuntime; // used only by V8
   jsiRuntime = facebook::jsc::makeJSCRuntime();
 #endif
 
@@ -81,36 +74,75 @@ static std::shared_ptr<jsi::Runtime> makeRuntime(
 }
 
 WorkletRuntime::WorkletRuntime(
-    jsi::Runtime &rnRuntime,
+    uint64_t runtimeId,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
-    const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::string &name,
-    const bool supportsLocking,
-    const bool isDevBundle)
-    : runtimeMutex_(std::make_shared<std::recursive_mutex>()),
-      runtime_(makeRuntime(
-          rnRuntime,
-          jsQueue,
-          name,
-          supportsLocking,
-          runtimeMutex_)),
+    const bool supportsLocking)
+    : runtimeId_(runtimeId),
+      runtimeMutex_(std::make_shared<std::recursive_mutex>()),
+      runtime_(makeRuntime(jsQueue, name, supportsLocking, runtimeMutex_)),
 #ifndef NDEBUG
       supportsLocking_(supportsLocking),
-#endif
+#endif // NDEBUG
       name_(name) {
   jsi::Runtime &rt = *runtime_;
   WorkletRuntimeCollector::install(rt);
-  WorkletRuntimeDecorator::decorate(rt, name, jsScheduler, isDevBundle);
+}
+
+void WorkletRuntime::init(
+    std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy) {
+  jsi::Runtime &rt = *runtime_;
+  const auto jsScheduler = jsiWorkletsModuleProxy->getJSScheduler();
+  const auto isDevBundle = jsiWorkletsModuleProxy->isDevBundle();
+#ifdef WORKLETS_BUNDLE_MODE
+  auto script = jsiWorkletsModuleProxy->getScript();
+  const auto &sourceUrl = jsiWorkletsModuleProxy->getSourceUrl();
+#endif // WORKLETS_BUNDLE_MODE
+
+  auto optimizedJsiWorkletsModuleProxy =
+      jsi_utils::optimizedFromHostObject(rt, std::move(jsiWorkletsModuleProxy));
 
+  WorkletRuntimeDecorator::decorate(
+      rt,
+      name_,
+      jsScheduler,
+      isDevBundle,
+      std::move(optimizedJsiWorkletsModuleProxy));
+
+#ifdef WORKLETS_BUNDLE_MODE
+  if (!script) {
+    throw std::runtime_error(
+        "[Worklets] Expected to receive the bundle, but got nullptr instead.");
+  }
+
+  try {
+    rt.evaluateJavaScript(script, sourceUrl);
+  } catch (facebook::jsi::JSError error) {
+    const auto &message = error.getMessage();
+    const auto &stack = error.getStack();
+    if (!message.starts_with("[Worklets] Worklets initialized successfully")) {
+      const auto newMessage =
+          "[Worklets] Failed to initialize runtime. Reason: " + message;
+      JSLogger::reportFatalErrorOnJS(
+          jsScheduler,
+          {.message = newMessage,
+           .stack = stack,
+           .name = "WorkletsError",
+           .jsEngine = "Worklets"});
+    }
+  }
+#else
+  // Legacy behavior
   auto valueUnpackerBuffer =
       std::make_shared<const jsi::StringBuffer>(ValueUnpackerCode);
   rt.evaluateJavaScript(valueUnpackerBuffer, "valueUnpacker");
+#endif // WORKLETS_BUNDLE_MODE
 }
 
 jsi::Value WorkletRuntime::executeSync(
     jsi::Runtime &rt,
     const jsi::Value &worklet) const {
-  assert(
+  react_native_assert(
       supportsLocking_ &&
       ("[Worklets] Runtime \"" + name_ + "\" doesn't support locking.")
           .c_str());
@@ -126,6 +158,20 @@ jsi::Value WorkletRuntime::executeSync(
   return shareableResult->toJSValue(rt);
 }
 
+jsi::Value WorkletRuntime::executeSync(
+    std::function<jsi::Value(jsi::Runtime &)> &&job) const {
+  auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+  jsi::Runtime &uiRuntime = getJSIRuntime();
+  return job(uiRuntime);
+}
+
+jsi::Value WorkletRuntime::executeSync(
+    const std::function<jsi::Value(jsi::Runtime &)> &job) const {
+  auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+  jsi::Runtime &uiRuntime = getJSIRuntime();
+  return job(uiRuntime);
+}
+
 jsi::Value WorkletRuntime::get(
     jsi::Runtime &rt,
     const jsi::PropNameID &propName) {

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

@@ -2,6 +2,7 @@
 
 #include <cxxreact/MessageQueueThread.h>
 #include <jsi/jsi.h>
+#include <jsireact/JSIExecutor.h>
 
 #include <worklets/SharedItems/Shareables.h>
 #include <worklets/Tools/AsyncQueue.h>
@@ -17,16 +18,21 @@ using namespace react;
 
 namespace worklets {
 
+/**
+ * Forward declaration to avoid circular dependencies.
+ */
+class JSIWorkletsModuleProxy;
+
 class WorkletRuntime : public jsi::HostObject,
                        public std::enable_shared_from_this<WorkletRuntime> {
  public:
   explicit WorkletRuntime(
-      jsi::Runtime &rnRuntime,
+      uint64_t runtimeId,
       const std::shared_ptr<MessageQueueThread> &jsQueue,
-      const std::shared_ptr<JSScheduler> &jsScheduler,
       const std::string &name,
-      const bool supportsLocking,
-      const bool isDevBundle);
+      const bool supportsLocking);
+
+  void init(std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy);
 
   jsi::Runtime &getJSIRuntime() const {
     return *runtime_;
@@ -58,6 +64,11 @@ class WorkletRuntime : public jsi::HostObject,
 
   jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const;
 
+  jsi::Value executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const;
+
+  jsi::Value executeSync(
+      const std::function<jsi::Value(jsi::Runtime &)> &job) const;
+
   std::string toString() const {
     return "[WorkletRuntime \"" + name_ + "\"]";
   }
@@ -66,7 +77,16 @@ class WorkletRuntime : public jsi::HostObject,
 
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
+  [[nodiscard]] auto getRuntimeId() const -> uint64_t {
+    return runtimeId_;
+  }
+
+  [[nodiscard]] auto getRuntimeName() const -> std::string {
+    return name_;
+  }
+
  private:
+  const uint64_t runtimeId_;
   const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
   const std::shared_ptr<jsi::Runtime> runtime_;
 #ifndef NDEBUG

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

@@ -5,6 +5,7 @@
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
 
+#include <utility>
 #include <vector>
 
 namespace worklets {
@@ -40,7 +41,8 @@ void WorkletRuntimeDecorator::decorate(
     jsi::Runtime &rt,
     const std::string &name,
     const std::shared_ptr<JSScheduler> &jsScheduler,
-    const bool isDevBundle) {
+    const bool isDevBundle,
+    jsi::Object &&jsiWorkletsModuleProxy) {
   // resolves "ReferenceError: Property 'global' doesn't exist at ..."
   rt.global().setProperty(rt, "global", rt.global());
 
@@ -54,6 +56,9 @@ void WorkletRuntimeDecorator::decorate(
 
   rt.global().setProperty(rt, "__DEV__", isDevBundle);
 
+  rt.global().setProperty(
+      rt, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
+
 #ifndef NDEBUG
   auto evalWithSourceUrl = [](jsi::Runtime &rt,
                               const jsi::Value &thisValue,
@@ -98,6 +103,13 @@ void WorkletRuntimeDecorator::decorate(
             rt, value, shouldRetainRemote, nativeStateSource);
       });
 
+  jsi_utils::installJsiFunction(
+      rt,
+      "_makeShareableHostObject",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeShareableHostObject(rt, value.asObject(rt).asHostObject(rt));
+      });
+
   jsi_utils::installJsiFunction(
       rt,
       "_makeShareableString",
@@ -131,10 +143,50 @@ void WorkletRuntimeDecorator::decorate(
         return makeShareableUndefined(rt);
       });
 
+  jsi_utils::installJsiFunction(
+      rt, "_makeShareableArray", [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeShareableArray(rt, value.asObject(rt).asArray(rt), false);
+      });
+
   jsi_utils::installJsiFunction(rt, "_makeShareableNull", [](jsi::Runtime &rt) {
     return makeShareableNull(rt);
   });
 
+  jsi_utils::installJsiFunction(
+      rt,
+      "_makeShareableObject",
+      [](jsi::Runtime &rt,
+         const jsi::Value &value,
+         const jsi::Value &shouldRetainRemote,
+         const jsi::Value &nativeStateSource) {
+        return makeShareableObject(
+            rt,
+            value.getObject(rt),
+            shouldRetainRemote.getBool(),
+            nativeStateSource);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_makeShareableWorklet",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeShareableWorklet(rt, value.asObject(rt), false);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_makeShareableInitializer",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeShareableInitializer(rt, value.asObject(rt));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_makeShareableFunction",
+      [](jsi::Runtime &rt, const jsi::Value &value) {
+        return makeShareableFunction(rt, value.asObject(rt).asFunction(rt));
+      });
+
   jsi_utils::installJsiFunction(
       rt,
       "_scheduleRemoteFunctionOnJS",

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

@@ -17,7 +17,8 @@ class WorkletRuntimeDecorator {
       jsi::Runtime &rt,
       const std::string &name,
       const std::shared_ptr<JSScheduler> &jsScheduler,
-      const bool isDevBundle);
+      const bool isDevBundle,
+      jsi::Object &&jsiWorkletsModuleProxy);
 };
 
 } // namespace worklets

package/RNWorklets.podspec

@@ -5,6 +5,9 @@ package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 $worklets_config = worklets_find_config()
 worklets_assert_minimal_react_native_version($worklets_config)
 
+$new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] != '0'
+worklets_assert_new_architecture_enabled($new_arch_enabled)
+
 ios_min_version = '13.4'
 
 Pod::Spec.new do |s|
@@ -42,7 +45,9 @@ Pod::Spec.new do |s|
   #   HERMESVM_PROFILER_OPCODE
   #   HERMESVM_PROFILER_BB
   # which shouldn't be defined in standard setups.
-  hermes_debug_hidden_flags = '$(inherited) HERMES_ENABLE_DEBUGGER=1'
+  hermes_debug_hidden_flags = 'HERMES_ENABLE_DEBUGGER=1'
+
+  bundle_mode_flag = $worklets_config[:bundle_mode] ? 'WORKLETS_BUNDLE_MODE=1' : ''
   
   s.pod_target_xcconfig = {
     "USE_HEADERMAP" => "YES",
@@ -58,9 +63,9 @@ Pod::Spec.new do |s|
       '"$(PODS_ROOT)/Headers/Private/Yoga"',
     ].join(' '),
     "FRAMEWORK_SEARCH_PATHS" => '"${PODS_CONFIGURATION_BUILD_DIR}/React-hermes"',
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
-    "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => hermes_debug_hidden_flags,
-    "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => '$(inherited)',
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => "$(inherited) #{hermes_debug_hidden_flags} #{bundle_mode_flag}",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => "$(inherited) #{bundle_mode_flag}",
   }
   s.xcconfig = {
     "HEADER_SEARCH_PATHS" => [

package/android/CMakeLists.txt

@@ -18,13 +18,12 @@ string(APPEND CMAKE_CXX_FLAGS
        " -fexceptions -fno-omit-frame-pointer -frtti -fstack-protector-all \
   -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
 
-if(${IS_NEW_ARCHITECTURE_ENABLED})
-  string(APPEND CMAKE_CXX_FLAGS " -DRCT_NEW_ARCH_ENABLED")
-endif()
-
 if(${IS_REANIMATED_EXAMPLE_APP})
   string(APPEND CMAKE_CXX_FLAGS " -DIS_REANIMATED_EXAMPLE_APP -Wpedantic")
 endif()
+if(${WORKLETS_BUNDLE_MODE})
+  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_BUNDLE_MODE")
+endif()
 
 if(NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug")
   string(APPEND CMAKE_CXX_FLAGS " -DNDEBUG")
@@ -34,17 +33,10 @@ if(${JS_RUNTIME} STREQUAL "hermes")
   string(APPEND CMAKE_CXX_FLAGS " -DJS_RUNTIME_HERMES=1")
 elseif(${JS_RUNTIME} STREQUAL "jsc")
   string(APPEND CMAKE_CXX_FLAGS " -DJS_RUNTIME_JSC=1")
-elseif(${JS_RUNTIME} STREQUAL "v8")
-  string(APPEND CMAKE_CXX_FLAGS " -DJS_RUNTIME_V8=1")
 else()
   message(FATAL_ERROR "Unknown JS runtime ${JS_RUNTIME}.")
 endif()
 
-# Resolves "CMake Warning: Manually-specified variables were not used by the
-# project" when any of the following variables is not used in some build
-# configuration.
-set(IGNORE_ME "${JS_RUNTIME_DIR}")
-
 set(BUILD_DIR "${CMAKE_SOURCE_DIR}/build")
 set(ANDROID_CPP_DIR "${CMAKE_SOURCE_DIR}/src/main/cpp")
 set(COMMON_CPP_DIR "${CMAKE_SOURCE_DIR}/../Common/cpp")
@@ -72,24 +64,20 @@ target_include_directories(worklets PUBLIC "${COMMON_CPP_DIR}"
 target_include_directories(
   worklets
   PRIVATE "${REACT_NATIVE_DIR}/ReactCommon"
+          "${REACT_NATIVE_DIR}/ReactCommon/yoga"
           "${REACT_NATIVE_DIR}/ReactAndroid/src/main/jni/react/turbomodule"
           "${REACT_NATIVE_DIR}/ReactCommon/react/nativemodule/core/ReactCommon"
           "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
-          "${REACT_NATIVE_DIR}/ReactCommon/runtimeexecutor")
-
-if(${IS_NEW_ARCHITECTURE_ENABLED})
-  target_include_directories(
-    worklets
-    PRIVATE
-      "${REACT_NATIVE_DIR}/ReactCommon/yoga"
-      "${REACT_NATIVE_DIR}/ReactCommon/react/renderer/graphics/platform/cxx")
-
-  if(ReactAndroid_VERSION_MINOR LESS 76)
-    target_link_libraries(
-      worklets ReactAndroid::fabricjni ReactAndroid::react_debug
-      ReactAndroid::react_render_core
-      ReactAndroid::react_render_componentregistry ReactAndroid::rrc_view)
-  endif()
+          "${REACT_NATIVE_DIR}/ReactCommon/runtimeexecutor"
+          "${REACT_NATIVE_DIR}/ReactCommon/jsiexecutor"
+          "${REACT_NATIVE_DIR}/ReactCommon/react/renderer/graphics/platform/cxx"
+)
+
+if(ReactAndroid_VERSION_MINOR LESS 76)
+  target_link_libraries(
+    worklets ReactAndroid::fabricjni ReactAndroid::react_debug
+    ReactAndroid::react_render_core
+    ReactAndroid::react_render_componentregistry ReactAndroid::rrc_view)
 endif()
 
 # build shared lib
@@ -122,14 +110,4 @@ elseif(${JS_RUNTIME} STREQUAL "jsc")
   else()
     target_link_libraries(worklets ReactAndroid::jscexecutor)
   endif()
-elseif(${JS_RUNTIME} STREQUAL "v8")
-  # TODO: Refactor this when adding support for newest V8
-  target_include_directories(worklets PRIVATE "${JS_RUNTIME_DIR}/src")
-  file(GLOB V8_SO_DIR "${JS_RUNTIME_DIR}/android/build/intermediates/\
-    library_jni/**/jni/${ANDROID_ABI}")
-  find_library(
-    V8EXECUTOR_LIB v8executor
-    PATHS ${V8_SO_DIR}
-    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
-  target_link_libraries(worklets ${V8EXECUTOR_LIB})
 endif()

package/android/build.gradle

@@ -72,6 +72,7 @@ def REACT_NATIVE_MINOR_VERSION = getReactNativeMinorVersion()
 def WORKLETS_VERSION = getWorkletsVersion()
 def IS_NEW_ARCHITECTURE_ENABLED = isNewArchitectureEnabled()
 def IS_REANIMATED_EXAMPLE_APP = safeAppExtGet("isReanimatedExampleApp", false)
+def BUNDLE_MODE = safeAppExtGet("workletsBundleMode", false)
 
 // Set version for prefab
 version WORKLETS_VERSION
@@ -84,12 +85,6 @@ def JS_RUNTIME = {
         return System.getenv("JS_RUNTIME")
     }
 
-    // Enable V8 runtime if react-native-v8 is installed
-    def v8Project = rootProject.getSubprojects().find { project -> project.name == "react-native-v8" }
-    if (v8Project != null) {
-        return "v8"
-    }
-
     // Check if Hermes is enabled in app setup
     def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
     if (appProject?.hermesEnabled?.toBoolean() || appProject?.ext?.react?.enableHermes?.toBoolean()) {
@@ -100,16 +95,6 @@ def JS_RUNTIME = {
     return "jsc"
 }.call()
 
-def jsRuntimeDir = {
-    if (JS_RUNTIME == "hermes") {
-        return Paths.get(reactNativeRootDir.path, "sdks", "hermes")
-    } else if (JS_RUNTIME == "v8") {
-        return findProject(":react-native-v8").getProjectDir().getParent()
-    } else {
-        return Paths.get(reactNativeRootDir.path, "ReactCommon", "jsi")
-    }
-}.call()
-
 def reactNativeArchitectures() {
     def value = project.getProperties().get("reactNativeArchitectures")
     return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
@@ -169,7 +154,7 @@ android {
         buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
         buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
         buildConfigField("int", "REACT_NATIVE_MINOR_VERSION", REACT_NATIVE_MINOR_VERSION.toString())
-        buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", IS_NEW_ARCHITECTURE_ENABLED.toString())
+        buildConfigField("boolean", "BUNDLE_MODE", BUNDLE_MODE.toString())
 
         externalNativeBuild {
             cmake {
@@ -178,9 +163,8 @@ android {
                         "-DANDROID_TOOLCHAIN=clang",
                         "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
                         "-DJS_RUNTIME=${JS_RUNTIME}",
-                        "-DJS_RUNTIME_DIR=${jsRuntimeDir}",
-                        "-DIS_NEW_ARCHITECTURE_ENABLED=${IS_NEW_ARCHITECTURE_ENABLED}",
                         "-DIS_REANIMATED_EXAMPLE_APP=${IS_REANIMATED_EXAMPLE_APP}",
+                        "-DWORKLETS_BUNDLE_MODE=${BUNDLE_MODE}",
                         "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
                 abiFilters (*reactNativeArchitectures())
                 targets("worklets")
@@ -243,7 +227,6 @@ android {
                 "**/libreact_render*.so",
                 "**/librrc_root.so",
                 "**/libjscexecutor.so",
-                "**/libv8executor.so",
         ]
     }
     compileOptions {
@@ -253,8 +236,10 @@ android {
     sourceSets {
         main {
             java {
-                if (!IS_NEW_ARCHITECTURE_ENABLED) {
-                    srcDirs += "src/worklets/paper"
+                if (BUNDLE_MODE) {
+                    srcDirs += "src/experimentalBundling"
+                } else {
+                    srcDirs += "src/legacyBundling"
                 }
             }
         }
@@ -288,6 +273,15 @@ task assertMinimalReactNativeVersionTask {
 
 preBuild.dependsOn(assertMinimalReactNativeVersionTask)
 
+task assertNewArchitectureEnabledTask {
+    onlyIf { !IS_NEW_ARCHITECTURE_ENABLED }
+    doFirst {
+        throw new GradleException("[Worklets] Worklets require new architecture to be enabled. Please enable it by setting `newArchEnabled` to `true` in `gradle.properties`.")
+    }
+}
+
+preBuild.dependsOn(assertNewArchitectureEnabledTask)
+
 task prepareWorkletsHeadersForPrefabs(type: Copy) {
     from("$projectDir/src/main/cpp")
     from("$projectDir/../Common/cpp")
@@ -319,14 +313,3 @@ dependencies {
 }
 
 preBuild.dependsOn(prepareWorkletsHeadersForPrefabs)
-
-afterEvaluate {
-    if (JS_RUNTIME == "v8") {
-        def buildTasks = tasks.findAll({ task ->
-            !task.name.contains("Clean") && (task.name.contains("externalNative") || task.name.contains("CMake") || task.name.startsWith("generateJsonModel")) })
-        buildTasks.forEach { task ->
-            def buildType = task.name.endsWith('Debug') ? 'Debug' : 'Release'
-            task.dependsOn(":react-native-v8:copy${buildType}JniLibsProjectOnly")
-        }
-    }
-}