react-native-worklets 0.8.0-rc.0 → 0.8.1

package/Common/cpp/worklets/Compat/StableApi.cpp

@@ -0,0 +1,121 @@
+#include <jsi/jsi.h>
+#include <worklets/Compat/Holders.h>
+#include <worklets/Compat/StableApi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Synchronizable.h>
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/WorkletRuntime/RuntimeHolder.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+
+namespace worklets {
+
+std::string JSIValueToStdString(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value) {
+  return worklets::stringifyJSIValue(rt, value);
+}
+
+void scheduleOnUI(const std::shared_ptr<UIScheduler> &uiScheduler, const std::function<void()> &job) {
+  uiScheduler->scheduleOnUI(job);
+}
+
+facebook::jsi::Runtime &getJSIRuntimeFromWorkletRuntime(const std::shared_ptr<WorkletRuntime> &workletRuntime) {
+  return workletRuntime->getJSIRuntime();
+}
+
+std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(jsi::Runtime &rt) {
+  return WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt);
+}
+
+std::shared_ptr<Serializable>
+extractSerializable(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value, const std::string &errorMessage) {
+  return extractSerializableOrThrow(rt, value, errorMessage);
+}
+
+std::shared_ptr<Serializable> extractSerializable(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Value &value,
+    const std::string &errorMessage,
+    const Serializable::ValueType expectedType) {
+  switch (expectedType) {
+    case Serializable::ValueType::WorkletType:
+      return extractSerializableOrThrow<SerializableWorklet>(rt, value, errorMessage);
+    case Serializable::ValueType::UndefinedType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::NullType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::BooleanType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::NumberType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::BigIntType:
+      return extractSerializableOrThrow<SerializableBigInt>(rt, value, errorMessage);
+    case Serializable::ValueType::StringType:
+      return extractSerializableOrThrow<SerializableString>(rt, value, errorMessage);
+    case Serializable::ValueType::ObjectType:
+      return extractSerializableOrThrow<SerializableObject>(rt, value, errorMessage);
+    case Serializable::ValueType::ArrayType:
+      return extractSerializableOrThrow<SerializableArray>(rt, value, errorMessage);
+    case Serializable::ValueType::MapType:
+      return extractSerializableOrThrow<SerializableMap>(rt, value, errorMessage);
+    case Serializable::ValueType::SetType:
+      return extractSerializableOrThrow<SerializableSet>(rt, value, errorMessage);
+    case Serializable::ValueType::RemoteFunctionType:
+      return extractSerializableOrThrow<SerializableRemoteFunction>(rt, value, errorMessage);
+    case Serializable::ValueType::HandleType:
+      return extractSerializableOrThrow<SerializableInitializer>(rt, value, errorMessage);
+    case Serializable::ValueType::HostObjectType:
+      return extractSerializableOrThrow<SerializableHostObject>(rt, value, errorMessage);
+    case Serializable::ValueType::HostFunctionType:
+      return extractSerializableOrThrow<SerializableHostFunction>(rt, value, errorMessage);
+    case Serializable::ValueType::ArrayBufferType:
+      return extractSerializableOrThrow<SerializableArrayBuffer>(rt, value, errorMessage);
+    case Serializable::ValueType::TurboModuleLikeType:
+      return extractSerializableOrThrow<SerializableTurboModuleLike>(rt, value, errorMessage);
+    case Serializable::ValueType::ImportType:
+      return extractSerializableOrThrow<SerializableImport>(rt, value, errorMessage);
+    case Serializable::ValueType::SynchronizableType:
+      return extractSerializableOrThrow<Synchronizable>(rt, value, errorMessage);
+    case Serializable::ValueType::CustomType:
+      return extractSerializableOrThrow<CustomSerializable>(rt, value, errorMessage);
+    case Serializable::ValueType::SymbolType:
+      throw std::runtime_error("[Worklets] Not implemented.");
+    case Serializable::ValueType::ShareableType:
+      throw std::runtime_error("[Worklets] Not implemented.");
+    default:
+      throw std::runtime_error("[Worklets] Invalid expected type provided to extractSerializable.");
+  }
+}
+
+void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet) {
+  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet));
+}
+
+void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0) {
+  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet), arg0);
+}
+
+void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0,
+    const facebook::jsi::Value &arg1) {
+  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet), arg0, arg1);
+}
+
+std::shared_ptr<WorkletRuntime> getWorkletRuntimeFromHolder(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object) {
+  return object.getNativeState<WorkletRuntimeHolder>(rt)->runtime_;
+}
+
+std::shared_ptr<UIScheduler> getUISchedulerFromHolder(facebook::jsi::Runtime &rt, const facebook::jsi::Object &object) {
+  return object.getNativeState<UISchedulerHolder>(rt)->scheduler_;
+}
+
+} // namespace worklets

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

