react-native-nitro-net 0.1.5

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

@@ -0,0 +1,74 @@
+///
+/// HybridNetDriverSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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 `HybridNetSocketDriverSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
+// Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridNetServerDriverSpec; }
+// Forward declaration of `NetConfig` to properly resolve imports.
+namespace margelo::nitro::net { struct NetConfig; }
+
+#include <memory>
+#include "HybridNetSocketDriverSpec.hpp"
+#include <string>
+#include <optional>
+#include "HybridNetServerDriverSpec.hpp"
+#include "NetConfig.hpp"
+
+namespace margelo::nitro::net {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NetDriver`
+   * Inherit this class to create instances of `HybridNetDriverSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNetDriver: public HybridNetDriverSpec {
+   * public:
+   *   HybridNetDriver(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNetDriverSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNetDriverSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNetDriverSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridNetSocketDriverSpec> createSocket(const std::optional<std::string>& id) = 0;
+      virtual std::shared_ptr<HybridNetServerDriverSpec> createServer() = 0;
+      virtual void initWithConfig(const NetConfig& config) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NetDriver";
+  };
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,29 @@
+///
+/// HybridNetServerDriverSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNetServerDriverSpec.hpp"
+
+namespace margelo::nitro::net {
+
+  void HybridNetServerDriverSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("onEvent", &HybridNetServerDriverSpec::getOnEvent);
+      prototype.registerHybridSetter("onEvent", &HybridNetServerDriverSpec::setOnEvent);
+      prototype.registerHybridGetter("maxConnections", &HybridNetServerDriverSpec::getMaxConnections);
+      prototype.registerHybridSetter("maxConnections", &HybridNetServerDriverSpec::setMaxConnections);
+      prototype.registerHybridMethod("listen", &HybridNetServerDriverSpec::listen);
+      prototype.registerHybridMethod("listenUnix", &HybridNetServerDriverSpec::listenUnix);
+      prototype.registerHybridMethod("listenHandle", &HybridNetServerDriverSpec::listenHandle);
+      prototype.registerHybridMethod("getLocalAddress", &HybridNetServerDriverSpec::getLocalAddress);
+      prototype.registerHybridMethod("close", &HybridNetServerDriverSpec::close);
+    });
+  }
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,72 @@
+///
+/// HybridNetServerDriverSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <functional>
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::net {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NetServerDriver`
+   * Inherit this class to create instances of `HybridNetServerDriverSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNetServerDriver: public HybridNetServerDriverSpec {
+   * public:
+   *   HybridNetServerDriver(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNetServerDriverSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNetServerDriverSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNetServerDriverSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)> getOnEvent() = 0;
+      virtual void setOnEvent(const std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)>& onEvent) = 0;
+      virtual double getMaxConnections() = 0;
+      virtual void setMaxConnections(double maxConnections) = 0;
+
+    public:
+      // Methods
+      virtual void listen(double port, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) = 0;
+      virtual void listenUnix(const std::string& path, std::optional<double> backlog) = 0;
+      virtual void listenHandle(double fd, std::optional<double> backlog) = 0;
+      virtual std::string getLocalAddress() = 0;
+      virtual void close() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NetServerDriver";
+  };
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,36 @@
+///
+/// HybridNetSocketDriverSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNetSocketDriverSpec.hpp"
+
+namespace margelo::nitro::net {
+
+  void HybridNetSocketDriverSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("id", &HybridNetSocketDriverSpec::getId);
+      prototype.registerHybridGetter("onEvent", &HybridNetSocketDriverSpec::getOnEvent);
+      prototype.registerHybridSetter("onEvent", &HybridNetSocketDriverSpec::setOnEvent);
+      prototype.registerHybridMethod("connect", &HybridNetSocketDriverSpec::connect);
+      prototype.registerHybridMethod("connectUnix", &HybridNetSocketDriverSpec::connectUnix);
+      prototype.registerHybridMethod("write", &HybridNetSocketDriverSpec::write);
+      prototype.registerHybridMethod("pause", &HybridNetSocketDriverSpec::pause);
+      prototype.registerHybridMethod("resume", &HybridNetSocketDriverSpec::resume);
+      prototype.registerHybridMethod("shutdown", &HybridNetSocketDriverSpec::shutdown);
+      prototype.registerHybridMethod("setTimeout", &HybridNetSocketDriverSpec::setTimeout);
+      prototype.registerHybridMethod("destroy", &HybridNetSocketDriverSpec::destroy);
+      prototype.registerHybridMethod("resetAndDestroy", &HybridNetSocketDriverSpec::resetAndDestroy);
+      prototype.registerHybridMethod("setNoDelay", &HybridNetSocketDriverSpec::setNoDelay);
+      prototype.registerHybridMethod("setKeepAlive", &HybridNetSocketDriverSpec::setKeepAlive);
+      prototype.registerHybridMethod("getLocalAddress", &HybridNetSocketDriverSpec::getLocalAddress);
+      prototype.registerHybridMethod("getRemoteAddress", &HybridNetSocketDriverSpec::getRemoteAddress);
+    });
+  }
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,78 @@
+///
+/// HybridNetSocketDriverSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <functional>
+#include <string>
+
+namespace margelo::nitro::net {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NetSocketDriver`
+   * Inherit this class to create instances of `HybridNetSocketDriverSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNetSocketDriver: public HybridNetSocketDriverSpec {
+   * public:
+   *   HybridNetSocketDriver(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNetSocketDriverSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNetSocketDriverSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNetSocketDriverSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getId() = 0;
+      virtual std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)> getOnEvent() = 0;
+      virtual void setOnEvent(const std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)>& onEvent) = 0;
+
+    public:
+      // Methods
+      virtual void connect(const std::string& host, double port) = 0;
+      virtual void connectUnix(const std::string& path) = 0;
+      virtual void write(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual void pause() = 0;
+      virtual void resume() = 0;
+      virtual void shutdown() = 0;
+      virtual void setTimeout(double timeout) = 0;
+      virtual void destroy() = 0;
+      virtual void resetAndDestroy() = 0;
+      virtual void setNoDelay(bool enable) = 0;
+      virtual void setKeepAlive(bool enable, double delay) = 0;
+      virtual std::string getLocalAddress() = 0;
+      virtual std::string getRemoteAddress() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NetSocketDriver";
+  };
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,32 @@
+///
+/// HybridNitroBufferSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroBufferSpec.hpp"
+
+namespace margelo::nitro::net {
+
+  void HybridNitroBufferSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("alloc", &HybridNitroBufferSpec::alloc);
+      prototype.registerHybridMethod("allocUnsafe", &HybridNitroBufferSpec::allocUnsafe);
+      prototype.registerHybridMethod("byteLength", &HybridNitroBufferSpec::byteLength);
+      prototype.registerHybridMethod("write", &HybridNitroBufferSpec::write);
+      prototype.registerHybridMethod("decode", &HybridNitroBufferSpec::decode);
+      prototype.registerHybridMethod("compare", &HybridNitroBufferSpec::compare);
+      prototype.registerHybridMethod("fill", &HybridNitroBufferSpec::fill);
+      prototype.registerHybridMethod("indexOf", &HybridNitroBufferSpec::indexOf);
+      prototype.registerHybridMethod("indexOfBuffer", &HybridNitroBufferSpec::indexOfBuffer);
+      prototype.registerHybridMethod("lastIndexOfByte", &HybridNitroBufferSpec::lastIndexOfByte);
+      prototype.registerHybridMethod("lastIndexOfBuffer", &HybridNitroBufferSpec::lastIndexOfBuffer);
+      prototype.registerHybridMethod("fillBuffer", &HybridNitroBufferSpec::fillBuffer);
+    });
+  }
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,74 @@
+///
+/// HybridNitroBufferSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+
+namespace margelo::nitro::net {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NitroBuffer`
+   * Inherit this class to create instances of `HybridNitroBufferSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNitroBuffer: public HybridNitroBufferSpec {
+   * public:
+   *   HybridNitroBuffer(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNitroBufferSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNitroBufferSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNitroBufferSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> alloc(double size) = 0;
+      virtual std::shared_ptr<ArrayBuffer> allocUnsafe(double size) = 0;
+      virtual double byteLength(const std::string& string, const std::string& encoding) = 0;
+      virtual double write(const std::shared_ptr<ArrayBuffer>& buffer, const std::string& string, double offset, double length, const std::string& encoding) = 0;
+      virtual std::string decode(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double length, const std::string& encoding) = 0;
+      virtual double compare(const std::shared_ptr<ArrayBuffer>& a, double aOffset, double aLength, const std::shared_ptr<ArrayBuffer>& b, double bOffset, double bLength) = 0;
+      virtual void fill(const std::shared_ptr<ArrayBuffer>& buffer, double value, double offset, double length) = 0;
+      virtual double indexOf(const std::shared_ptr<ArrayBuffer>& buffer, double value, double offset, double length) = 0;
+      virtual double indexOfBuffer(const std::shared_ptr<ArrayBuffer>& buffer, const std::shared_ptr<ArrayBuffer>& needle, double offset, double length) = 0;
+      virtual double lastIndexOfByte(const std::shared_ptr<ArrayBuffer>& buffer, double value, double offset, double length) = 0;
+      virtual double lastIndexOfBuffer(const std::shared_ptr<ArrayBuffer>& buffer, const std::shared_ptr<ArrayBuffer>& needle, double offset, double length) = 0;
+      virtual void fillBuffer(const std::shared_ptr<ArrayBuffer>& buffer, const std::shared_ptr<ArrayBuffer>& value, double offset, double length) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NitroBuffer";
+  };
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,83 @@
+///
+/// NetConfig.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+
+
+#include <optional>
+
+namespace margelo::nitro::net {
+
+  /**
+   * A struct which can be represented as a JavaScript object (NetConfig).
+   */
+  struct NetConfig final {
+  public:
+    std::optional<double> workerThreads     SWIFT_PRIVATE;
+
+  public:
+    NetConfig() = default;
+    explicit NetConfig(std::optional<double> workerThreads): workerThreads(workerThreads) {}
+
+  public:
+    friend bool operator==(const NetConfig& lhs, const NetConfig& rhs) = default;
+  };
+
+} // namespace margelo::nitro::net
+
+namespace margelo::nitro {
+
+  // C++ NetConfig <> JS NetConfig (object)
+  template <>
+  struct JSIConverter<margelo::nitro::net::NetConfig> final {
+    static inline margelo::nitro::net::NetConfig fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::net::NetConfig(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "workerThreads")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::net::NetConfig& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "workerThreads"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.workerThreads));
+      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<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "workerThreads")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -0,0 +1,59 @@
+{
+    "name": "react-native-nitro-net",
+    "version": "0.1.5",
+    "description": "Ultra-high-performance networking to React Native by combining a memory-safe Rust core with the zero-overhead Nitro Modules JSI bridge. Provides Node.js-compatible net API.",
+    "main": "./lib/index.js",
+    "module": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "keywords": [
+        "react-native",
+        "ios",
+        "android",
+        "nitro",
+        "net",
+        "socket",
+        "tcp"
+    ],
+    "author": "iwater <iwater@gmail.com>",
+    "license": "ISC",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/iwater/react-native-nitro-net.git"
+    },
+    "bugs": {
+        "url": "https://github.com/iwater/react-native-nitro-net/issues"
+    },
+    "scripts": {
+        "build": "npx nitrogen@0.32.0 && tsc",
+        "prepare": "npm run build",
+        "copy-clib": "rm -rf ios/Frameworks/RustCNet.xcframework && cp -R ../rust_c_net/target/xcframework/RustCNet.xcframework ios/Frameworks/ && mkdir -p android/libs/arm64-v8a android/libs/armeabi-v7a android/libs/x86 android/libs/x86_64 && cp ../rust_c_net/target/aarch64-linux-android/release/librust_c_net.so android/libs/arm64-v8a/ && cp ../rust_c_net/target/armv7-linux-androideabi/release/librust_c_net.so android/libs/armeabi-v7a/ && cp ../rust_c_net/target/i686-linux-android/release/librust_c_net.so android/libs/x86/ && cp ../rust_c_net/target/x86_64-linux-android/release/librust_c_net.so android/libs/x86_64/ && cp ../rust_c_net/include/NetBindings.hpp cpp/",
+        "copy-clib-android": "cp ../rust_c_net/target/aarch64-linux-android/release/librust_c_net.so android/libs/arm64-v8a/ && cp ../rust_c_net/target/armv7-linux-androideabi/release/librust_c_net.so android/libs/armeabi-v7a/ && cp ../rust_c_net/target/i686-linux-android/release/librust_c_net.so android/libs/x86/ && cp ../rust_c_net/target/x86_64-linux-android/release/librust_c_net.so android/libs/x86_64/ && cp ../rust_c_net/include/NetBindings.hpp cpp/",
+        "copy-clib-ios": "rm -rf ios/Frameworks/RustCNet.xcframework && cp -R ../rust_c_net/target/xcframework/RustCNet.xcframework ios/Frameworks/"
+    },
+    "dependencies": {
+        "eventemitter3": "^5.0.1",
+        "react-native-nitro-buffer": "^0.0.11",
+        "readable-stream": "^4.7.0"
+    },
+    "devDependencies": {
+        "@types/node": "*",
+        "@types/readable-stream": "^4.0.23",
+        "nitrogen": "^0.32.0",
+        "react-native-nitro-modules": "^0.32.0",
+        "typescript": "^5.3.3"
+    },
+    "peerDependencies": {
+        "react-native": "*",
+        "react-native-nitro-modules": "^0.32.0"
+    },
+    "packageManager": "yarn@4.12.0",
+    "files": [
+        "lib/",
+        "src/",
+        "cpp/",
+        "ios/",
+        "android/",
+        "nitrogen/",
+        "*.podspec"
+    ]
+}

