@delali/narsil-react-native 0.0.0-stage → 0.3.1-next.151

package/nitrogen/generated/shared/c++/GraphMemory.hpp

@@ -0,0 +1,120 @@
+///
+/// GraphMemory.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `MemoryView` to properly resolve imports.
+namespace margelo::nitro::narsil { struct MemoryView; }
+
+#include "MemoryView.hpp"
+
+namespace margelo::nitro::narsil {
+
+  /**
+   * A struct which can be represented as a JavaScript object (GraphMemory).
+   */
+  struct GraphMemory final {
+  public:
+    MemoryView graphHeader     SWIFT_PRIVATE;
+    MemoryView nodeLevels     SWIFT_PRIVATE;
+    MemoryView level0     SWIFT_PRIVATE;
+    MemoryView upperBase     SWIFT_PRIVATE;
+    MemoryView upper     SWIFT_PRIVATE;
+    MemoryView locks     SWIFT_PRIVATE;
+    MemoryView tombstones     SWIFT_PRIVATE;
+    MemoryView incoming     SWIFT_PRIVATE;
+    MemoryView nearestLinkDue     SWIFT_PRIVATE;
+    MemoryView heldLocks     SWIFT_PRIVATE;
+
+  public:
+    GraphMemory() = default;
+    explicit GraphMemory(MemoryView graphHeader, MemoryView nodeLevels, MemoryView level0, MemoryView upperBase, MemoryView upper, MemoryView locks, MemoryView tombstones, MemoryView incoming, MemoryView nearestLinkDue, MemoryView heldLocks): graphHeader(graphHeader), nodeLevels(nodeLevels), level0(level0), upperBase(upperBase), upper(upper), locks(locks), tombstones(tombstones), incoming(incoming), nearestLinkDue(nearestLinkDue), heldLocks(heldLocks) {}
+
+  public:
+    friend bool operator==(const GraphMemory& lhs, const GraphMemory& rhs) = default;
+  };
+
+} // namespace margelo::nitro::narsil
+
+namespace margelo::nitro {
+
+  // C++ GraphMemory <> JS GraphMemory (object)
+  template <>
+  struct JSIConverter<margelo::nitro::narsil::GraphMemory> final {
+    static inline margelo::nitro::narsil::GraphMemory fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::narsil::GraphMemory(
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "graphHeader"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nodeLevels"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "level0"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "upperBase"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "upper"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "locks"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tombstones"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "incoming"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nearestLinkDue"))),
+        JSIConverter<margelo::nitro::narsil::MemoryView>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "heldLocks")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::narsil::GraphMemory& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "graphHeader"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.graphHeader));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "nodeLevels"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.nodeLevels));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "level0"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.level0));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "upperBase"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.upperBase));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "upper"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.upper));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "locks"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.locks));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "tombstones"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.tombstones));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "incoming"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.incoming));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "nearestLinkDue"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.nearestLinkDue));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "heldLocks"), JSIConverter<margelo::nitro::narsil::MemoryView>::toJSI(runtime, arg.heldLocks));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "graphHeader")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nodeLevels")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "level0")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "upperBase")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "upper")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "locks")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tombstones")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "incoming")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nearestLinkDue")))) return false;
+      if (!JSIConverter<margelo::nitro::narsil::MemoryView>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "heldLocks")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridNarsilAttachedGraphSpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridNarsilAttachedGraphSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNarsilAttachedGraphSpec.hpp"
+
+namespace margelo::nitro::narsil {
+
+  void HybridNarsilAttachedGraphSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      
+    });
+  }
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilAttachedGraphSpec.hpp