@@ -0,0 +1,109 @@
+#pragma once
+
+/** 
+* Version of `react-native-worklets` which introduced current stable API.
+* It can be used by libraries to verify they use a compatible version
+* of `react-native-worklets` installed when integrating in C++. 
+*/
+#define WORKLETS_STABLE_API_VERSION "0.8.0"
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace facebook::jsi {
+class Runtime;
+class Value;
+class Object;
+} // namespace facebook::jsi
+
+namespace worklets {
+
+class WorkletRuntime;
+class UIScheduler;
+
+class Serializable {
+ public:
+  virtual facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) = 0;
+
+  virtual ~Serializable();
+
+  enum class ValueType : std::uint8_t {
+    UndefinedType,
+    NullType,
+    BooleanType,
+    NumberType,
+    BigIntType,
+    StringType,
+    ObjectType,
+    ArrayType,
+    MapType,
+    SetType,
+    WorkletType,
+    RemoteFunctionType,
+    HandleType,
+    HostObjectType,
+    HostFunctionType,
+    ArrayBufferType,
+    TurboModuleLikeType,
+    ImportType,
+    SynchronizableType,
+    CustomType,
+    SymbolType, /* unused */
+    ShareableType
+  };
+
+  explicit Serializable(ValueType valueType) : valueType_(valueType) {}
+
+  inline ValueType valueType() const {
+    return valueType_;
+  }
+
+  static std::shared_ptr<Serializable> undefined();
+
+ protected:
+  ValueType valueType_;
+};
+
+extern std::shared_ptr<WorkletRuntime> getWorkletRuntimeFromHolder(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object);
+
+extern std::shared_ptr<UIScheduler> getUISchedulerFromHolder(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object);
+
+extern facebook::jsi::Runtime &getJSIRuntimeFromWorkletRuntime(const std::shared_ptr<WorkletRuntime> &workletRuntime);
+
+extern std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(facebook::jsi::Runtime &rt);
+
+extern void scheduleOnUI(const std::shared_ptr<UIScheduler> &uiScheduler, const std::function<void()> &job);
+
+extern std::string JSIValueToStdString(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value);
+
+extern std::shared_ptr<Serializable>
+extractSerializable(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value, const std::string &errorMessage);
+
+extern std::shared_ptr<Serializable> extractSerializable(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Value &value,
+    const std::string &errorMessage,
+    const Serializable::ValueType expectedType);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0,
+    const facebook::jsi::Value &arg1);
+
+} // namespace worklets

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.cpp

@@ -2,6 +2,7 @@
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
 #include <worklets/Compat/Holders.h>
+#include <worklets/Compat/StableApi.h>
 #include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
 #include <worklets/NativeModules/WorkletsModuleProxy.h>
 #include <worklets/SharedItems/Serializable.h>
@@ -11,6 +12,7 @@
 #include <worklets/Tools/Defs.h>
 #include <worklets/Tools/FeatureFlags.h>
 #include <worklets/Tools/JSLogger.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
 
 #include <memory>
