@depup/react-native-worklets 0.11.3-depup.0

package/Common/cpp/worklets/SharedItems/SerializableRemoteFunction.cpp

@@ -0,0 +1,71 @@
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/SerializableRemoteFunction.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+namespace {
+
+jsi::Function getRemoteFunctionUnpacker(jsi::Runtime &rt) {
+  auto remoteFunctionUnpacker = rt.global().getProperty(rt, "__remoteFunctionUnpacker");
+  react_native_assert(remoteFunctionUnpacker.isObject() && "remoteFunctionUnpacker not found");
+  return remoteFunctionUnpacker.asObject(rt).asFunction(rt);
+}
+
+} // namespace
+
+SerializableRemoteFunction::~SerializableRemoteFunction() {
+  if (isHostedOnRNRuntime()) {
+    rnRuntimeStatus_->runWhileLocked([this](bool isDead) {
+      if (isDead) {
+        freeWithoutCallingDestructor(function_);
+      } else {
+        function_.reset();
+      }
+    });
+  } else {
+    cleanupRuntimeAware(hostRuntime_, function_);
+  }
+}
+
+jsi::Value SerializableRemoteFunction::toJSValue(jsi::Runtime &rt) {
+  if (&rt == hostRuntime_) {
+    return jsi::Value(rt, *function_);
+  } else {
+    const auto name = name_.empty() ? jsi::Value::undefined() : jsi::String::createFromUtf8(rt, name_);
+    auto holderFunction = getRemoteFunctionUnpacker(rt).call(rt, name).getObject(rt);
+    holderFunction.setNativeState(rt, std::make_shared<SerializableJSRef>(shared_from_this()));
+    return holderFunction;
+  }
+}
+
+// TODO: generalize it and merge with other scheduling methods
+void SerializableRemoteFunction::resolveOrRejectPromise(
+    const std::shared_ptr<Serializable> &resolveValue,
+    const std::shared_ptr<RuntimeManager> &runtimeManager) {
+  if (isHostedOnRNRuntime()) {
+    jsScheduler_->scheduleOnJS([resolver = shared_from_this(), resolveValue](jsi::Runtime &rt) {
+      resolver->toJSValue(rt).getObject(rt).getFunction(rt).call(rt, resolveValue->toJSValue(rt));
+    });
+  } else {
+    const auto workletRuntime = runtimeManager->getRuntime(hostRuntimeId_);
+    // NOLINTNEXTLINE(readability/braces)
+    if (!workletRuntime) [[unlikely]] {
+      // Host runtime is dead, most likely we're the last owner of the Remote Function.
+      // Do nothing.
+    } else {
+      workletRuntime->schedule([resolver = shared_from_this(), resolveValue](jsi::Runtime &rt) {
+        resolver->toJSValue(rt).getObject(rt).getFunction(rt).call(rt, resolveValue->toJSValue(rt));
+      });
+    }
+  }
+}
+
+} // namespace worklets

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

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+class RuntimeManager;
+
+class SerializableRemoteFunction : public Serializable,
+                                   public std::enable_shared_from_this<SerializableRemoteFunction> {
+ public:
+  /** Creates RN Runtime Remote Function. */
+  SerializableRemoteFunction(
+      jsi::Runtime &rnRuntime,
+      const std::string &name,
+      jsi::Function &&function,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus)
+      : Serializable(ValueType::RemoteFunctionType),
+        hostRuntime_(&rnRuntime),
+        hostRuntimeId_(RuntimeData::rnRuntimeId),
+        function_(std::make_unique<jsi::Value>(rnRuntime, std::move(function))),
+        name_(name),
+        jsScheduler_(jsScheduler),
+        rnRuntimeStatus_(rnRuntimeStatus) {}
+
+  /** Creates Worklet Runtime Remote Function. */
+  SerializableRemoteFunction(
+      jsi::Runtime &workletRuntime,
+      const std::string &name,
+      jsi::Function &&function,
+      RuntimeData::RuntimeId hostRuntimeId)
+      : Serializable(ValueType::RemoteFunctionType),
+        hostRuntime_(&workletRuntime),
+        hostRuntimeId_(hostRuntimeId),
+        function_(std::make_unique<jsi::Value>(workletRuntime, std::move(function))),
+        name_(name),
+        jsScheduler_(nullptr),
+        rnRuntimeStatus_(nullptr) {}
+
+  ~SerializableRemoteFunction() override;
+
+  SerializableRemoteFunction(const SerializableRemoteFunction &) = delete;
+  SerializableRemoteFunction &operator=(const SerializableRemoteFunction &) = delete;
+
+  void resolveOrRejectPromise(
+      const std::shared_ptr<Serializable> &resolveValue,
+      const std::shared_ptr<RuntimeManager> &runtimeManager);
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
+
+  [[nodiscard]] bool isHostedOnRNRuntime() const noexcept {
+    return hostRuntimeId_ == RuntimeData::rnRuntimeId;
+  }
+
+  [[nodiscard]] RuntimeData::RuntimeId getHostRuntimeId() const noexcept {
+    return hostRuntimeId_;
+  }
+
+ private:
+  jsi::Runtime *hostRuntime_;
+  const RuntimeData::RuntimeId hostRuntimeId_;
+  std::unique_ptr<jsi::Value> function_;
+  const std::string name_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,84 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Shareable.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+#include <mutex>
+#include <utility>
+
+namespace worklets {
+
+jsi::Function Shareable::getShareableHostUnpacker(jsi::Runtime &rt) {
+  return rt.global().getPropertyAsFunction(rt, "__shareableHostUnpacker");
+}
+
+jsi::Function Shareable::getShareableGuestUnpacker(jsi::Runtime &rt) {
+  return rt.global().getPropertyAsFunction(rt, "__shareableGuestUnpacker");
+}
+
+Shareable::Shareable(
+    const std::shared_ptr<WorkletRuntime> &hostRuntime,
+    const std::shared_ptr<Serializable> &initial,
+    const bool initSynchronously,
+    const std::shared_ptr<Serializable> &decorateHost,
+    const std::shared_ptr<Serializable> &decorateGuest)
+    : Serializable(ValueType::ShareableType),
+      weakHostRuntime_(hostRuntime),
+      hostRuntimeId_(hostRuntime->getRuntimeId()),
+      hostJSIRuntime_(hostRuntime->getJSIRuntime()),
+      initial_(initial),
+      initSynchronously_(initSynchronously),
+      decorateHost_(decorateHost),
+      decorateGuest_(decorateGuest) {
+  if (initSynchronously) {
+    hostRuntime->runSync([this](jsi::Runtime &rt) { initHostValue(); });
+  }
+}
+
+Shareable::~Shareable() {
+  if (hostValue_) {
+    const auto strongHostRuntime = weakHostRuntime_.lock();
+    if (strongHostRuntime) {
+      hostValue_.reset();
+    } else {
+      freeWithoutCallingDestructor(hostValue_);
+    }
+  }
+}
+
+jsi::Value Shareable::toJSValue(jsi::Runtime &rt) {
+  if (&rt == &hostJSIRuntime_) {
+    return hostJSValue();
+  } else {
+    return guestJSValue(rt);
+  }
+}
+
+jsi::Value Shareable::hostJSValue() {
+  if (!initSynchronously_ && !hostValue_) {
+    std::lock_guard lock(initializationMutex_);
+    if (!hostValue_) {
+      initHostValue();
+    }
+  }
+
+  return jsi::Value(hostJSIRuntime_, *hostValue_);
+}
+
+jsi::Value Shareable::guestJSValue(jsi::Runtime &rt) {
+  const auto shareableUnpacker = getShareableGuestUnpacker(rt);
+  const auto ref = SerializableJSRef::newNativeStateObject(rt, shared_from_this());
+  return shareableUnpacker.call(rt, static_cast<double>(hostRuntimeId_), ref, decorateGuest_->toJSValue(rt));
+}
+
+void Shareable::initHostValue() {
+  const auto shareableUnpacker = getShareableHostUnpacker(hostJSIRuntime_);
+  const auto shareable = shareableUnpacker.call(
+      hostJSIRuntime_, initial_->toJSValue(hostJSIRuntime_), decorateHost_->toJSValue(hostJSIRuntime_));
+  hostValue_ = std::make_unique<jsi::Value>(hostJSIRuntime_, std::move(shareable));
+  initial_.reset();
+  decorateHost_.reset();
+}
+
+} // namespace worklets

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+
+namespace worklets {
+
+class Shareable : public Serializable, public std::enable_shared_from_this<Shareable> {
+ public:
+  static jsi::Function getShareableHostUnpacker(jsi::Runtime &rt);
+  static jsi::Function getShareableGuestUnpacker(jsi::Runtime &rt);
+
+  Shareable(
+      const std::shared_ptr<WorkletRuntime> &hostRuntime,
+      const std::shared_ptr<Serializable> &initial,
+      const bool initSynchronously,
+      const std::shared_ptr<Serializable> &decorateHost,
+      const std::shared_ptr<Serializable> &decorateGuest);
+
+  ~Shareable() override;
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
+
+ private:
+  jsi::Value hostJSValue();
+  jsi::Value guestJSValue(jsi::Runtime &rt);
+  void initHostValue();
+
+  const std::weak_ptr<WorkletRuntime> weakHostRuntime_;
+  const RuntimeData::RuntimeId hostRuntimeId_;
+  jsi::Runtime &hostJSIRuntime_;
+  std::shared_ptr<Serializable> initial_;
+  const bool initSynchronously_;
+  std::mutex initializationMutex_;
+  std::unique_ptr<jsi::Value> hostValue_;
+  std::shared_ptr<Serializable> decorateHost_;
+  const std::shared_ptr<Serializable> decorateGuest_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,59 @@
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Synchronizable.h>
+
+#include <memory>
+#include <utility>
+
+namespace worklets {
+
+std::shared_ptr<Serializable> Synchronizable::getDirty() {
+  return value_;
+}
+
+std::shared_ptr<Serializable> Synchronizable::getBlocking() {
+  getBlockingBefore();
+  auto value = value_;
+  getBlockingAfter();
+  return value;
+}
+
+// TODO: Shared pointer members (unless they're atomic) can't be assigned
+// in a non thread-safe manner, therefore `setDirty` has little sense now.
+// void Synchronizable::setDirty(const std::shared_ptr<Serializable> &value) {
+//   setDirtyBefore();
+//   value_ = value;
+//   setDirtyAfter();
+// }
+
+void Synchronizable::setBlocking(const std::shared_ptr<Serializable> &value) {
+  setBlockingBefore();
+  value_ = value;
+  setBlockingAfter();
+}
+
+jsi::Value Synchronizable::toJSValue(jsi::Runtime &rt) {
+  auto synchronizableUnpacker = getSynchronizableUnpacker(rt);
+  auto ref = SerializableJSRef::newNativeStateObject(rt, this->shared_from_this());
+  return synchronizableUnpacker.call(rt, std::move(ref));
+}
+
+Synchronizable::Synchronizable(const std::shared_ptr<Serializable> &value)
+    : Serializable(ValueType::SynchronizableType), value_(value) {}
+
+jsi::Function getSynchronizableUnpacker(jsi::Runtime &rt) {
+  auto synchronizableUnpacker = rt.global().getProperty(rt, "__synchronizableUnpacker");
+  react_native_assert(synchronizableUnpacker.isObject() && "synchronizableUnpacker not found");
+  return synchronizableUnpacker.asObject(rt).asFunction(rt);
+}
+
+std::shared_ptr<Synchronizable> extractSynchronizableOrThrow(jsi::Runtime &rt, const 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;
+}
+
+} // namespace worklets

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

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/SynchronizableAccess.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+class Synchronizable : public SynchronizableAccess,
+                       public Serializable,
+                       public jsi::NativeState,
+                       public std::enable_shared_from_this<Synchronizable> {
+ public:
+  /**
+   * Can run concurrently with getDirty, setDirty, getBlocking, setBlocking.
+   */
+  std::shared_ptr<Serializable> getDirty();
+
+  /**
+   * Can run concurrently with getDirty, getBlocking.
+   * Can't run concurrently with setDirty, setBlocking.
+   */
+  std::shared_ptr<Serializable> getBlocking();
+
+  // 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.
+   */
+  // void setDirty(const std::shared_ptr<Serializable> &value);
+
+  /**
+   * Can run concurrently with getDirty.
+   * Can't run concurrently with getBlocking, setDirty, setBlocking.
+   */
+  void setBlocking(const std::shared_ptr<Serializable> &value);
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
+
+  explicit Synchronizable(const std::shared_ptr<Serializable> &value);
+
+  ~Synchronizable() override = default;
+
+ private:
+  std::shared_ptr<Serializable> value_;
+};
+
+jsi::Function getSynchronizableUnpacker(jsi::Runtime &rt);
+
+std::shared_ptr<Synchronizable> extractSynchronizableOrThrow(jsi::Runtime &rt, const jsi::Value &value);
+
+}; // namespace worklets

package/Common/cpp/worklets/SharedItems/SynchronizableAccess.cpp

@@ -0,0 +1,78 @@
+#include <worklets/SharedItems/SynchronizableAccess.h>
+
+#include <mutex>
+
+namespace worklets {
+void SynchronizableAccess::getBlockingBefore() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  queue_.wait(lock, [this]() {
+    return !blockingWriter_ /* && dirtyWriters_ == 0 */ && (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
+  });
+  blockingReaders_++;
+}
+
+void SynchronizableAccess::getBlockingAfter() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  blockingReaders_--;
+  if (blockingReaders_ == 0) {
+    queue_.notify_all();
+  }
+}
+
+// TODO: Shared pointer members (unless they're atomic) can't be assigned
+// in a non thread-safe manner, therefore `setDirty` has little sense now.
+// void SynchronizableAccess::setDirtyBefore() {
+//   std::unique_lock<std::mutex> lock(accessLock_);
+//   queue_.wait(lock, [this]() {
+//     return !blockingWriter_ && blockingReaders_ == 0 &&
+//         (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
+//   });
+//   dirtyWriters_++;
+// }
+
+// TODO: Shared pointer members (unless they're atomic) can't be assigned
+// in a non thread-safe manner, therefore `setDirty` has little sense now.
+// void SynchronizableAccess::setDirtyAfter() {
+//   std::unique_lock<std::mutex> lock(accessLock_);
+//   dirtyWriters_--;
+//   if (dirtyWriters_ == 0) {
+//     queue_.notify_all();
+//   }
+// }
+
+void SynchronizableAccess::setBlockingBefore() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  queue_.wait(lock, [this]() {
+    return !blockingWriter_ && blockingReaders_ == 0 /* && dirtyWriters_ == 0 */ &&
+        (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
+  });
+  blockingWriter_ = true;
+}
+
+void SynchronizableAccess::setBlockingAfter() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  blockingWriter_ = false;
+  queue_.notify_all();
+}
+
+void SynchronizableAccess::lock() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  queue_.wait(lock, [this]() {
+    return !blockingWriter_ && blockingReaders_ == 0 /* && dirtyWriters_ == 0 */ &&
+        (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
+  });
+  imperativelyLocked_ = true;
+  imperativeOwner_ = pthread_self();
+}
+
+void SynchronizableAccess::unlock() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  if (imperativeOwner_ != pthread_self()) {
+    return;
+  }
+  imperativelyLocked_ = false;
+  imperativeOwner_ = {};
+  queue_.notify_all();
+}
+
+} // namespace worklets

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

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+
+namespace worklets {
+
+class SynchronizableAccess {
+ public:
+  /**
+   * Allows you to imperatively lock the synchronizable to perform a
+   * transaction.
+   */
+  void lock();
+
+  /**
+   * Unlocks the synchronizable after an imperative lock when the transaction is
+   * complete.
+   */
+  void unlock();
+
+ protected:
+  void getBlockingBefore();
+  void getBlockingAfter();
+
+  // TODO: Shared pointer members (unless they're atomic) can't be assigned
+  // in a non thread-safe manner, therefore `setDirty` has little sense now.
+  // void setDirtyBefore();
+  // void setDirtyAfter();
+
+  void setBlockingBefore();
+  void setBlockingAfter();
+
+ private:
+  int blockingReaders_{0};
+  // int dirtyWriters_{0};
+  bool blockingWriter_{false};
+  bool imperativelyLocked_{false};
+  pthread_t imperativeOwner_{};
+  std::mutex accessLock_;
+  std::recursive_mutex imperativeLock_;
+  std::condition_variable queue_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/ScriptBuffer.h>
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace worklets {
+
+struct CodeUnpacker {
+  std::string code;
+  std::string location;
+  std::string sourceMap;
+};
+
+struct BytecodeUnpacker {
+  std::vector<uint8_t> bytecode;
+};
+
+class UnpackerLoader {
+ public:
+  void loadCodeUnpackers(std::array<CodeUnpacker, 6> unpackers) {
+    codeUnpackers_ = std::move(unpackers);
+  }
+
+  void loadBytecodeUnpackers(std::array<BytecodeUnpacker, 6> unpackers) {
+    bytecodeUnpackers_ = std::move(unpackers);
+  }
+
+  void installUnpackers(facebook::jsi::Runtime &rt) const {
+    if (codeUnpackers_) {
+      for (const auto &unpacker : *codeUnpackers_) {
+        installUnpacker(rt, unpacker);
+      }
+    } else if (bytecodeUnpackers_) {
+      for (const auto &unpacker : *bytecodeUnpackers_) {
+        installUnpacker(rt, unpacker);
+      }
+    } else {
+      throw std::runtime_error("[Worklets] UnpackerLoader tried to install unpackers but they were not loaded.");
+    }
+  }
+
+ private:
+  static void installUnpacker(facebook::jsi::Runtime &rt, const CodeUnpacker &unpacker) {
+#ifndef NDEBUG
+    if (!unpacker.sourceMap.empty()) {
+      rt.global()
+          .getPropertyAsFunction(rt, "evalWithSourceMap")
+          .call(rt, unpacker.code, unpacker.location, unpacker.sourceMap)
+          .getObject(rt)
+          .getFunction(rt)
+          .call(rt);
+      return;
+    }
+#endif // NDEBUG
+    rt.evaluateJavaScript(std::make_shared<facebook::jsi::StringBuffer>(unpacker.code), unpacker.location)
+        .getObject(rt)
+        .getFunction(rt)
+        .call(rt);
+  }
+
+  static void installUnpacker(facebook::jsi::Runtime &rt, const BytecodeUnpacker &unpacker) {
+    auto buffer = std::make_shared<BytecodeBuffer>(unpacker.bytecode);
+    rt.evaluateJavaScript(buffer, "").getObject(rt).getFunction(rt).call(rt);
+  }
+
+  std::optional<std::array<CodeUnpacker, 6>> codeUnpackers_;
+  std::optional<std::array<BytecodeUnpacker, 6>> bytecodeUnpackers_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/FeatureFlags.cpp

@@ -0,0 +1,18 @@
+#include <worklets/Tools/FeatureFlags.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace worklets {
+
+std::unordered_map<std::string, bool> DynamicFeatureFlags::flags_;
+
+bool DynamicFeatureFlags::getFlag(const std::string &name) {
+  return flags_.contains(name) && flags_[name];
+}
+
+void DynamicFeatureFlags::setFlag(const std::string &name, bool value) {
+  flags_[name] = value;
+}
+
+} // namespace worklets

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

@@ -0,0 +1,44 @@
+#pragma once
+#include <string>
+#include <unordered_map>
+
+namespace worklets {
+
+class StaticFeatureFlags {
+ public:
+#ifdef WORKLETS_FEATURE_FLAGS
+
+// Convert the value under x into a string
+#define XTOSTRING(x) #x
+// Evaluate the flag value; without this step, it would stringify the flag name
+// itself instead of the flag value
+#define TOSTRING(x) XTOSTRING(x)
+
+  static constexpr bool getFlag(const std::string_view &name) {
+    std::string nameStr = name.data();
+    std::string featureFlags = TOSTRING(WORKLETS_FEATURE_FLAGS);
+    if (featureFlags.find("[" + nameStr + ":") == std::string::npos) {
+      throw std::logic_error("Unable to recognize flag: " + nameStr);
+    }
+    return featureFlags.find("[" + nameStr + ":true]") != std::string::npos;
+  }
+
+#else
+
+  static constexpr bool getFlag(const std::string_view &) {
+    return false;
+  }
+
+#endif
+};
+
+class DynamicFeatureFlags {
+ public:
+  static bool getFlag(const std::string &name);
+  static void setFlag(const std::string &name, bool value);
+
+ private:
+  static std::unordered_map<std::string, bool> flags_;
+};
+
+} // namespace worklets