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

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

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Compat/StableApi.h>
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/WorkletsSystraceSection.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+
+#include <array>
+#include <atomic>
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace worklets {
+
+template <typename TSerializable>
+  requires std::is_base_of_v<Serializable, TSerializable>
+class RetainingSerializableStore {
+ private:
+  static constexpr std::size_t kSlotsPerChunk = 4;
+
+  struct Slot {
+    std::atomic<facebook::jsi::Runtime *> runtime{nullptr};
+    facebook::jsi::Value value{facebook::jsi::Value::undefined()};
+  };
+
+  std::array<Slot, kSlotsPerChunk> slots_{};
+
+  std::atomic<RetainingSerializableStore *> nextChunk_{nullptr};
+  std::unique_ptr<RetainingSerializableStore> nextChunkOwner_{};
+
+  const facebook::jsi::Value *find(facebook::jsi::Runtime *rt) {
+    for (auto &slot : slots_) {
+      if (slot.runtime.load(std::memory_order_acquire) == rt) {
+        return &slot.value;
+      }
+    }
+    if (auto *next = nextChunk_.load(std::memory_order_acquire)) {
+      return next->find(rt);
+    }
+    return nullptr;
+  }
+
+  void store(facebook::jsi::Runtime *rt, facebook::jsi::Value value) {
+    for (auto &slot : slots_) {
+      if (slot.runtime.load(std::memory_order_relaxed) != nullptr) {
+        continue;
+      }
+      facebook::jsi::Runtime *expected = nullptr;
+      if (slot.runtime.compare_exchange_strong(expected, rt, std::memory_order_acq_rel)) {
+        slot.value = std::move(value);
+        return;
+      }
+    }
+
+    auto *next = nextChunk_.load(std::memory_order_acquire);
+    if (next == nullptr) {
+      auto fresh = std::make_unique<RetainingSerializableStore>();
+      auto *freshChunk = fresh.get();
+      if (nextChunk_.compare_exchange_strong(next, freshChunk, std::memory_order_acq_rel)) {
+        nextChunkOwner_ = std::move(fresh);
+        next = freshChunk;
+      }
+    }
+    next->store(rt, std::move(value));
+  }
+
+ public:
+  RetainingSerializableStore() = default;
+
+  ~RetainingSerializableStore() {
+    for (auto &slot : slots_) {
+      cleanupRuntimeAware(slot.runtime.load(std::memory_order_relaxed), slot.value);
+    }
+  }
+
+  facebook::jsi::Value getOrStore(facebook::jsi::Runtime &rt, TSerializable &serializable) {
+    if (const auto *cachedValue = find(&rt)) {
+      return facebook::jsi::Value(rt, *cachedValue);
+    }
+
+    auto jsValue = serializable.TSerializable::toJSValue(rt);
+    store(&rt, facebook::jsi::Value(rt, jsValue));
+
+    return jsValue;
+  }
+};
+
+template <typename TSerializable>
+  requires std::is_base_of_v<Serializable, TSerializable>
+class RetainingSerializable : virtual public TSerializable {
+ private:
+  std::unique_ptr<RetainingSerializableStore<TSerializable>> store_{
+      std::make_unique<RetainingSerializableStore<TSerializable>>()};
+
+ public:
+  template <typename... Args>
+  explicit RetainingSerializable(facebook::jsi::Runtime &rt, Args &&...args)
+      : TSerializable(rt, std::forward<Args>(args)...) {}
+
+  ~RetainingSerializable() override = default;
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override {
+    return store_->getOrStore(rt, *this);
+  }
+};
+
+} // namespace worklets

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