@@ -86,14 +88,13 @@ inline jsi::Value createWorkletRuntime(
   return jsi::Object::createFromHostObject(originRuntime, workletRuntime);
 }
 
-#ifdef WORKLETS_BUNDLE_MODE_ENABLED
 inline jsi::Value propagateModuleUpdate(
     const std::shared_ptr<RuntimeManager> &runtimeManager,
     const std::string &code,
     const std::string &sourceUrl) {
   const auto runtimes = runtimeManager->getAllRuntimes();
 
-  for (auto runtime : runtimes) {
+  for (const auto &runtime : runtimes) {
     runtime->runSync([code, sourceUrl](jsi::Runtime &rt) -> void {
       const auto buffer = std::make_shared<jsi::StringBuffer>(code);
       rt.evaluateJavaScript(buffer, sourceUrl);
@@ -101,7 +102,6 @@ inline jsi::Value propagateModuleUpdate(
   }
   return jsi::Value::undefined();
 }
-#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
 inline jsi::Value reportFatalErrorOnJS(
     const std::shared_ptr<JSScheduler> &jsScheduler,
@@ -151,19 +151,17 @@ inline void registerCustomSerializable(
 
 JSIWorkletsModuleProxy::JSIWorkletsModuleProxy(
     const bool isDevBundle,
-    const std::shared_ptr<const ScriptBuffer> &script,
-    const std::string &sourceUrl,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::shared_ptr<UIScheduler> &uiScheduler,
     const std::shared_ptr<MemoryManager> &memoryManager,
     const std::shared_ptr<RuntimeManager> &runtimeManager,
     const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
-    const std::shared_ptr<RuntimeBindings> &runtimeBindings)
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+    const BundleModeConfig &bundleModeConfig)
     : jsi::HostObject(),
       isDevBundle_(isDevBundle),
-      script_(script),
-      sourceUrl_(sourceUrl),
+      bundleModeConfig_(bundleModeConfig),
       jsQueue_(jsQueue),
       jsScheduler_(jsScheduler),
       uiScheduler_(uiScheduler),
@@ -218,9 +216,7 @@ std::vector<jsi::PropNameID> JSIWorkletsModuleProxy::getPropertyNames(jsi::Runti
 
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "createShareable"));
 
-#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "propagateModuleUpdate"));
-#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "getUIRuntimeHolder"));
   propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "getUISchedulerHolder"));
@@ -578,7 +574,6 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
         });
   }
 
-#ifdef WORKLETS_BUNDLE_MODE_ENABLED
   if (name == "propagateModuleUpdate") {
     return jsi::Function::createFromHostFunction(
         rt,
@@ -592,7 +587,6 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
               /* sourceURL */ args[1].asString(rt).utf8(rt));
         });
   }
-#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   if (name == "getStaticFeatureFlag") {
     return jsi::Function::createFromHostFunction(
@@ -619,8 +613,13 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
         0,
         [uiWorkletRuntime = uiWorkletRuntime_](
             jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+          const auto strongUIWorkletRuntime = uiWorkletRuntime.lock();
+          if (!strongUIWorkletRuntime) {
+            throw jsi::JSError(rt, "[Worklets] UI Worklet Runtime is not available.");
+          }
+          auto nativeState = std::make_shared<WorkletRuntimeHolder>(strongUIWorkletRuntime);
           auto obj = jsi::Object(rt);
-          obj.setNativeState(rt, std::make_shared<WorkletRuntimeHolder>(uiWorkletRuntime.lock()));
+          obj.setNativeState(rt, std::move(nativeState));
           return obj;
         });
   }
@@ -632,8 +631,9 @@ jsi::Value JSIWorkletsModuleProxy::get(jsi::Runtime &rt, const jsi::PropNameID &
         0,
         [uiScheduler = uiScheduler_](
             jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+          auto nativeState = std::make_shared<UISchedulerHolder>(uiScheduler);
           auto obj = jsi::Object(rt);
-          obj.setNativeState(rt, std::make_shared<UISchedulerHolder>(uiScheduler));
+          obj.setNativeState(rt, std::move(nativeState));
           return obj;
         });
   }

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

