react-native-executorch 0.4.8 → 0.5.0

package/common/rnexecutorch/jsi/JsiHostObject.cpp

@@ -0,0 +1,108 @@
+#include "JsiHostObject.h"
+
+//  set this value to 1 in order to debug the construction/destruction
+#define JSI_DEBUG_ALLOCATIONS 1
+
+namespace rnexecutorch {
+
+#if JSI_DEBUG_ALLOCATIONS
+int objCounter = 0;
+std::vector<JsiHostObject *> objects;
+#endif
+
+JsiHostObject::JsiHostObject() {
+  getters_ = std::make_unique<std::unordered_map<
+      std::string, jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
+  functions_ = std::make_unique<
+      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
+                                          jsi::Runtime &, const jsi::Value &,
+                                          const jsi::Value *, size_t)>>();
+  setters_ = std::make_unique<std::unordered_map<
+      std::string,
+      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>();
+
+#if JSI_DEBUG_ALLOCATIONS
+  objects.push_back(this);
+  objCounter++;
+#endif
+}
+
+JsiHostObject::~JsiHostObject() {
+#if JSI_DEBUG_ALLOCATIONS
+  for (size_t i = 0; i < objects.size(); ++i) {
+    if (objects.at(i) == this) {
+      objects.erase(objects.begin() + i);
+      break;
+    }
+  }
+  objCounter--;
+#endif
+}
+
+std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.reserve(getters_->size() + functions_->size() +
+                        setters_->size());
+
+  for (const auto &it : *getters_) {
+    propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
+  }
+
+  for (const auto &it : *functions_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  for (const auto &it : *setters_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  return propertyNames;
+}
+
+jsi::Value JsiHostObject::get(jsi::Runtime &runtime,
+                              const jsi::PropNameID &name) {
+  auto nameAsString = name.utf8(runtime);
+  auto &hostFunctionCache = hostFunctionCache_.get(runtime);
+
+  auto cachedFunction = hostFunctionCache.find(nameAsString);
+  if (cachedFunction != hostFunctionCache.end()) {
+    return cachedFunction->second.asFunction(runtime);
+  }
+
+  auto getter = getters_->find(nameAsString);
+  if (getter != getters_->end()) {
+    auto dispatcher = std::bind(getter->second, this, std::placeholders::_1);
+
+    return dispatcher(runtime);
+  }
+
+  auto function = functions_->find(nameAsString);
+  if (function == functions_->end()) {
+    return jsi::Value::undefined();
+  }
+
+  auto dispatcher =
+      std::bind(function->second, reinterpret_cast<JsiHostObject *>(this),
+                std::placeholders::_1, std::placeholders::_2,
+                std::placeholders::_3, std::placeholders::_4);
+
+  return hostFunctionCache
+      .emplace(nameAsString, jsi::Function::createFromHostFunction(
+                                 runtime, name, 0, dispatcher))
+      .first->second.asFunction(runtime);
+}
+
+void JsiHostObject::set(jsi::Runtime &runtime, const jsi::PropNameID &name,
+                        const jsi::Value &value) {
+  auto nameAsString = name.utf8(runtime);
+
+  auto setter = setters_->find(nameAsString);
+
+  if (setter != setters_->end()) {
+    auto dispatcher = std::bind(setter->second, this, std::placeholders::_1,
+                                std::placeholders::_2);
+
+    return dispatcher(runtime, value);
+  }
+}
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/JsiHostObject.h

@@ -0,0 +1,87 @@
+#pragma once
+// Adapted from https://github.com/software-mansion/react-native-audio-api
+
+#include <rnexecutorch/jsi/RuntimeAwareCache.h>
+
+#include <jsi/jsi.h>
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#define JSI_HOST_FUNCTION(NAME)                                                \
+  jsi::Value NAME(jsi::Runtime &runtime, const jsi::Value &thisValue,          \
+                  const jsi::Value *args, size_t count)
+
+#define JSI_EXPORT_FUNCTION(CLASS, FUNCTION, NAME)                             \
+  std::make_pair(                                                              \
+      NAME,                                                                    \
+      static_cast<jsi::Value (JsiHostObject::*)(                               \
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>(    \
+          &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_GETTER(name) jsi::Value name(jsi::Runtime &runtime)
+
+#define JSI_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION)                            \
+  std::make_pair(std::string(#FUNCTION),                                       \
+                 static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>(   \
+                     &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_SETTER(name)                                              \
+  void name(jsi::Runtime &runtime, const jsi::Value &value)
+
+#define JSI_EXPORT_PROPERTY_SETTER(CLASS, FUNCTION)                            \
+  std::make_pair(std::string(#FUNCTION),                                       \
+                 static_cast<void (JsiHostObject::*)(                          \
+                     jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+class JsiHostObject : public jsi::HostObject {
+public:
+  JsiHostObject();
+  ~JsiHostObject() override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(jsi::Runtime &runtime, const jsi::PropNameID &name,
+           const jsi::Value &value) override;
+
+  template <typename... Args> void addGetters(Args... args) {
+    (getters_->insert(args), ...);
+  }
+
+  template <typename... Args> void addSetters(Args... args) {
+    (setters_->insert(args), ...);
+  }
+
+  template <typename... Args> void addFunctions(Args... args) {
+    (functions_->insert(args), ...);
+  }
+
+protected:
+  std::unique_ptr<std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
+                                                      jsi::Runtime &)>>
+      getters_;
+
+  std::unique_ptr<
+      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
+                                          jsi::Runtime &, const jsi::Value &,
+                                          const jsi::Value *, size_t)>>
+      functions_;
+
+  std::unique_ptr<std::unordered_map<
+      std::string, void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
+      setters_;
+
+private:
+  RuntimeAwareCache<std::map<std::string, jsi::Function>> hostFunctionCache_;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/OwningArrayBuffer.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+/**
+ * JSI offers the MutableBuffer as an interface for accessing native memory
+ * directly from JS. A class inheriting from the MutableBuffer could be used to
+ * access memory which is owned by C++ or memory which should be freed once JS
+ * is done with it. OwningArrayBuffer is an example of the latter, memory is
+ * allocated on creation and freed on deletion. JS holds a pointer to all
+ * MutableBuffers via a shared_ptr, so the destructor will be called only when
+ * no reference to it is kept. For a handy JS access to the data, MutableBuffers
+ * can be inspected via a data view, such as Float32Array. See
+ * ImageSegmentation.cpp for an example usage.
+ */
+class OwningArrayBuffer : public jsi::MutableBuffer {
+public:
+  OwningArrayBuffer(const size_t size) : size_(size) {
+    data_ = new uint8_t[size];
+  }
+  ~OwningArrayBuffer() override { delete[] data_; }
+
+  OwningArrayBuffer(const OwningArrayBuffer &) = delete;
+  OwningArrayBuffer(OwningArrayBuffer &&) = delete;
+  OwningArrayBuffer &operator=(const OwningArrayBuffer &) = delete;
+  OwningArrayBuffer &operator=(OwningArrayBuffer &&) = delete;
+
+  [[nodiscard]] size_t size() const override { return size_; }
+  uint8_t *data() override { return data_; }
+
+private:
+  uint8_t *data_;
+  const size_t size_;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/Promise.cpp

@@ -0,0 +1,20 @@
+#include "Promise.h"
+
+namespace rnexecutorch {
+
+Promise::Promise(jsi::Runtime &runtime,
+                 std::shared_ptr<react::CallInvoker> callInvoker,
+                 jsi::Value resolver, jsi::Value rejecter)
+    : runtime(runtime), callInvoker(callInvoker),
+      _resolver(std::move(resolver)), _rejecter(std::move(rejecter)) {}
+
+void Promise::resolve(jsi::Value &&result) {
+  _resolver.asObject(runtime).asFunction(runtime).call(runtime, result);
+}
+
+void Promise::reject(std::string message) {
+  jsi::JSError error(runtime, message);
+  _rejecter.asObject(runtime).asFunction(runtime).call(runtime, error.value());
+}
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/Promise.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+class Promise;
+
+template <typename T>
+concept PromiseRunFn =
+    std::invocable<T, std::shared_ptr<Promise>> &&
+    std::same_as<std::invoke_result_t<T, std::shared_ptr<Promise>>, void>;
+
+class Promise {
+public:
+  Promise(jsi::Runtime &runtime,
+          std::shared_ptr<react::CallInvoker> callInvoker, jsi::Value resolver,
+          jsi::Value rejecter);
+
+  Promise(const Promise &) = delete;
+  Promise &operator=(const Promise &) = delete;
+
+  void resolve(jsi::Value &&result);
+  void reject(std::string error);
+
+  /**
+    Creates a new promise and runs the supplied "run" function that takes this
+    promise. We use a template for the function type to not use std::function
+    and be able to bind a lambda.
+  */
+  template <PromiseRunFn Fn>
+  static jsi::Value
+  createPromise(jsi::Runtime &runtime,
+                std::shared_ptr<react::CallInvoker> callInvoker, Fn &&run) {
+    // Get Promise ctor from global
+    auto promiseCtor =
+        runtime.global().getPropertyAsFunction(runtime, "Promise");
+
+    auto promiseCallback = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "PromiseCallback"), 2,
+        [run = std::move(run),
+         callInvoker](jsi::Runtime &runtime, const jsi::Value &thisValue,
+                      const jsi::Value *arguments, size_t count) -> jsi::Value {
+          // Call function
+          auto promise = std::make_shared<Promise>(
+              runtime, callInvoker, arguments[0].asObject(runtime),
+              arguments[1].asObject(runtime));
+          run(promise);
+
+          return jsi::Value::undefined();
+        });
+
+    return promiseCtor.callAsConstructor(runtime, promiseCallback);
+  }
+
+private:
+  jsi::Runtime &runtime;
+  std::shared_ptr<react::CallInvoker> callInvoker;
+  jsi::Value _resolver;
+  jsi::Value _rejecter;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/RuntimeAwareCache.h

@@ -0,0 +1,58 @@
+#pragma once
+// Adapted from https://github.com/software-mansion/react-native-audio-api
+
+// Header in jsi/ need to be added like this. See comment in JsiHostObject.h.
+#include <rnexecutorch/jsi/RuntimeLifecycleMonitor.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <unordered_map>
+#include <utility>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+/**
+ * Provides a way to keep data specific to a jsi::Runtime instance that gets
+ * cleaned up when that runtime is destroyed. This is necessary because JSI does
+ * not allow for its associated objects to be retained past the runtime
+ * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
+ * after the runtime is torn down, its destructor (once it is destroyed
+ * eventually) will result in a crash (JSI objects keep a pointer to memory
+ * managed by the runtime, accessing that portion of the memory after runtime is
+ * deleted is the root cause of that crash).
+ */
+template <typename T>
+class RuntimeAwareCache : public RuntimeLifecycleListener {
+public:
+  void onRuntimeDestroyed(jsi::Runtime *rt) override {
+    // A runtime has been destroyed, so destroy the related cache.
+    runtimeCaches_.erase(rt);
+  }
+
+  ~RuntimeAwareCache() override {
+    for (auto &cache : runtimeCaches_) {
+      // remove all `onRuntimeDestroyed` listeners.
+      RuntimeLifecycleMonitor::removeListener(*cache.first, this);
+    }
+  }
+
+  T &get(jsi::Runtime &rt) {
+    if (runtimeCaches_.count(&rt) == 0) {
+      // This is the first time this Runtime has been accessed.
+      // We set up a `onRuntimeDestroyed` listener for it and
+      // initialize the cache map.
+      RuntimeLifecycleMonitor::addListener(rt, this);
+
+      T cache;
+      runtimeCaches_.emplace(&rt, std::move(cache));
+    }
+    return runtimeCaches_.at(&rt);
+  }
+
+private:
+  std::unordered_map<jsi::Runtime *, T> runtimeCaches_;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.cpp

@@ -0,0 +1,53 @@
+#include "RuntimeLifecycleMonitor.h"
+
+namespace rnexecutorch {
+
+static std::unordered_map<jsi::Runtime *,
+                          std::unordered_set<RuntimeLifecycleListener *>>
+    listeners;
+
+struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
+  jsi::Runtime *rt_;
+  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : rt_(rt) {}
+  ~RuntimeLifecycleMonitorObject() override {
+    auto listenersSet = listeners.find(rt_);
+    if (listenersSet != listeners.end()) {
+      for (auto listener : listenersSet->second) {
+        listener->onRuntimeDestroyed(rt_);
+      }
+      listeners.erase(listenersSet);
+    }
+  }
+};
+
+void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt,
+                                          RuntimeLifecycleListener *listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // We install a global host object in the provided runtime, this way we can
+    // use that host object destructor to get notified when the runtime is being
+    // terminated. We use a unique name for the object as it gets saved with the
+    // runtime's global object.
+    rt.global().setProperty(
+        rt, "__rnaudioapi_runtime_lifecycle_monitor",
+        jsi::Object::createFromHostObject(
+            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
+    std::unordered_set<RuntimeLifecycleListener *> newSet;
+    newSet.insert(listener);
+    listeners.emplace(&rt, std::move(newSet));
+  } else {
+    listenersSet->second.insert(listener);
+  }
+}
+
+void RuntimeLifecycleMonitor::removeListener(
+    jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // nothing to do here
+  } else {
+    listenersSet->second.erase(listener);
+  }
+}
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.h

@@ -0,0 +1,35 @@
+#pragma once
+// Adapted from https://github.com/software-mansion/react-native-audio-api
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+/**
+ * Listener interface that allows for getting notified when a jsi::Runtime
+ * instance is destroyed.
+ */
+struct RuntimeLifecycleListener {
+  virtual ~RuntimeLifecycleListener() = default;
+  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
+};
+
+/**
+ * This class provides an API via static methods for registering and
+ * unregistering runtime lifecycle listeners. The listeners can be used to
+ * cleanup any data that references a given jsi::Runtime instance before it gets
+ * destroyed.
+ */
+struct RuntimeLifecycleMonitor {
+  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
+  static void removeListener(jsi::Runtime &rt,
+                             RuntimeLifecycleListener *listener);
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/metaprogramming/ConstructorHelpers.h

@@ -0,0 +1,131 @@
+#pragma once
+
+#include <concepts>
+#include <jsi/jsi.h>
+#include <memory>
+#include <rnexecutorch/host_objects/JsiConversions.h>
+#include <tuple>
+#include <type_traits>
+
+namespace facebook::react {
+class CallInvoker;
+}
+
+namespace rnexecutorch {
+namespace meta {
+
+using namespace facebook;
+
+/**
+ * To be able to generically invoke constructors, we need to know what types
+ * are the arguments that need to be passed to it. To do this, we specialize the
+ * ConstructorTraits struct template for each class which constructor we want to
+ * use. See REGISTER_CONSTRUCTOR macro for a easy way to do this.
+ *
+ * Note: a downside for this method is that we can specialize ConstructorTraits
+ * only for a single constructor signature per class.
+ */
+
+template <typename T> struct ConstructorTraits;
+
+template <typename T>
+concept HasConstructorTraits =
+    requires { typename ConstructorTraits<T>::arg_types; };
+
+template <typename T, typename Tuple> struct is_constructible_from_tuple;
+
+template <typename T, typename... Args>
+struct is_constructible_from_tuple<T, std::tuple<Args...>>
+    : std::is_constructible<T, Args...> {};
+
+template <typename T, typename Tuple>
+concept ConstructibleFromTuple = is_constructible_from_tuple<T, Tuple>::value;
+
+template <typename NotTuple>
+struct last_element_is_call_invoker : std::false_type {};
+
+template <typename... Args>
+struct last_element_is_call_invoker<std::tuple<Args...>> {
+private:
+  template <typename Last> static constexpr bool check() {
+    return std::is_same_v<Last, std::shared_ptr<facebook::react::CallInvoker>>;
+  }
+
+  template <typename First, typename Second, typename... Rest>
+  static constexpr bool check_last() {
+    return check_last<Second, Rest...>();
+  }
+
+  template <typename Last> static constexpr bool check_last() {
+    return check<Last>();
+  }
+
+public:
+  static constexpr bool value = sizeof...(Args) > 0 && check_last<Args...>();
+};
+
+// HasConstructorTraits<T> could be removed as typename
+// ConstructorTraits<T>::arg_types would still resolve the concept to false if
+// it wouldn't be defined, but we keep it for readability
+template <typename T>
+concept ValidConstructorTraits =
+    HasConstructorTraits<T> &&
+    ConstructibleFromTuple<T, typename ConstructorTraits<T>::arg_types>;
+
+template <typename T>
+concept CallInvokerLastInConstructor =
+    HasConstructorTraits<T> &&
+    last_element_is_call_invoker<
+        typename ConstructorTraits<T>::arg_types>::value;
+
+template <typename... Types, std::size_t... I>
+std::tuple<Types...> fillConstructorTupleFromArgs(
+    std::index_sequence<I...>, const jsi::Value *args, jsi::Runtime &runtime,
+    std::shared_ptr<react::CallInvoker> jsCallInvoker) {
+  constexpr std::size_t lastIndex = sizeof...(Types) - 1;
+  return std::make_tuple([&]() {
+    if constexpr (I == lastIndex) {
+      return jsCallInvoker;
+    } else {
+      return jsiconversion::getValue<Types>(args[I], runtime);
+    }
+  }()...);
+}
+
+/// @brief A method that creates a tuple of arguments based on types specified
+/// in a ConstructorTraits specialization. The class has to have CallInvoker as
+/// the last argument in the constructor.
+/// @tparam T The class for which we want to construct the tuple
+/// @param args JSI args passed from JS that will be converted according to
+/// getValue<T> from JsiConversions
+/// @param runtime JS runtime reference
+/// @param jsCallInvoker CallInvoker that will be passed to the constructed
+/// object. This is the only argument that is not created from jsi::Value.
+/// @return A tuple which can then be used to instantiate the class T.
+template <typename T>
+  requires ValidConstructorTraits<T> && CallInvokerLastInConstructor<T>
+auto createConstructorArgsWithCallInvoker(
+    const jsi::Value *args, jsi::Runtime &runtime,
+    std::shared_ptr<react::CallInvoker> jsCallInvoker) {
+  return std::apply(
+      [&](auto... typeWrappers) {
+        return fillConstructorTupleFromArgs<decltype(typeWrappers)...>(
+            std::index_sequence_for<decltype(typeWrappers)...>{}, args, runtime,
+            jsCallInvoker);
+      },
+      typename ConstructorTraits<T>::arg_types{});
+}
+
+} // namespace meta
+
+// A helper macro to create ConstructorTraits for a class. The variadic pack
+// ("...") should list the types of the constructor arguments.
+// A class declaration is added so that we don't need to include the class
+// definition.
+#define REGISTER_CONSTRUCTOR(Class, ...)                                       \
+  class Class;                                                                 \
+  template <> struct meta::ConstructorTraits<Class> {                          \
+    using arg_types = std::tuple<__VA_ARGS__>;                                 \
+  }
+
+} // namespace rnexecutorch

package/common/rnexecutorch/metaprogramming/FunctionHelpers.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <cstddef>
+#include <jsi/jsi.h>
+#include <tuple>
+
+#include <rnexecutorch/host_objects/JsiConversions.h>
+
+namespace rnexecutorch::meta {
+using namespace facebook;
+
+template <typename Model, typename R, typename... Types>
+constexpr std::size_t getArgumentCount(R (Model::*f)(Types...)) {
+  return sizeof...(Types);
+}
+
+template <typename Model, typename R, typename... Types>
+constexpr std::size_t getArgumentCount(R (Model::*f)(Types...) const) {
+  return sizeof...(Types);
+}
+
+template <typename... Types, std::size_t... I>
+std::tuple<Types...> fillTupleFromArgs(std::index_sequence<I...>,
+                                       const jsi::Value *args,
+                                       jsi::Runtime &runtime) {
+  return std::make_tuple(jsiconversion::getValue<Types>(args[I], runtime)...);
+}
+
+/**
+ * createArgsTupleFromJsi creates a tuple that can be used as a collection of
+ * arguments for method supplied with a pointer. The types in the tuple are
+ * inferred from the method pointer.
+ */
+
+template <typename Model, typename R, typename... Types>
+std::tuple<Types...> createArgsTupleFromJsi(R (Model::*f)(Types...),
+                                            const jsi::Value *args,
+                                            jsi::Runtime &runtime) {
+  return fillTupleFromArgs<Types...>(std::index_sequence_for<Types...>{}, args,
+                                     runtime);
+}
+
+template <typename Model, typename R, typename... Types>
+std::tuple<Types...> createArgsTupleFromJsi(R (Model::*f)(Types...) const,
+                                            const jsi::Value *args,
+                                            jsi::Runtime &runtime) {
+  return fillTupleFromArgs<Types...>(std::index_sequence_for<Types...>{}, args,
+                                     runtime);
+}
+} // namespace rnexecutorch::meta