@@ -0,0 +1,129 @@
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable/RetainingSerializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+#include <worklets/SharedItems/Serializable/SerializableArray.h>
+#include <worklets/SharedItems/Serializable/SerializableArrayBuffer.h>
+#include <worklets/SharedItems/Serializable/SerializableBigInt.h>
+#include <worklets/SharedItems/Serializable/SerializableHostFunction.h>
+#include <worklets/SharedItems/Serializable/SerializableHostObject.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+#include <worklets/SharedItems/Serializable/SerializableScalar.h>
+#include <worklets/SharedItems/Serializable/SerializableString.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Function getValueUnpacker(jsi::Runtime &rt) {
+  auto valueUnpacker = rt.global().getProperty(rt, "__valueUnpacker");
+  react_native_assert(valueUnpacker.isObject() && "valueUnpacker not found");
+  return valueUnpacker.asObject(rt).asFunction(rt);
+}
+
+jsi::Value makeSerializableClone(
+    jsi::Runtime &rt,
+    const jsi::Value &value,
+    const jsi::Value &shouldRetainRemote,
+    const jsi::Value &nativeStateSource) {
+  std::shared_ptr<Serializable> serializable;
+  if (value.isObject()) {
+    auto object = value.asObject(rt);
+    if (!object.getProperty(rt, "__workletHash").isUndefined()) {
+      // We pass `false` because this function is invoked only
+      // by `makeSerializableCloneOnUIRecursive` which doesn't
+      // make Retaining Serializables.
+      return makeSerializableWorklet(rt, object, false);
+    } else if (object.isFunction(rt)) {
+      auto fun = object.asFunction(rt);
+      if (fun.isHostFunction(rt)) {
+        auto name = fun.getProperty(rt, "name").asString(rt).utf8(rt);
+        return makeSerializableHostFunction(
+            rt, fun.getHostFunction(rt), name, fun.getProperty(rt, "length").asNumber());
+      } else {
+        throw std::runtime_error(
+            "[Worklets] Cloning remote functions from Worklet Runtimes is only available in Bundle Mode.");
+      }
+    } else if (object.isArray(rt)) {
+      if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
+        serializable = std::make_shared<RetainingSerializable<SerializableArray>>(rt, object.asArray(rt));
+      } else {
+        serializable = std::make_shared<SerializableArray>(rt, object.asArray(rt));
+      }
+    } else if (object.isArrayBuffer(rt)) {
+      serializable = std::make_shared<SerializableArrayBuffer>(rt, object.getArrayBuffer(rt));
+    } else if (object.isHostObject(rt)) {
+      if (object.isHostObject<SerializableJSRef>(rt)) {
+        return object;
+      }
+      serializable = std::make_shared<SerializableHostObject>(rt, object.getHostObject(rt));
+    } else {
+      if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
+        serializable = std::make_shared<RetainingSerializable<SerializableObject>>(rt, object, nativeStateSource);
+      } else {
+        serializable = std::make_shared<SerializableObject>(rt, object, nativeStateSource);
+      }
+    }
+  } else if (value.isString()) {
+    serializable = std::make_shared<SerializableString>(value.asString(rt).utf8(rt));
+  } else if (value.isUndefined()) {
+    serializable = std::make_shared<SerializableScalar>();
+  } else if (value.isNull()) {
+    serializable = std::make_shared<SerializableScalar>(nullptr);
+  } else if (value.isBool()) {
+    serializable = std::make_shared<SerializableScalar>(value.getBool());
+  } else if (value.isNumber()) {
+    serializable = std::make_shared<SerializableScalar>(value.getNumber());
+  } else if (value.isBigInt()) {
+    serializable = std::make_shared<SerializableBigInt>(rt, value.getBigInt(rt));
+  } else if (value.isSymbol()) {
+    // TODO: this is only a placeholder implementation, here we replace symbols
+    // with strings in order to make certain objects to be captured. There isn't
+    // yet any use-case for using symbols on the UI runtime so it is fine to keep
+    // it like this for now.
+    serializable = std::make_shared<SerializableString>(value.getSymbol(rt).toString(rt));
+  } else {
+    throw std::runtime_error("[Worklets] Attempted to convert an unsupported value type.");
+  }
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+std::shared_ptr<Serializable> extractSerializableOrThrow(
+    jsi::Runtime &rt,
+    const jsi::Value &maybeSerializableValue,
+    const std::string &errorMessage) {
+  if (maybeSerializableValue.isObject()) {
+    auto object = maybeSerializableValue.getObject(rt);
+    return extractSerializableOrThrow(rt, object, errorMessage);
+  } else if (maybeSerializableValue.isUndefined()) {
+    return Serializable::undefined();
+  }
+  throw std::runtime_error(errorMessage);
+}
+
+std::shared_ptr<Serializable> extractSerializableOrThrow(
+    jsi::Runtime &rt,
+    const jsi::Object &maybeSerializableValue,
+    const std::string &errorMessage) {
+  if (maybeSerializableValue.hasNativeState(rt)) {
+    auto nativeState = maybeSerializableValue.getNativeState(rt);
+    return std::dynamic_pointer_cast<SerializableJSRef>(nativeState)->value();
+  }
+  throw std::runtime_error(errorMessage);
+}
+
+Serializable::~Serializable() = default;
+
+std::shared_ptr<Serializable> Serializable::undefined() {
+  static auto undefined = std::make_shared<SerializableScalar>();
+  return undefined;
+}
+
+SerializableJSRef::~SerializableJSRef() = default;
+
+} // namespace worklets

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