@@ -8,6 +8,7 @@
 #include <worklets/SharedItems/Serializable.h>
 #include <worklets/Tools/Defs.h>
 #include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/RuntimeManager.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
@@ -26,15 +27,14 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
  public:
   explicit JSIWorkletsModuleProxy(
       const bool isDevBundle,
-      const std::shared_ptr<const ScriptBuffer> &script,
-      const std::string &sourceUrl,
       const std::shared_ptr<MessageQueueThread> &jsQueue,
       const std::shared_ptr<JSScheduler> &jsScheduler,
       const std::shared_ptr<UIScheduler> &uiScheduler,
       const std::shared_ptr<MemoryManager> &memoryManager,
       const std::shared_ptr<RuntimeManager> &runtimeManager,
       const std::weak_ptr<WorkletRuntime> &uiWorkletRuntime,
-      const std::shared_ptr<RuntimeBindings> &runtimeBindings);
+      const std::shared_ptr<RuntimeBindings> &runtimeBindings,
+      const BundleModeConfig &bundleModeConfig);
 
   JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other) = default;
 
@@ -56,16 +56,20 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
     return uiScheduler_;
   }
 
+  [[nodiscard]] bool isBundleModeEnabled() const {
+    return bundleModeConfig_.enabled;
+  }
+
   [[nodiscard]] bool isDevBundle() const {
     return isDevBundle_;
   }
 
   [[nodiscard]] std::shared_ptr<const ScriptBuffer> getScript() const {
-    return script_;
+    return bundleModeConfig_.script;
   }
 
   [[nodiscard]] std::string getSourceUrl() const {
-    return sourceUrl_;
+    return bundleModeConfig_.sourceURL;
   }
 
   [[nodiscard]] std::shared_ptr<MemoryManager> getMemoryManager() const {
@@ -82,8 +86,7 @@ class JSIWorkletsModuleProxy : public jsi::HostObject {
 
  private:
   const bool isDevBundle_;
-  const std::shared_ptr<const ScriptBuffer> script_;
-  const std::string sourceUrl_;
+  const BundleModeConfig bundleModeConfig_;
   const std::shared_ptr<MessageQueueThread> jsQueue_;
   const std::shared_ptr<JSScheduler> jsScheduler_;
   const std::shared_ptr<UIScheduler> uiScheduler_;

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

@@ -1,6 +1,5 @@
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
-
 #include <worklets/NativeModules/WorkletsModuleProxy.h>
 #include <worklets/RunLoop/AsyncQueueImpl.h>
 #include <worklets/SharedItems/Serializable.h>
@@ -9,19 +8,14 @@
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
 
-#ifdef __ANDROID__
-#include <fbjni/fbjni.h>
-#endif // __ANDROID__
-
 #include <memory>
-#include <string>
 #include <utility>
 
 using namespace facebook;
 
 namespace worklets {
 
-auto isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) -> bool;
+bool isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime);
 
 WorkletsModuleProxy::WorkletsModuleProxy(
     jsi::Runtime &rnRuntime,
@@ -30,16 +24,14 @@ WorkletsModuleProxy::WorkletsModuleProxy(
     const std::shared_ptr<UIScheduler> &uiScheduler,
     std::function<bool()> &&isJavaScriptThread,
     const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-    const std::shared_ptr<const ScriptBuffer> &script,
-    const std::string &sourceUrl)
+    const BundleModeConfig &bundleModeConfig)
     : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
       jsQueue_(jsQueue),
       jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker, std::move(isJavaScriptThread))),
       uiScheduler_(uiScheduler),
       jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
       runtimeBindings_(runtimeBindings),