@@ -0,0 +1,62 @@
+///
+/// HybridNarsilAttachedGraphSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::narsil {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NarsilAttachedGraph`
+   * Inherit this class to create instances of `HybridNarsilAttachedGraphSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNarsilAttachedGraph: public HybridNarsilAttachedGraphSpec {
+   * public:
+   *   HybridNarsilAttachedGraph(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNarsilAttachedGraphSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNarsilAttachedGraphSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNarsilAttachedGraphSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NarsilAttachedGraph";
+  };
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilAttachedStoreSpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridNarsilAttachedStoreSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNarsilAttachedStoreSpec.hpp"
+
+namespace margelo::nitro::narsil {
+
+  void HybridNarsilAttachedStoreSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("detach", &HybridNarsilAttachedStoreSpec::detach);
+    });
+  }
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilAttachedStoreSpec.hpp

@@ -0,0 +1,62 @@
+///
+/// HybridNarsilAttachedStoreSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::narsil {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NarsilAttachedStore`
+   * Inherit this class to create instances of `HybridNarsilAttachedStoreSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNarsilAttachedStore: public HybridNarsilAttachedStoreSpec {
+   * public:
+   *   HybridNarsilAttachedStore(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNarsilAttachedStoreSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNarsilAttachedStoreSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNarsilAttachedStoreSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual double detach() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NarsilAttachedStore";
+  };
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilCoreSpec.cpp

@@ -0,0 +1,35 @@
+///
+/// HybridNarsilCoreSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNarsilCoreSpec.hpp"
+
+namespace margelo::nitro::narsil {
+
+  void HybridNarsilCoreSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("abiVersion", &HybridNarsilCoreSpec::abiVersion);
+      prototype.registerHybridMethod("workspaceBytes", &HybridNarsilCoreSpec::workspaceBytes);
+      prototype.registerHybridMethod("attachGraph", &HybridNarsilCoreSpec::attachGraph);
+      prototype.registerHybridMethod("attachStore", &HybridNarsilCoreSpec::attachStore);
+      prototype.registerHybridMethod("search", &HybridNarsilCoreSpec::search);
+      prototype.registerHybridMethod("searchAsync", &HybridNarsilCoreSpec::searchAsync);
+      prototype.registerHybridMethod("scoreAsync", &HybridNarsilCoreSpec::scoreAsync);
+      prototype.registerHybridMethod("score", &HybridNarsilCoreSpec::score);
+      prototype.registerHybridMethod("place", &HybridNarsilCoreSpec::place);
+      prototype.registerHybridMethod("remove", &HybridNarsilCoreSpec::remove);
+      prototype.registerHybridMethod("compact", &HybridNarsilCoreSpec::compact);
+      prototype.registerHybridMethod("connectUnreached", &HybridNarsilCoreSpec::connectUnreached);
+      prototype.registerHybridMethod("connectUnreachedAsync", &HybridNarsilCoreSpec::connectUnreachedAsync);
+      prototype.registerHybridMethod("measure", &HybridNarsilCoreSpec::measure);
+      prototype.registerHybridMethod("quantise", &HybridNarsilCoreSpec::quantise);
+    });
+  }
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilCoreSpec.hpp

@@ -0,0 +1,100 @@
+///
+/// HybridNarsilCoreSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridNarsilAttachedGraphSpec` to properly resolve imports.
+namespace margelo::nitro::narsil { class HybridNarsilAttachedGraphSpec; }
+// Forward declaration of `GraphMemory` to properly resolve imports.
+namespace margelo::nitro::narsil { struct GraphMemory; }
+// Forward declaration of `HybridNarsilAttachedStoreSpec` to properly resolve imports.
+namespace margelo::nitro::narsil { class HybridNarsilAttachedStoreSpec; }
+// Forward declaration of `StoreMemory` to properly resolve imports.
+namespace margelo::nitro::narsil { struct StoreMemory; }
+// Forward declaration of `MemoryView` to properly resolve imports.
+namespace margelo::nitro::narsil { struct MemoryView; }
+// Forward declaration of `NativeSearchHits` to properly resolve imports.
+namespace margelo::nitro::narsil { struct NativeSearchHits; }
+// Forward declaration of `NativeScores` to properly resolve imports.
+namespace margelo::nitro::narsil { struct NativeScores; }
+// Forward declaration of `NativeConnectOutcome` to properly resolve imports.
+namespace margelo::nitro::narsil { struct NativeConnectOutcome; }
+
+#include <memory>
+#include "HybridNarsilAttachedGraphSpec.hpp"
+#include "GraphMemory.hpp"
+#include "HybridNarsilAttachedStoreSpec.hpp"
+#include "StoreMemory.hpp"
+#include "MemoryView.hpp"
+#include "NativeSearchHits.hpp"
+#include <NitroModules/Promise.hpp>
+#include "NativeScores.hpp"
+#include "NativeConnectOutcome.hpp"
+
+namespace margelo::nitro::narsil {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NarsilCore`
+   * Inherit this class to create instances of `HybridNarsilCoreSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNarsilCore: public HybridNarsilCoreSpec {
+   * public:
+   *   HybridNarsilCore(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNarsilCoreSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNarsilCoreSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNarsilCoreSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual double abiVersion() = 0;
+      virtual double workspaceBytes() = 0;
+      virtual std::shared_ptr<HybridNarsilAttachedGraphSpec> attachGraph(const GraphMemory& memory) = 0;
+      virtual std::shared_ptr<HybridNarsilAttachedStoreSpec> attachStore(const StoreMemory& memory) = 0;
+      virtual double search(const std::shared_ptr<HybridNarsilAttachedGraphSpec>& graph, const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, const MemoryView& query, double metric, double candidateCount, double threadSlot, const MemoryView& ordinals, const MemoryView& distances, const MemoryView& accepted, bool filtered) = 0;
+      virtual std::shared_ptr<Promise<NativeSearchHits>> searchAsync(const std::shared_ptr<HybridNarsilAttachedGraphSpec>& graph, const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, const MemoryView& query, double metric, double candidateCount, double threadSlot, const MemoryView& accepted, bool filtered) = 0;
+      virtual std::shared_ptr<Promise<NativeScores>> scoreAsync(const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, const MemoryView& query, double metric, const MemoryView& ordinals, double count, double threadSlot) = 0;
+      virtual double score(const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, const MemoryView& query, double metric, const MemoryView& ordinals, double count, const MemoryView& distances) = 0;
+      virtual double place(const std::shared_ptr<HybridNarsilAttachedGraphSpec>& graph, const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, double metric, double ordinal, double topLayer, double graphHeldAlone, double threadSlot, const MemoryView& wakes) = 0;
+      virtual double remove(const std::shared_ptr<HybridNarsilAttachedGraphSpec>& graph, double ordinal, double threadSlot, const MemoryView& wakes) = 0;
+      virtual double compact(const std::shared_ptr<HybridNarsilAttachedGraphSpec>& graph, const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, double metric, double threadSlot, const MemoryView& wakes) = 0;
+      virtual double connectUnreached(const std::shared_ptr<HybridNarsilAttachedGraphSpec>& graph, const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, double metric, const MemoryView& nearby, double threadSlot, const MemoryView& wakes) = 0;
+      virtual std::shared_ptr<Promise<NativeConnectOutcome>> connectUnreachedAsync(const std::shared_ptr<HybridNarsilAttachedGraphSpec>& graph, const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, double metric, const MemoryView& nearby, double threadSlot) = 0;
+      virtual double measure(const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, double metric, const MemoryView& ordinals, double count, const MemoryView& totals) = 0;
+      virtual double quantise(const std::shared_ptr<HybridNarsilAttachedStoreSpec>& store, double metric, const MemoryView& ordinals, double count) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NarsilCore";
+  };
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilFilesSpec.cpp

@@ -0,0 +1,37 @@
+///
+/// HybridNarsilFilesSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNarsilFilesSpec.hpp"
+
+namespace margelo::nitro::narsil {
+
+  void HybridNarsilFilesSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("open", &HybridNarsilFilesSpec::open);
+      prototype.registerHybridMethod("close", &HybridNarsilFilesSpec::close);
+      prototype.registerHybridMethod("read", &HybridNarsilFilesSpec::read);
+      prototype.registerHybridMethod("write", &HybridNarsilFilesSpec::write);
+      prototype.registerHybridMethod("sync", &HybridNarsilFilesSpec::sync);
+      prototype.registerHybridMethod("readAsync", &HybridNarsilFilesSpec::readAsync);
+      prototype.registerHybridMethod("writeAsync", &HybridNarsilFilesSpec::writeAsync);
+      prototype.registerHybridMethod("syncAsync", &HybridNarsilFilesSpec::syncAsync);
+      prototype.registerHybridMethod("truncate", &HybridNarsilFilesSpec::truncate);
+      prototype.registerHybridMethod("descriptorStatus", &HybridNarsilFilesSpec::descriptorStatus);
+      prototype.registerHybridMethod("pathStatus", &HybridNarsilFilesSpec::pathStatus);
+      prototype.registerHybridMethod("makeDirectory", &HybridNarsilFilesSpec::makeDirectory);
+      prototype.registerHybridMethod("readDirectory", &HybridNarsilFilesSpec::readDirectory);
+      prototype.registerHybridMethod("rename", &HybridNarsilFilesSpec::rename);
+      prototype.registerHybridMethod("unlink", &HybridNarsilFilesSpec::unlink);
+      prototype.registerHybridMethod("removeDirectory", &HybridNarsilFilesSpec::removeDirectory);
+      prototype.registerHybridMethod("link", &HybridNarsilFilesSpec::link);
+    });
+  }
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilFilesSpec.hpp