@@ -0,0 +1,121 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Compat/StableApi.h>
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+#include <memory>
+#include <new>
+#include <stdexcept>
+#include <string>
+
+namespace worklets {
+
+// Frees the heap-allocated facebook::jsi::Value wrapper without running ~facebook::jsi::Value.
+// Use when the runtime that owns the JSI handle is already gone. When the
+// owning runtime is terminated, the orphaned JSI objects would crash the app
+// if their destructors ran, because they call into memory managed by the
+// terminated runtime. The JS object itself lived inside the runtime's heap
+// and was reclaimed with the runtime; only the C++ wrapper allocation
+// remains, and we free it here without invoking ~facebook::jsi::Value.
+// See https://github.com/facebook/hermes/blob/75b617a/API/jsi/jsi/jsi.h#L833
+inline void freeWithoutCallingDestructor(std::unique_ptr<facebook::jsi::Value> &value) {
+  ::operator delete(value.release());
+}
+
+inline void cleanupRuntimeAware(facebook::jsi::Runtime *rt, std::unique_ptr<facebook::jsi::Value> &value) {
+  if (value == nullptr || rt == nullptr) {
+    return;
+  }
+  WorkletRuntimeRegistry::runWhileLocked(rt, [&value](bool isAlive) {
+    if (isAlive) {
+      value.reset();
+    } else {
+      freeWithoutCallingDestructor(value);
+    }
+  });
+}
+
+inline void cleanupRuntimeAware(facebook::jsi::Runtime *rt, facebook::jsi::Value &value) {
+  if (rt == nullptr || value.isUndefined()) {
+    return;
+  }
+  WorkletRuntimeRegistry::runWhileLocked(rt, [&value](bool isAlive) {
+    if (isAlive) {
+      value.~Value();
+    }
+    new (&value) facebook::jsi::Value(facebook::jsi::Value::undefined());
+  });
+}
+
+class SerializableJSRef : public facebook::jsi::NativeState {
+ private:
+  const std::shared_ptr<Serializable> value_;
+
+ public:
+  explicit SerializableJSRef(const std::shared_ptr<Serializable> &value) : value_(value) {}
+
+  ~SerializableJSRef() override;
+
+  std::shared_ptr<Serializable> value() const {
+    return value_;
+  }
+
+  static facebook::jsi::Object newNativeStateObject(
+      facebook::jsi::Runtime &rt,
+      const std::shared_ptr<Serializable> &value) {
+    auto object = facebook::jsi::Object(rt);
+    object.setNativeState(rt, std::make_shared<SerializableJSRef>(value));
+    object.setProperty(rt, "__serializableRef", true);
+    return object;
+  }
+};
+
+facebook::jsi::Function getValueUnpacker(facebook::jsi::Runtime &rt);
+
+[[nodiscard]]
+facebook::jsi::Value makeSerializableClone(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Value &value,
+    const facebook::jsi::Value &shouldRetainRemote,
+    const facebook::jsi::Value &nativeStateSource);
+
+[[nodiscard]]
+std::shared_ptr<Serializable> extractSerializableOrThrow(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Value &maybeSerializableValue,
+    const std::string &errorMessage = "[Worklets] Expecting the object to be of type SerializableJSRef.");
+
+[[nodiscard]]
+std::shared_ptr<Serializable> extractSerializableOrThrow(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &maybeSerializableValue,
+    const std::string &errorMessage = "[Worklets] Expecting the object to be of type SerializableJSRef.");
+
+template <typename TSerializable>
+[[nodiscard]]
+std::shared_ptr<TSerializable> extractSerializableOrThrow(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Value &serializableRef,
+    const std::string &errorMessage = "[Worklets] Provided serializable object is of an incompatible type.") {
+  auto res = std::dynamic_pointer_cast<TSerializable>(extractSerializableOrThrow(rt, serializableRef, errorMessage));
+  if (!res) {
+    throw std::runtime_error(errorMessage);
+  }
+  return res;
+}
+
+template <typename TSerializable>
+[[nodiscard]]
+std::shared_ptr<TSerializable> extractSerializableOrThrow(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &serializableRef,
+    const std::string &errorMessage = "[Worklets] Provided serializable object is of an incompatible type.") {
+  auto res = std::dynamic_pointer_cast<TSerializable>(extractSerializableOrThrow(rt, serializableRef, errorMessage));
+  if (!res) {
+    throw std::runtime_error(errorMessage);
+  }
+  return res;
+}
+
+} // namespace worklets

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