-      script_(script),
-      sourceUrl_(sourceUrl),
+      bundleModeConfig_(bundleModeConfig),
       memoryManager_(std::make_shared<MemoryManager>()),
       runtimeManager_(std::make_shared<RuntimeManager>()),
       uiWorkletRuntime_(
@@ -61,15 +53,14 @@ std::shared_ptr<JSIWorkletsModuleProxy> WorkletsModuleProxy::createJSIWorkletsMo
   assert(uiWorkletRuntime_ && "UI Worklet Runtime must be initialized before creating JSI proxy.");
   return std::make_shared<JSIWorkletsModuleProxy>(
       isDevBundle_,
-      script_,
-      sourceUrl_,
       jsQueue_,
       jsScheduler_,
       uiScheduler_,
       memoryManager_,
       runtimeManager_,
       uiWorkletRuntime_,
-      runtimeBindings_);
+      runtimeBindings_,
+      bundleModeConfig_);
 }
 
 WorkletsModuleProxy::~WorkletsModuleProxy() {

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

@@ -12,11 +12,11 @@
 #include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/Tools/SingleInstanceChecker.h>
 #include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeManager.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
-#include <string>
 
 namespace worklets {
 
@@ -29,8 +29,7 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
       const std::shared_ptr<UIScheduler> &uiScheduler,
       std::function<bool()> &&isJavaScriptQueue,
       const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-      const std::shared_ptr<const ScriptBuffer> &script,
-      const std::string &sourceUrl);
+      const BundleModeConfig &bundleModeConfig);
 
   ~WorkletsModuleProxy();
 
@@ -67,8 +66,7 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
   const std::shared_ptr<UIScheduler> uiScheduler_;
   const std::shared_ptr<JSLogger> jsLogger_;
   const std::shared_ptr<RuntimeBindings> runtimeBindings_;
-  const std::shared_ptr<const ScriptBuffer> script_;
-  const std::string sourceUrl_;
+  const BundleModeConfig bundleModeConfig_;
   const std::shared_ptr<MemoryManager> memoryManager_;
   const std::shared_ptr<RuntimeManager> runtimeManager_;
   std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;

package/Common/cpp/worklets/SharedItems/Serializable.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <worklets/Compat/StableApi.h>
 #include <worklets/Registries/WorkletRuntimeRegistry.h>
 
 #include <jsi/jsi.h>
@@ -39,49 +40,6 @@ inline void cleanupIfRuntimeExists(jsi::Runtime *rt, std::unique_ptr<jsi::Value>
   }
 }
 