@@ -0,0 +1,86 @@
+///
+/// HybridNarsilFilesSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `FileStatus` to properly resolve imports.
+namespace margelo::nitro::narsil { struct FileStatus; }
+// Forward declaration of `DirectoryEntry` to properly resolve imports.
+namespace margelo::nitro::narsil { struct DirectoryEntry; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include "FileStatus.hpp"
+#include "DirectoryEntry.hpp"
+#include <vector>
+
+namespace margelo::nitro::narsil {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NarsilFiles`
+   * Inherit this class to create instances of `HybridNarsilFilesSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNarsilFiles: public HybridNarsilFilesSpec {
+   * public:
+   *   HybridNarsilFiles(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNarsilFilesSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNarsilFilesSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNarsilFilesSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual double open(const std::string& path, const std::string& flags) = 0;
+      virtual void close(double descriptor) = 0;
+      virtual double read(double descriptor, const std::shared_ptr<ArrayBuffer>& target, double byteOffset, double byteLength, double position) = 0;
+      virtual double write(double descriptor, const std::shared_ptr<ArrayBuffer>& source, double byteOffset, double byteLength, double position) = 0;
+      virtual void sync(double descriptor) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> readAsync(double descriptor, double byteLength, double position) = 0;
+      virtual std::shared_ptr<Promise<double>> writeAsync(double descriptor, const std::shared_ptr<ArrayBuffer>& source, double byteOffset, double byteLength, double position) = 0;
+      virtual std::shared_ptr<Promise<void>> syncAsync(double descriptor) = 0;
+      virtual void truncate(double descriptor, double byteLength) = 0;
+      virtual FileStatus descriptorStatus(double descriptor) = 0;
+      virtual FileStatus pathStatus(const std::string& path) = 0;
+      virtual void makeDirectory(const std::string& path) = 0;
+      virtual std::vector<DirectoryEntry> readDirectory(const std::string& path) = 0;
+      virtual void rename(const std::string& from, const std::string& to) = 0;
+      virtual void unlink(const std::string& path) = 0;
+      virtual void removeDirectory(const std::string& path) = 0;
+      virtual void link(const std::string& existingPath, const std::string& newPath) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NarsilFiles";
+  };
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilHostSpec.cpp

@@ -0,0 +1,34 @@
+///
+/// HybridNarsilHostSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNarsilHostSpec.hpp"
+
+namespace margelo::nitro::narsil {
+
+  void HybridNarsilHostSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("reserveMemory", &HybridNarsilHostSpec::reserveMemory);
+      prototype.registerHybridMethod("allocateMemory", &HybridNarsilHostSpec::allocateMemory);
+      prototype.registerHybridMethod("ownsMemory", &HybridNarsilHostSpec::ownsMemory);
+      prototype.registerHybridMethod("atomic", &HybridNarsilHostSpec::atomic);
+      prototype.registerHybridMethod("fillRandom", &HybridNarsilHostSpec::fillRandom);
+      prototype.registerHybridMethod("processId", &HybridNarsilHostSpec::processId);
+      prototype.registerHybridMethod("processStartedAtMs", &HybridNarsilHostSpec::processStartedAtMs);
+      prototype.registerHybridMethod("processIsAlive", &HybridNarsilHostSpec::processIsAlive);
+      prototype.registerHybridMethod("processMemory", &HybridNarsilHostSpec::processMemory);
+      prototype.registerHybridMethod("appStorageDirectory", &HybridNarsilHostSpec::appStorageDirectory);
+      prototype.registerHybridMethod("deflateRaw", &HybridNarsilHostSpec::deflateRaw);
+      prototype.registerHybridMethod("inflateRaw", &HybridNarsilHostSpec::inflateRaw);
+      prototype.registerHybridMethod("gzip", &HybridNarsilHostSpec::gzip);
+      prototype.registerHybridMethod("gunzip", &HybridNarsilHostSpec::gunzip);
+    });
+  }
+
+} // namespace margelo::nitro::narsil