@@ -0,0 +1,38 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/RetainingSerializable.h>
+#include <worklets/SharedItems/Serializable/SerializableArray.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+SerializableArray::SerializableArray(jsi::Runtime &rt, const jsi::Array &array) : Serializable(ValueType::ArrayType) {
+  auto size = array.size(rt);
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    data_.push_back(extractSerializableOrThrow(rt, array.getValueAtIndex(rt, i)));
+  }
+}
+
+jsi::Value SerializableArray::toJSValue(jsi::Runtime &rt) {
+  auto size = data_.size();
+  auto ary = jsi::Array(rt, size);
+  for (size_t i = 0; i < size; i++) {
+    ary.setValueAtIndex(rt, i, data_[i]->toJSValue(rt));
+  }
+  return ary;
+}
+
+jsi::Value makeSerializableArray(jsi::Runtime &rt, const jsi::Array &array, const jsi::Value &shouldRetainRemote) {
+  std::shared_ptr<Serializable> serializable;
+  if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
+    serializable = std::make_shared<RetainingSerializable<SerializableArray>>(rt, array);
+  } else {
+    serializable = std::make_shared<SerializableArray>(rt, array);
+  }
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <memory>
+#include <vector>
+
+namespace worklets {
+
+class SerializableArray : public Serializable {
+ public:
+  SerializableArray(facebook::jsi::Runtime &rt, const facebook::jsi::Array &array);
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+  std::vector<facebook::jsi::Value> getJSIValueArr(facebook::jsi::Runtime &rt) {
+    std::vector<facebook::jsi::Value> args;
+    args.reserve(data_.size());
+    for (const auto &item : data_) {
+      args.push_back(item->toJSValue(rt));
+    }
+    return args;
+  }
+
+  [[nodiscard]] const std::vector<std::shared_ptr<Serializable>> &getList() const {
+    return data_;
+  }
+
+ protected:
+  std::vector<std::shared_ptr<Serializable>> data_;
+};
+
+facebook::jsi::Value makeSerializableArray(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Array &array,
+    const facebook::jsi::Value &shouldRetainRemote);
+
+} // namespace worklets

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

@@ -0,0 +1,35 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableArrayBuffer.h>
+
+#include <cstring>
+#include <memory>
+#include <optional>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableArrayBuffer::toJSValue(jsi::Runtime &rt) {
+  auto size = static_cast<int>(data_.size());
+  auto arrayBuffer =
+      rt.global().getPropertyAsFunction(rt, "ArrayBuffer").callAsConstructor(rt, size).getObject(rt).getArrayBuffer(rt);
+  memcpy(arrayBuffer.data(rt), data_.data(), size);
+  if (!metadata_.has_value()) {
+    return arrayBuffer;
+  }
+
+  auto constructor = rt.global().getPropertyAsFunction(rt, metadata_->typeName.c_str());
+  return constructor.callAsConstructor(
+      rt, arrayBuffer, static_cast<double>(metadata_->byteOffset), static_cast<double>(metadata_->length));
+}
+
+jsi::Value makeSerializableArrayBuffer(
+    jsi::Runtime &rt,
+    const jsi::ArrayBuffer &arrayBuffer,
+    std::optional<ArrayBufferMetadata> metadata) {
+  auto serializable = std::make_shared<SerializableArrayBuffer>(rt, arrayBuffer, std::move(metadata));
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+struct ArrayBufferMetadata {
+  std::string typeName;
+  size_t byteOffset;
+  size_t length;
+};
+
+class SerializableArrayBuffer : public Serializable {
+ public:
+  SerializableArrayBuffer(
+      facebook::jsi::Runtime &rt,
+      const facebook::jsi::ArrayBuffer &arrayBuffer,
+      std::optional<ArrayBufferMetadata> metadata = std::nullopt)
+      : Serializable(ValueType::ArrayBufferType),
+        metadata_(std::move(metadata)),
+        data_(arrayBuffer.data(rt), arrayBuffer.data(rt) + arrayBuffer.size(rt)) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  std::optional<ArrayBufferMetadata> metadata_;
+  std::vector<uint8_t> data_;
+};
+
+facebook::jsi::Value makeSerializableArrayBuffer(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::ArrayBuffer &arrayBuffer,
+    std::optional<ArrayBufferMetadata> metadata = std::nullopt);
+
+} // namespace worklets

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