-class Serializable {
- public:
-  virtual jsi::Value toJSValue(jsi::Runtime &rt) = 0;
-
-  virtual ~Serializable();
-
-  enum class ValueType : std::uint8_t {
-    UndefinedType,
-    NullType,
-    BooleanType,
-    NumberType,
-    BigIntType,
-    StringType,
-    ObjectType,
-    ArrayType,
-    MapType,
-    SetType,
-    WorkletType,
-    RemoteFunctionType,
-    HandleType,
-    HostObjectType,
-    HostFunctionType,
-    ArrayBufferType,
-    TurboModuleLikeType,
-    ImportType,
-    SynchronizableType,
-    CustomType,
-    SymbolType, /* unused */
-    ShareableType,
-  };
-
-  explicit Serializable(ValueType valueType) : valueType_(valueType) {}
-
-  inline ValueType valueType() const {
-    return valueType_;
-  }
-
-  static std::shared_ptr<Serializable> undefined();
-
- protected:
-  ValueType valueType_;
-};
-
 template <typename BaseClass>
 class RetainingSerializable : virtual public BaseClass {
  private:

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

@@ -1,15 +1,10 @@
 #pragma once
 
-/*
-On Android JS_RUNTIME_HERMES is set in CMakeList.txt,
-but on iOS there is no simple way to defect if Hermes exists
-so we have to check if headers are available.
-*/
 #if __APPLE__ && __has_include(<hermes/hermes.h>)
 #define JS_RUNTIME_HERMES 1
 #endif
 
-#if REACT_NATIVE_MINOR_VERSION >= 84 || defined(WORKLETS_BUNDLE_MODE_ENABLED)
+#if REACT_NATIVE_MINOR_VERSION >= 84
 #include <cxxreact/JSBigString.h>
 namespace worklets {
 using JSBigStringBuffer = facebook::react::JSBigString;
@@ -19,4 +14,4 @@ using JSBigStringBuffer = facebook::react::JSBigString;
 namespace worklets {
 using JSBigStringBuffer = facebook::react::BigStringBuffer;
 }
-#endif // REACT_NATIVE_MINOR_VERSION >= 84 || defined(WORKLETS_BUNDLE_MODE_ENABLED)
+#endif // REACT_NATIVE_MINOR_VERSION >= 84

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

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <cxxreact/JSBigString.h>
 #include <jsi/jsi.h>
+#include <worklets/Tools/Defs.h>
 
 #include <memory>
 #include <utility>

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/ScriptBuffer.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+struct BundleModeConfig {
+  bool enabled;
+  std::shared_ptr<const ScriptBuffer> script;
+  std::string sourceURL;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,73 @@
+#include <worklets/Tools/Defs.h>
+#include <worklets/WorkletRuntime/HermesProfiling.h>
+
+#include <string>
+
+#if JS_RUNTIME_HERMES
+#include <hermes/hermes.h>
+
+#include <chrono>
+#include <filesystem>
+#include <sstream>
+#endif
+
+namespace worklets {
+
+#if JS_RUNTIME_HERMES
+static std::string generateUniqueProfilePath() {
+  auto now = std::chrono::steady_clock::now().time_since_epoch().count();
+  std::ostringstream oss;
+  oss << "profile-" << now << ".cpuprofile";
+  std::filesystem::path dir = std::filesystem::temp_directory_path();
+  return (dir / oss.str()).string();
+}
+#endif
+
+void startProfiling(facebook::jsi::Runtime &rt, double meanHzFreq) {
+#if JS_RUNTIME_HERMES
+#if REACT_NATIVE_MINOR_VERSION >= 81
+  auto *ihermes = facebook::jsi::castInterface<facebook::hermes::IHermes>(&rt);
+  if (ihermes) {
+    ihermes->registerForProfiling();
+  }
+  auto *api = facebook::jsi::castInterface<facebook::hermes::IHermesRootAPI>(facebook::hermes::makeHermesRootAPI());
+  if (api) {
+    api->enableSamplingProfiler(meanHzFreq);
+  }
+#else
+  (void)rt;
+  (void)meanHzFreq;
+  facebook::hermes::HermesRuntime::enableSamplingProfiler();
+#endif
+#else
+  (void)rt;
+  (void)meanHzFreq;
+#endif
+}
+
+std::string stopProfiling(facebook::jsi::Runtime &rt) {
+#if JS_RUNTIME_HERMES
+  std::string path = generateUniqueProfilePath();
+#if REACT_NATIVE_MINOR_VERSION >= 81
+  auto *api = facebook::jsi::castInterface<facebook::hermes::IHermesRootAPI>(facebook::hermes::makeHermesRootAPI());
+  if (api) {
+    api->dumpSampledTraceToFile(path);
+    api->disableSamplingProfiler();
+  }
+  auto *ihermes = facebook::jsi::castInterface<facebook::hermes::IHermes>(&rt);
+  if (ihermes) {
+    ihermes->unregisterForProfiling();
+  }
+#else
+  (void)rt;
+  facebook::hermes::HermesRuntime::dumpSampledTraceToFile(path);
+  facebook::hermes::HermesRuntime::disableSamplingProfiler();
+#endif
+  return path;
+#else
+  (void)rt;
+  return {};
+#endif
+}
+
+} // namespace worklets