package/react-native-nitro-net.podspec

@@ -0,0 +1,47 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-nitro-net"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/iwater/react-native-nitro-net"
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  
+  s.platform     = :ios, "13.0"
+  s.source       = { :git => "https://github.com/iwater/react-native-nitro-net.git", :tag => "v#{s.version}" }
+  
+  # Module Name must match iosModuleName in nitro.json
+  s.module_name  = "RustCNet"
+
+  s.source_files = [
+    "ios/**/*.{h,m,mm,swift}",
+    "cpp/**/*.{hpp,cpp}"
+  ]
+  
+  s.dependency "React-Core"
+  
+  # Add vendored xcframework (Rust binary)
+  s.vendored_frameworks = "ios/Frameworks/RustCNet.xcframework"
+  
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => [
+      "\"$(PODS_ROOT)/react-native-nitro-modules/ios\"",
+      "\"$(PODS_ROOT)/Headers/Public/react-native-nitro-modules\"",
+      "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/shared/c++\"",
+      "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/shared\"",
+      "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/ios/c++\"",
+      "\"$(PODS_TARGET_SRCROOT)/nitrogen/generated/ios\"",
+      "\"$(PODS_TARGET_SRCROOT)/cpp\"",
+      "\"$(PODS_TARGET_SRCROOT)/ios/Frameworks/RustCNet.xcframework/ios-arm64/RustCNet.framework/Headers\"",
+      "\"$(PODS_TARGET_SRCROOT)/ios/Frameworks/RustCNet.xcframework/ios-arm64_x86_64-simulator/RustCNet.framework/Headers\""
+    ],
+    "OTHER_SWIFT_FLAGS" => "-cxx-interoperability-mode=default"
+  }
+
+  # Add all files generated by Nitrogen
+  load 'nitrogen/generated/ios/RustCNet+autolinking.rb'
+  add_nitrogen_files(s)
+end

package/src/Driver.ts

@@ -0,0 +1,4 @@
+import { NitroModules } from 'react-native-nitro-modules'
+import type { NetDriver } from './Net.nitro'
+
+export const Driver = NitroModules.createHybridObject<NetDriver>('NetDriver')