package/nitrogen/generated/shared/c++/HybridNarsilHostSpec.hpp

@@ -0,0 +1,78 @@
+///
+/// HybridNarsilHostSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ProcessMemory` to properly resolve imports.
+namespace margelo::nitro::narsil { struct ProcessMemory; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include "ProcessMemory.hpp"
+#include <string>
+
+namespace margelo::nitro::narsil {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NarsilHost`
+   * Inherit this class to create instances of `HybridNarsilHostSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNarsilHost: public HybridNarsilHostSpec {
+   * public:
+   *   HybridNarsilHost(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNarsilHostSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNarsilHostSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNarsilHostSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> reserveMemory(double bytes) = 0;
+      virtual std::shared_ptr<ArrayBuffer> allocateMemory(double bytes) = 0;
+      virtual bool ownsMemory(const std::shared_ptr<ArrayBuffer>& buffer) = 0;
+      virtual double atomic(double operation, double elementKind, const std::shared_ptr<ArrayBuffer>& buffer, double byteIndex, double value, double replacement) = 0;
+      virtual void fillRandom(const std::shared_ptr<ArrayBuffer>& target, double byteOffset, double byteLength) = 0;
+      virtual double processId() = 0;
+      virtual double processStartedAtMs() = 0;
+      virtual bool processIsAlive(double processId) = 0;
+      virtual ProcessMemory processMemory() = 0;
+      virtual std::string appStorageDirectory() = 0;
+      virtual std::shared_ptr<ArrayBuffer> deflateRaw(const std::shared_ptr<ArrayBuffer>& source, double byteOffset, double byteLength) = 0;
+      virtual std::shared_ptr<ArrayBuffer> inflateRaw(const std::shared_ptr<ArrayBuffer>& source, double byteOffset, double byteLength, double rawByteLength) = 0;
+      virtual std::shared_ptr<ArrayBuffer> gzip(const std::shared_ptr<ArrayBuffer>& source, double byteOffset, double byteLength) = 0;
+      virtual std::shared_ptr<ArrayBuffer> gunzip(const std::shared_ptr<ArrayBuffer>& source, double byteOffset, double byteLength, double maxByteLength) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NarsilHost";
+  };
+
+} // namespace margelo::nitro::narsil