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

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

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <string>
+
+namespace worklets {
+
+class SerializableString : public Serializable {
+ public:
+  explicit SerializableString(const std::string &string) : Serializable(ValueType::StringType), data_(string) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  const std::string data_;
+};
+
+facebook::jsi::Value makeSerializableString(facebook::jsi::Runtime &rt, const facebook::jsi::String &string);
+
+} // namespace worklets

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

@@ -0,0 +1,26 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableTurboModuleLike.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableTurboModuleLike::toJSValue(jsi::Runtime &rt) {
+  auto obj = properties_->toJSValue(rt).asObject(rt);
+  const auto prototype = proto_->toJSValue(rt);
+  rt.global().getPropertyAsObject(rt, "Object").getPropertyAsFunction(rt, "setPrototypeOf").call(rt, obj, prototype);
+
+  return obj;
+}
+
+jsi::Value makeSerializableTurboModuleLike(
+    jsi::Runtime &rt,
+    const jsi::Object &object,
+    const std::shared_ptr<jsi::HostObject> &proto) {
+  const auto serializable = std::make_shared<SerializableTurboModuleLike>(rt, object, proto);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableHostObject.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+
+#include <memory>
+
+namespace worklets {
+
+class SerializableTurboModuleLike : public Serializable {
+ public:
+  SerializableTurboModuleLike(
+      facebook::jsi::Runtime &rt,
+      const facebook::jsi::Object &object,
+      const std::shared_ptr<facebook::jsi::HostObject> &proto)
+      : Serializable(ValueType::TurboModuleLikeType),
+        proto_(std::make_unique<SerializableHostObject>(rt, proto)),
+        properties_(std::make_unique<SerializableObject>(rt, object)) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ private:
+  const std::unique_ptr<SerializableHostObject> proto_;
+  const std::unique_ptr<SerializableObject> properties_;
+};
+
+facebook::jsi::Value makeSerializableTurboModuleLike(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object,
+    const std::shared_ptr<facebook::jsi::HostObject> &proto);
+
+} // namespace worklets

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

@@ -0,0 +1,31 @@
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable/RetainingSerializable.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>
+
+#include <algorithm>
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableWorklet::toJSValue(jsi::Runtime &rt) {
+  react_native_assert(
+      std::any_of(data_.cbegin(), data_.cend(), [](const auto &item) { return item.first == "__workletHash"; }) &&
+      "SerializableWorklet doesn't have `__workletHash` property");
+  jsi::Value obj = SerializableObject::toJSValue(rt);
+  return getValueUnpacker(rt).call(rt, obj, jsi::String::createFromAscii(rt, "Worklet"));
+}
+
+jsi::Value makeSerializableWorklet(jsi::Runtime &rt, const jsi::Object &object, const bool &shouldRetainRemote) {
+  std::shared_ptr<Serializable> serializable;
+  if (shouldRetainRemote) {
+    serializable = std::make_shared<RetainingSerializable<SerializableWorklet>>(rt, object);
+  } else {
+    serializable = std::make_shared<SerializableWorklet>(rt, object);
+  }
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+
+namespace worklets {
+
+class SerializableWorklet : public SerializableObject {
+ public:
+  SerializableWorklet(facebook::jsi::Runtime &rt, const facebook::jsi::Object &worklet)
+      : SerializableObject(rt, worklet) {
+    valueType_ = ValueType::WorkletType;
+  }
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+};
+
+facebook::jsi::Value makeSerializableWorklet(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object,
+    const bool &shouldRetainRemote);
+
+} // namespace worklets

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

@@ -1,411 +1,23 @@
 #pragma once
 
-#include <jsi/jsi.h>
-#include <worklets/Compat/StableApi.h>
-#include <worklets/Registries/WorkletRuntimeRegistry.h>
-#include <worklets/Tools/JSScheduler.h>
-#include <worklets/WorkletRuntime/RuntimeData.h>
-
-#include <atomic>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <utility>
-#include <vector>
-
-using namespace facebook;
-
-namespace worklets {
-
-// Frees the heap-allocated jsi::Value wrapper without running ~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 ~jsi::Value.
-// See https://github.com/facebook/hermes/blob/75b617a/API/jsi/jsi/jsi.h#L833
-inline void freeWithoutCallingDestructor(std::unique_ptr<jsi::Value> &value) {
-  ::operator delete(value.release());
-}
-
-inline void cleanupRuntimeAware(jsi::Runtime *rt, std::unique_ptr<jsi::Value> &value) {
-  if (value == nullptr || rt == nullptr) {
-    return;
-  }
-  WorkletRuntimeRegistry::runWhileLocked(rt, [&value](bool isAlive) {
-    if (isAlive) {
-      value.reset();
-    } else {
-      freeWithoutCallingDestructor(value);
-    }
-  });
-}
-
-template <typename BaseClass>
-class RetainingSerializable : virtual public BaseClass {
- private:
-  jsi::Runtime *primaryRuntime_;
-  std::unique_ptr<jsi::Value> secondaryValue_;
-  std::atomic<jsi::Runtime *> secondaryRuntime_{nullptr};
-  std::mutex secondaryCacheMutex_;
-
- public:
-  template <typename... Args>
-  explicit RetainingSerializable(jsi::Runtime &rt, Args &&...args)
-      : BaseClass(rt, std::forward<Args>(args)...), primaryRuntime_(&rt) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override {
-    if (&rt == primaryRuntime_) {
-      return BaseClass::toJSValue(rt);
-    }
-    if (secondaryRuntime_.load(std::memory_order_acquire) == &rt) {
-      return jsi::Value(rt, *secondaryValue_);
-    }
-    auto value = BaseClass::toJSValue(rt);
-    {
-      std::lock_guard<std::mutex> lock(secondaryCacheMutex_);
-      if (secondaryRuntime_.load(std::memory_order_relaxed) == nullptr) {
-        secondaryValue_ = std::make_unique<jsi::Value>(rt, value);
-        secondaryRuntime_.store(&rt, std::memory_order_release);
-      }
-    }
-    return value;
-  }
-
-  ~RetainingSerializable() override {
-    cleanupRuntimeAware(secondaryRuntime_.load(std::memory_order_relaxed), secondaryValue_);
-  }
-};
-
-class SerializableJSRef : public 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 jsi::Object newNativeStateObject(jsi::Runtime &rt, const std::shared_ptr<Serializable> &value) {
-    auto object = jsi::Object(rt);
-    object.setNativeState(rt, std::make_shared<SerializableJSRef>(value));
-    object.setProperty(rt, "__serializableRef", true);
-    return object;
-  }
-};
-
-[[nodiscard]]
-jsi::Value makeSerializableClone(
-    jsi::Runtime &rt,
-    const jsi::Value &value,
-    const jsi::Value &shouldRetainRemote,
-    const jsi::Value &nativeStateSource);
-
-[[nodiscard]]
-std::shared_ptr<Serializable> extractSerializableOrThrow(
-    jsi::Runtime &rt,
-    const jsi::Value &maybeSerializableValue,
-    const std::string &errorMessage = "[Worklets] Expecting the object to be of type SerializableJSRef.");
-
-[[nodiscard]]
-std::shared_ptr<Serializable> extractSerializableOrThrow(
-    jsi::Runtime &rt,
-    const 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(
-    jsi::Runtime &rt,
-    const 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(
-    jsi::Runtime &rt,
-    const 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;
-}
-
-class SerializableArray : public Serializable {
- public:
-  SerializableArray(jsi::Runtime &rt, const jsi::Array &array);
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
-  std::vector<jsi::Value> getJSIValueArr(jsi::Runtime &rt) {
-    std::vector<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_;
-};
-
-class SerializableObject : public Serializable {
- public:
-  SerializableObject(jsi::Runtime &rt, const jsi::Object &object);
-
-  SerializableObject(jsi::Runtime &rt, const jsi::Object &object, const jsi::Value &nativeStateSource);
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  std::vector<std::pair<std::string, std::shared_ptr<Serializable>>> data_;
-  std::shared_ptr<jsi::NativeState> nativeState_;
-};
-
-class SerializableMap : public Serializable {
- public:
-  SerializableMap(jsi::Runtime &rt, const jsi::Array &keys, const jsi::Array &values);
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  std::vector<std::pair<std::shared_ptr<Serializable>, std::shared_ptr<Serializable>>> data_;
-};
-
-class SerializableSet : public Serializable {
- public:
-  SerializableSet(jsi::Runtime &rt, const jsi::Array &values);
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  std::vector<std::shared_ptr<Serializable>> data_;
-};
-
-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) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  const std::string name_;
-  const std::string message_;
-  const std::optional<std::string> stack_;
-};
-
-class SerializableRegExp : public Serializable {
- public:
-  SerializableRegExp(const std::string &pattern, const std::string &flags)
-      : Serializable(ValueType::RegExpType), pattern_(pattern), flags_(flags) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  const std::string pattern_;
-  const std::string flags_;
-};
-
-class SerializableHostObject : public Serializable {
- public:
-  SerializableHostObject(jsi::Runtime &, const std::shared_ptr<jsi::HostObject> &hostObject)
-      : Serializable(ValueType::HostObjectType), hostObject_(hostObject) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  const std::shared_ptr<jsi::HostObject> hostObject_;
-};
-
-class SerializableHostFunction : public Serializable {
- public:
-  SerializableHostFunction(const jsi::HostFunctionType &function, const std::string &name, unsigned int paramCount)
-      : Serializable(ValueType::HostFunctionType), hostFunction_(function), name_(name), paramCount_(paramCount) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  const jsi::HostFunctionType hostFunction_;
-  const std::string name_;
-  const unsigned int paramCount_;
-};
-
-struct ArrayBufferMetadata {
-  std::string typeName;
-  size_t byteOffset;
-  size_t length;
-};
-
-class SerializableArrayBuffer : public Serializable {
- public:
-  SerializableArrayBuffer(
-      jsi::Runtime &rt,
-      const 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)) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  std::optional<ArrayBufferMetadata> metadata_;
-  std::vector<uint8_t> data_;
-};
-
-class SerializableWorklet : public SerializableObject {
- public:
-  SerializableWorklet(jsi::Runtime &rt, const jsi::Object &worklet) : SerializableObject(rt, worklet) {
-    valueType_ = ValueType::WorkletType;
-  }
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-};
-
-class SerializableImport : public Serializable {
- public:
-  SerializableImport(jsi::Runtime &rt, const double source, const jsi::String &imported)
-      : Serializable(ValueType::ImportType), source_(source), imported_(imported.utf8(rt)) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  const double source_;
-  const std::string imported_;
-};
-
-class SerializableInitializer : public Serializable {
- private:
-  // We don't release the initializer since the handle can get
-  // initialized in parallel on multiple threads. However this is not a problem,
-  // since the final value is taken from a cache on the runtime which guarantees
-  // sequential access.
-  std::unique_ptr<SerializableObject> initializer_;
-  std::unique_ptr<jsi::Value> remoteValue_;
-  mutable std::mutex initializationMutex_;
-  jsi::Runtime *remoteRuntime_;
-
- public:
-  SerializableInitializer(jsi::Runtime &rt, const jsi::Object &initializerObject)
-      : Serializable(ValueType::HandleType),
-        initializer_(std::make_unique<SerializableObject>(rt, initializerObject)) {}
-
-  ~SerializableInitializer() override {
-    cleanupRuntimeAware(remoteRuntime_, remoteValue_);
-  }
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-};
-
-class SerializableString : public Serializable {
- public:
-  explicit SerializableString(const std::string &string) : Serializable(ValueType::StringType), data_(string) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- protected:
-  const std::string data_;
-};
-
-class SerializableBigInt : public Serializable {
- public:
-  explicit SerializableBigInt(jsi::Runtime &rt, const jsi::BigInt &bigInt) : Serializable(ValueType::BigIntType) {
-    if (bigInt.isInt64(rt)) {
-      fastValue_ = bigInt.getInt64(rt);
-    } else {
-      slowValue_ = bigInt.toString(rt).utf8(rt);
-    }
-  }
-
-  jsi::Value toJSValue(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_{};
-};
-
-class SerializableScalar : public Serializable {
- public:
-  explicit SerializableScalar(double number) : Serializable(ValueType::NumberType) {
-    data_.number = number;
-  }
-  explicit SerializableScalar(bool boolean) : Serializable(ValueType::BooleanType) {
-    data_.boolean = boolean;
-  }
-  SerializableScalar() : Serializable(ValueType::UndefinedType) {}
-  explicit SerializableScalar(std::nullptr_t) : Serializable(ValueType::NullType) {}
-
-  jsi::Value toJSValue(jsi::Runtime &) override;
-
- protected:
-  union Data {
-    bool boolean;
-    double number;
-  };
-
- private:
-  Data data_;
-};
-
-class SerializableTurboModuleLike : public Serializable {
- public:
-  SerializableTurboModuleLike(
-      jsi::Runtime &rt,
-      const jsi::Object &object,
-      const std::shared_ptr<jsi::HostObject> &proto)
-      : Serializable(ValueType::TurboModuleLikeType),
-        proto_(std::make_unique<SerializableHostObject>(rt, proto)),
-        properties_(std::make_unique<SerializableObject>(rt, object)) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- private:
-  const std::unique_ptr<SerializableHostObject> proto_;
-  const std::unique_ptr<SerializableObject> properties_;
-};
-
-jsi::Function getCustomSerializableUnpacker(jsi::Runtime &rt);
-
-class CustomSerializable : public Serializable {
- public:
-  CustomSerializable(std::shared_ptr<Serializable> data, const int typeId)
-      : Serializable(ValueType::CustomType), data_(std::move(data)), typeId_(typeId) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
-
- private:
-  const std::shared_ptr<Serializable> data_;
-  const int typeId_;
-};
-
-struct SerializationData {
-  std::shared_ptr<SerializableWorklet> determine;
-  std::shared_ptr<SerializableWorklet> pack;
-  std::shared_ptr<SerializableWorklet> unpack;
-  int typeId;
-};
-
-} // namespace worklets
+#warning Do not include this file directly, it will be removed in the future. Prefer including specific Serializable headers.
+
+#include <worklets/SharedItems/Serializable/CustomSerializable.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/SerializableError.h>
+#include <worklets/SharedItems/Serializable/SerializableHostFunction.h>
+#include <worklets/SharedItems/Serializable/SerializableHostObject.h>
+#include <worklets/SharedItems/Serializable/SerializableImport.h>
+#include <worklets/SharedItems/Serializable/SerializableMap.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+#include <worklets/SharedItems/Serializable/SerializableRegExp.h>
+#include <worklets/SharedItems/Serializable/SerializableRemoteFunction.h>
+#include <worklets/SharedItems/Serializable/SerializableScalar.h>
+#include <worklets/SharedItems/Serializable/SerializableSet.h>
+#include <worklets/SharedItems/Serializable/SerializableString.h>
+#include <worklets/SharedItems/Serializable/SerializableTurboModuleLike.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>

package/Common/cpp/worklets/SharedItems/Shareable.cpp

@@ -1,5 +1,5 @@
 #include <jsi/jsi.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/SharedItems/Shareable.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>

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

@@ -1,57 +1,80 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/SharedItems/SynchronizableAccess.h>
 
 #include <memory>
-
-using namespace facebook;
+#include <utility>
+#include <variant>
 
 namespace worklets {
 
+using SynchronizableValue = std::variant<std::shared_ptr<Serializable>, double, bool>;
+using SynchronizableFixedValue = std::variant<double, bool>;
+
 class Synchronizable : public SynchronizableAccess,
                        public Serializable,
-                       public jsi::NativeState,
+                       public facebook::jsi::NativeState,
                        public std::enable_shared_from_this<Synchronizable> {
  public:
+  static std::shared_ptr<Synchronizable> extractSynchronizableOrThrow(
+      facebook::jsi::Runtime &rt,
+      const facebook::jsi::Value &value) {
+    auto serializable =
+        extractSerializableOrThrow(rt, value, "[Worklets] Expecting the object to be of type SerializableJSRef.");
+
+    auto synchronizable = std::dynamic_pointer_cast<Synchronizable>(serializable);
+    react_native_assert(synchronizable != nullptr && "[Worklets] Expected the object to be a Synchronizable.");
+
+    return synchronizable;
+  }
+
+  bool isFixed() const {
+    return isFixed_;
+  }
+
   /**
    * Can run concurrently with getDirty, setDirty, getBlocking, setBlocking.
    */
-  std::shared_ptr<Serializable> getDirty();
+  virtual SynchronizableValue getDirty() = 0;
 
   /**
    * Can run concurrently with getDirty, getBlocking.
    * Can't run concurrently with setDirty, setBlocking.
    */
-  std::shared_ptr<Serializable> getBlocking();
+  virtual SynchronizableValue getBlocking() = 0;
 
-  // TODO: Shared pointer members (unless they're atomic) can't be assigned
-  // in a non thread-safe manner, therefore `setDirty` has little sense now.
   /**
-   * Can run concurrently with getDirty, getBlocking.
-   * Can't run concurrently with setDirty, setBlocking.
+   * Can run concurrently with getDirty, setDirty.
+   * Can't run concurrently with getBlocking, setBlocking.
    */
-  // void setDirty(const std::shared_ptr<Serializable> &value);
+  virtual void setDirty(const SynchronizableFixedValue &value) = 0;
 
   /**
    * Can run concurrently with getDirty.
    * Can't run concurrently with getBlocking, setDirty, setBlocking.
    */
-  void setBlocking(const std::shared_ptr<Serializable> &value);
+  virtual void setBlocking(const std::shared_ptr<Serializable> &value) = 0;
 
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
+  virtual void setBlocking(const SynchronizableFixedValue &value) = 0;
 
-  explicit Synchronizable(const std::shared_ptr<Serializable> &value);
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) final {
+    auto synchronizableUnpacker = rt.global().getProperty(rt, "__synchronizableUnpacker");
+    react_native_assert(synchronizableUnpacker.isObject() && "synchronizableUnpacker not found");
+    auto ref = SerializableJSRef::newNativeStateObject(rt, this->shared_from_this());
+    return synchronizableUnpacker.getObject(rt).getFunction(rt).call(
+        rt, std::move(ref), facebook::jsi::Value(isFixed()));
+  }
 
   ~Synchronizable() override = default;
 
+ protected:
+  explicit Synchronizable(bool isFixed) : Serializable(ValueType::SynchronizableType), isFixed_(isFixed) {}
+
  private:
-  std::shared_ptr<Serializable> value_;
+  const bool isFixed_;
 };
 
-jsi::Function getSynchronizableUnpacker(jsi::Runtime &rt);
-
-std::shared_ptr<Synchronizable> extractSynchronizableOrThrow(jsi::Runtime &rt, const jsi::Value &value);
-
-}; // namespace worklets
+} // namespace worklets