@@ -0,0 +1,23 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableBigInt.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableBigInt::toJSValue(jsi::Runtime &rt) {
+  if (fastValue_.has_value()) {
+    return jsi::BigInt::fromInt64(rt, fastValue_.value());
+  } else {
+    return rt.global().getPropertyAsFunction(rt, "BigInt").call(rt, jsi::String::createFromUtf8(rt, slowValue_));
+  }
+}
+
+jsi::Value makeSerializableBigInt(jsi::Runtime &rt, const jsi::BigInt &bigint) {
+  const auto serializable = std::make_shared<SerializableBigInt>(rt, bigint);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace worklets {
+
+class SerializableBigInt : public Serializable {
+ public:
+  explicit SerializableBigInt(facebook::jsi::Runtime &rt, const facebook::jsi::BigInt &bigInt)
+      : Serializable(ValueType::BigIntType) {
+    if (bigInt.isInt64(rt)) {
+      fastValue_ = bigInt.getInt64(rt);
+    } else {
+      slowValue_ = bigInt.toString(rt).utf8(rt);
+    }
+  }
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  /**
+   * This member is used only when the BigInt fits into int64_t range.
+   */
+  std::optional<int64_t> fastValue_{};
+  std::string slowValue_{};
+};
+
+facebook::jsi::Value makeSerializableBigInt(facebook::jsi::Runtime &rt, const facebook::jsi::BigInt &bigint);
+
+} // namespace worklets

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

@@ -0,0 +1,38 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableError.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableError::toJSValue(jsi::Runtime &rt) {
+  auto error = rt.global()
+                   .getPropertyAsFunction(rt, "Error")
+                   .callAsConstructor(rt, jsi::String::createFromUtf8(rt, message_))
+                   .getObject(rt);
+
+  error.setProperty(rt, "name", jsi::String::createFromUtf8(rt, name_));
+
+  if (stack_.has_value()) {
+    error.setProperty(rt, "stack", jsi::String::createFromUtf8(rt, stack_.value()));
+  } else {
+    error.setProperty(rt, "stack", jsi::String::createFromUtf8(rt, ""));
+  }
+
+  return error;
+}
+
+jsi::Value makeSerializableError(
+    jsi::Runtime &rt,
+    const std::string &name,
+    const std::string &message,
+    const std::optional<std::string> &stack) {
+  auto serializable = std::make_shared<SerializableError>(name, message, stack);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <optional>
+#include <string>
+
+namespace worklets {
+
+class SerializableError : public Serializable {
+ public:
+  SerializableError(const std::string &name, const std::string &message, const std::optional<std::string> &stack)
+      : Serializable(ValueType::ErrorType), name_(name), message_(message), stack_(stack) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  const std::string name_;
+  const std::string message_;
+  const std::optional<std::string> stack_;
+};
+
+facebook::jsi::Value makeSerializableError(
+    facebook::jsi::Runtime &rt,
+    const std::string &name,
+    const std::string &message,
+    const std::optional<std::string> &stack);
+
+} // namespace worklets

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

@@ -0,0 +1,24 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableHostFunction.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableHostFunction::toJSValue(jsi::Runtime &rt) {
+  return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, name_), paramCount_, hostFunction_);
+}
+
+jsi::Value makeSerializableHostFunction(
+    jsi::Runtime &rt,
+    const jsi::HostFunctionType &function,
+    const std::string &name,
+    unsigned int paramCount) {
+  auto serializable = std::make_shared<SerializableHostFunction>(function, name, paramCount);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets