react-native-nitro-net 0.2.0 → 0.3.0

package/lib/tls.js

@@ -11,6 +11,12 @@ exports.parseCertString = parseCertString;
 exports.convertTLSV1CertToPEM = convertTLSV1CertToPEM;
 const index_1 = require("./index");
 const Driver_1 = require("./Driver");
+function debugLog(message) {
+    if ((0, index_1.isVerbose)()) {
+        const timestamp = new Date().toISOString().split('T')[1].split('Z')[0];
+        console.log(`[NET DEBUG ${timestamp}] ${message}`);
+    }
+}
 exports.DEFAULT_MIN_VERSION = 'TLSv1.2';
 exports.DEFAULT_MAX_VERSION = 'TLSv1.3';
 exports.rootCertificates = [];
@@ -131,13 +137,48 @@ class TLSSocket extends index_1.Socket {
     }
     renegotiate(options, callback) {
         if (callback) {
-            process.nextTick(() => callback(new Error('Renegotiation is not supported by rustls')));
+            setTimeout(() => {
+                const err = new Error('Renegotiation is not supported by rustls');
+                err.code = 'ERR_TLS_RENEGOTIATION_DISABLED';
+                callback(err);
+            }, 0);
         }
         return false;
     }
     disableRenegotiation() {
         // No-op, already effectively disabled
     }
+    /**
+     * Enables trace output for this socket.
+     */
+    enableTrace() {
+        const driver = this._driver;
+        if (driver) {
+            driver.enableTrace();
+        }
+    }
+    /**
+     * Exports keying material for use by external protocols.
+     *
+     * @param length The number of bytes to return.
+     * @param label A label identifying the keying material.
+     * @param context An optional context.
+     * @returns Buffer containing keying material.
+     * @throws Error if export fails (e.g., TLS not connected).
+     */
+    exportKeyingMaterial(length, label, context) {
+        const driver = this._driver;
+        if (driver) {
+            const ctx = context ? new Uint8Array(context).buffer : undefined;
+            const result = driver.exportKeyingMaterial(length, label, ctx);
+            if (result) {
+                return Buffer.from(result);
+            }
+        }
+        const err = new Error('exportKeyingMaterial failed: TLS connection may not be established');
+        err.code = 'ERR_TLS_EXPORT_KEYING_MATERIAL';
+        throw err;
+    }
     constructor(socketOrOptions, options) {
         let opts = {};
         if (socketOrOptions instanceof index_1.Socket) {
@@ -174,6 +215,21 @@ class TLSSocket extends index_1.Socket {
             if (connectionListener)
                 this.once('secureConnect', connectionListener);
             this.once('connect', () => {
+                // After the native TLS handshake, perform hostname verification
+                if (rejectUnauthorized !== false) {
+                    const cert = this.getPeerCertificate();
+                    if (cert && Object.keys(cert).length > 0) {
+                        const verifyFn = (typeof options === 'object' && options.checkServerIdentity)
+                            ? options.checkServerIdentity
+                            : checkServerIdentity;
+                        const verifyErr = verifyFn(servername, cert);
+                        if (verifyErr) {
+                            this.emit('error', verifyErr);
+                            this.destroy(verifyErr);
+                            return;
+                        }
+                    }
+                }
                 this.emit('secureConnect');
             });
             if (session) {
@@ -194,17 +250,21 @@ class TLSSocket extends index_1.Socket {
             }
             if (path) {
                 if (secureContextId !== undefined) {
+                    debugLog(`TLSSocket.connect: Calling driver.connectUnixTLSWithContext(${path}, ${servername}, ctx=${secureContextId})`);
                     driver.connectUnixTLSWithContext(path, servername, rejectUnauthorized, secureContextId);
                 }
                 else {
+                    debugLog(`TLSSocket.connect: Calling driver.connectUnixTLS(${path}, ${servername})`);
                     driver.connectUnixTLS(path, servername, rejectUnauthorized);
                 }
             }
             else {
                 if (secureContextId !== undefined) {
+                    debugLog(`TLSSocket.connect: Calling driver.connectTLSWithContext(${host}, ${port}, ${servername}, ctx=${secureContextId})`);
                     driver.connectTLSWithContext(host, port, servername, rejectUnauthorized, secureContextId);
                 }
                 else {
+                    debugLog(`TLSSocket.connect: Calling driver.connectTLS(${host}, ${port}, ${servername})`);
                     driver.connectTLS(host, port, servername, rejectUnauthorized);
                 }
             }
@@ -261,6 +321,10 @@ class Server extends index_1.Server {
                 ca: options.ca
             }).id;
         }
+        else {
+            // Create empty secure context to allow late configuration (addContext)
+            this._secureContextId = createSecureContext().id;
+        }
         this.on('connection', (socket) => {
             const tlsSocket = new TLSSocket(socket);
             this.emit('secureConnection', tlsSocket);
@@ -338,10 +402,16 @@ class Server extends index_1.Server {
         if (_callback)
             this.once('listening', _callback);
         const driver = this._driver;
-        if (handle || _path) {
-            console.warn("TLS over Unix sockets/handles not fully implemented yet");
+        if (_path) {
+            driver.listenTLSUnix(_path, this._secureContextId, _backlog);
+        }
+        else if (handle) {
+            console.warn("TLS over handles not fully implemented yet");
+            driver.listenTLS(_port || 0, this._secureContextId, _backlog, ipv6Only, reusePort);
+        }
+        else {
+            driver.listenTLS(_port || 0, this._secureContextId, _backlog, ipv6Only, reusePort);
         }
-        driver.listenTLS(_port || 0, this._secureContextId, _backlog, ipv6Only, reusePort);
         return this;
     }
 }

package/nitrogen/generated/android/RustCNet+autolinking.cmake

@@ -35,11 +35,13 @@ target_sources(
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridNetSocketDriverSpec.cpp
   ../nitrogen/generated/shared/c++/HybridNetServerDriverSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHttpParserSpec.cpp
   ../nitrogen/generated/shared/c++/HybridNetDriverSpec.cpp
   ../nitrogen/generated/shared/c++/HybridNitroBufferSpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridNetSocketDriverSpec.cpp
   ../nitrogen/generated/android/c++/JHybridNetServerDriverSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridHttpParserSpec.cpp
   ../nitrogen/generated/android/c++/JHybridNetDriverSpec.cpp
 )
 

package/nitrogen/generated/android/RustCNetOnLoad.cpp

@@ -18,6 +18,7 @@
 #include "JHybridNetSocketDriverSpec.hpp"
 #include "JFunc_void_double_std__shared_ptr_ArrayBuffer_.hpp"
 #include "JHybridNetServerDriverSpec.hpp"
+#include "JHybridHttpParserSpec.hpp"
 #include "JHybridNetDriverSpec.hpp"
 #include "HybridNetDriver.hpp"
 
@@ -33,6 +34,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::net::JHybridNetSocketDriverSpec::registerNatives();
     margelo::nitro::net::JFunc_void_double_std__shared_ptr_ArrayBuffer__cxx::registerNatives();
     margelo::nitro::net::JHybridNetServerDriverSpec::registerNatives();
+    margelo::nitro::net::JHybridHttpParserSpec::registerNatives();
     margelo::nitro::net::JHybridNetDriverSpec::registerNatives();
 
     // Register Nitro Hybrid Objects

package/nitrogen/generated/android/c++/JHybridHttpParserSpec.cpp

@@ -0,0 +1,54 @@
+///
+/// JHybridHttpParserSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridHttpParserSpec.hpp"
+
+
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+
+namespace margelo::nitro::net {
+
+  jni::local_ref<JHybridHttpParserSpec::jhybriddata> JHybridHttpParserSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridHttpParserSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridHttpParserSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridHttpParserSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridHttpParserSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridHttpParserSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::string JHybridHttpParserSpec::feed(const std::shared_ptr<ArrayBuffer>& data) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<JArrayBuffer::javaobject> /* data */)>("feed");
+    auto __result = method(_javaPart, JArrayBuffer::wrap(data));
+    return __result->toStdString();
+  }
+
+} // namespace margelo::nitro::net

package/nitrogen/generated/android/c++/JHybridHttpParserSpec.hpp

@@ -0,0 +1,65 @@
+///
+/// HybridHttpParserSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridHttpParserSpec.hpp"
+
+
+
+
+namespace margelo::nitro::net {
+
+  using namespace facebook;
+
+  class JHybridHttpParserSpec: public jni::HybridClass<JHybridHttpParserSpec, JHybridObject>,
+                               public virtual HybridHttpParserSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/net/HybridHttpParserSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridHttpParserSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridHttpParserSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridHttpParserSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridHttpParserSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::string feed(const std::shared_ptr<ArrayBuffer>& data) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridHttpParserSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::net

package/nitrogen/generated/android/c++/JHybridNetDriverSpec.cpp

@@ -11,6 +11,8 @@
 namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
 // Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
 namespace margelo::nitro::net { class HybridNetServerDriverSpec; }
+// Forward declaration of `HybridHttpParserSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridHttpParserSpec; }
 // Forward declaration of `NetConfig` to properly resolve imports.
 namespace margelo::nitro::net { struct NetConfig; }
 
@@ -19,6 +21,8 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include "JHybridNetSocketDriverSpec.hpp"
 #include "HybridNetServerDriverSpec.hpp"
 #include "JHybridNetServerDriverSpec.hpp"
+#include "HybridHttpParserSpec.hpp"
+#include "JHybridHttpParserSpec.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <optional>
 #include <NitroModules/JArrayBuffer.hpp>
@@ -68,6 +72,11 @@ namespace margelo::nitro::net {
     auto __result = method(_javaPart);
     return __result->cthis()->shared_cast<JHybridNetServerDriverSpec>();
   }
+  std::shared_ptr<HybridHttpParserSpec> JHybridNetDriverSpec::createHttpParser(double mode) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridHttpParserSpec::javaobject>(double /* mode */)>("createHttpParser");
+    auto __result = method(_javaPart, mode);
+    return __result->cthis()->shared_cast<JHybridHttpParserSpec>();
+  }
   double JHybridNetDriverSpec::createSecureContext(const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) {
     static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* cert */, jni::alias_ref<jni::JString> /* key */, jni::alias_ref<jni::JString> /* passphrase */)>("createSecureContext");
     auto __result = method(_javaPart, jni::make_jstring(cert), jni::make_jstring(key), passphrase.has_value() ? jni::make_jstring(passphrase.value()) : nullptr);

package/nitrogen/generated/android/c++/JHybridNetDriverSpec.hpp

@@ -56,6 +56,7 @@ namespace margelo::nitro::net {
     // Methods
     std::shared_ptr<HybridNetSocketDriverSpec> createSocket(const std::optional<std::string>& id) override;
     std::shared_ptr<HybridNetServerDriverSpec> createServer() override;
+    std::shared_ptr<HybridHttpParserSpec> createHttpParser(double mode) override;
     double createSecureContext(const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) override;
     double createEmptySecureContext() override;
     void addCACertToSecureContext(double scId, const std::string& ca) override;

package/nitrogen/generated/android/c++/JHybridNetServerDriverSpec.cpp

@@ -86,6 +86,10 @@ namespace margelo::nitro::net {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */, jni::alias_ref<jni::JDouble> /* backlog */)>("listenUnix");
     method(_javaPart, jni::make_jstring(path), backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr);
   }
+  void JHybridNetServerDriverSpec::listenTLSUnix(const std::string& path, double secureContextId, std::optional<double> backlog) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */, double /* secureContextId */, jni::alias_ref<jni::JDouble> /* backlog */)>("listenTLSUnix");
+    method(_javaPart, jni::make_jstring(path), secureContextId, backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr);
+  }
   void JHybridNetServerDriverSpec::listenHandle(double fd, std::optional<double> backlog) {
     static const auto method = javaClassStatic()->getMethod<void(double /* fd */, jni::alias_ref<jni::JDouble> /* backlog */)>("listenHandle");
     method(_javaPart, fd, backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr);

package/nitrogen/generated/android/c++/JHybridNetServerDriverSpec.hpp

@@ -60,6 +60,7 @@ namespace margelo::nitro::net {
     void listen(double port, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) override;
     void listenTLS(double port, double secureContextId, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) override;
     void listenUnix(const std::string& path, std::optional<double> backlog) override;
+    void listenTLSUnix(const std::string& path, double secureContextId, std::optional<double> backlog) override;
     void listenHandle(double fd, std::optional<double> backlog) override;
     std::string getLocalAddress() override;
     void close() override;

package/nitrogen/generated/android/c++/JHybridNetSocketDriverSpec.cpp

@@ -175,6 +175,15 @@ namespace margelo::nitro::net {
     static const auto method = javaClassStatic()->getMethod<void()>("enableKeylog");
     method(_javaPart);
   }
+  void JHybridNetSocketDriverSpec::enableTrace() {
+    static const auto method = javaClassStatic()->getMethod<void()>("enableTrace");
+    method(_javaPart);
+  }
+  std::optional<std::shared_ptr<ArrayBuffer>> JHybridNetSocketDriverSpec::exportKeyingMaterial(double length, const std::string& label, const std::optional<std::shared_ptr<ArrayBuffer>>& context) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JArrayBuffer::javaobject>(double /* length */, jni::alias_ref<jni::JString> /* label */, jni::alias_ref<JArrayBuffer::javaobject> /* context */)>("exportKeyingMaterial");
+    auto __result = method(_javaPart, length, jni::make_jstring(label), context.has_value() ? JArrayBuffer::wrap(context.value()) : nullptr);
+    return __result != nullptr ? std::make_optional(__result->cthis()->getArrayBuffer()) : std::nullopt;
+  }
   void JHybridNetSocketDriverSpec::setNoDelay(bool enable) {
     static const auto method = javaClassStatic()->getMethod<void(jboolean /* enable */)>("setNoDelay");
     method(_javaPart, enable);

package/nitrogen/generated/android/c++/JHybridNetSocketDriverSpec.hpp

@@ -80,6 +80,8 @@ namespace margelo::nitro::net {
     void destroy() override;
     void resetAndDestroy() override;
     void enableKeylog() override;
+    void enableTrace() override;
+    std::optional<std::shared_ptr<ArrayBuffer>> exportKeyingMaterial(double length, const std::string& label, const std::optional<std::shared_ptr<ArrayBuffer>>& context) override;
     void setNoDelay(bool enable) override;
     void setKeepAlive(bool enable, double delay) override;
     std::string getLocalAddress() override;

package/nitrogen/generated/android/c++/JNetConfig.hpp

@@ -33,8 +33,11 @@ namespace margelo::nitro::net {
       static const auto clazz = javaClassStatic();
       static const auto fieldWorkerThreads = clazz->getField<jni::JDouble>("workerThreads");
       jni::local_ref<jni::JDouble> workerThreads = this->getFieldValue(fieldWorkerThreads);
+      static const auto fieldDebug = clazz->getField<jni::JBoolean>("debug");
+      jni::local_ref<jni::JBoolean> debug = this->getFieldValue(fieldDebug);
       return NetConfig(
-        workerThreads != nullptr ? std::make_optional(workerThreads->value()) : std::nullopt
+        workerThreads != nullptr ? std::make_optional(workerThreads->value()) : std::nullopt,
+        debug != nullptr ? std::make_optional(static_cast<bool>(debug->value())) : std::nullopt
       );
     }
 
@@ -44,12 +47,13 @@ namespace margelo::nitro::net {
      */
     [[maybe_unused]]
     static jni::local_ref<JNetConfig::javaobject> fromCpp(const NetConfig& value) {
-      using JSignature = JNetConfig(jni::alias_ref<jni::JDouble>);
+      using JSignature = JNetConfig(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
-        value.workerThreads.has_value() ? jni::JDouble::valueOf(value.workerThreads.value()) : nullptr
+        value.workerThreads.has_value() ? jni::JDouble::valueOf(value.workerThreads.value()) : nullptr,
+        value.debug.has_value() ? jni::JBoolean::valueOf(value.debug.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridHttpParserSpec.kt

@@ -0,0 +1,58 @@
+///
+/// HybridHttpParserSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the HttpParser HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of HttpParser.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridHttpParserSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject HttpParser]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun feed(data: ArrayBuffer): String
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridHttpParserSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetDriverSpec.kt

@@ -54,6 +54,10 @@ abstract class HybridNetDriverSpec: HybridObject() {
   @Keep
   abstract fun createServer(): HybridNetServerDriverSpec
   
+  @DoNotStrip
+  @Keep
+  abstract fun createHttpParser(mode: Double): HybridHttpParserSpec
+  
   @DoNotStrip
   @Keep
   abstract fun createSecureContext(cert: String, key: String, passphrase: String?): Double

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetServerDriverSpec.kt

@@ -76,6 +76,10 @@ abstract class HybridNetServerDriverSpec: HybridObject() {
   @Keep
   abstract fun listenUnix(path: String, backlog: Double?): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun listenTLSUnix(path: String, secureContextId: Double, backlog: Double?): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun listenHandle(fd: Double, backlog: Double?): Unit

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetSocketDriverSpec.kt

@@ -158,6 +158,14 @@ abstract class HybridNetSocketDriverSpec: HybridObject() {
   @Keep
   abstract fun enableKeylog(): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun enableTrace(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun exportKeyingMaterial(length: Double, label: String, context: ArrayBuffer?): ArrayBuffer?
+  
   @DoNotStrip
   @Keep
   abstract fun setNoDelay(enable: Boolean): Unit

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/NetConfig.kt

@@ -19,7 +19,10 @@ import com.facebook.proguard.annotations.DoNotStrip
 data class NetConfig(
   @DoNotStrip
   @Keep
-  val workerThreads: Double?
+  val workerThreads: Double?,
+  @DoNotStrip
+  @Keep
+  val debug: Boolean?
 ) {
   /* primary constructor */
 
@@ -31,8 +34,8 @@ data class NetConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(workerThreads: Double?): NetConfig {
-      return NetConfig(workerThreads)
+    private fun fromCpp(workerThreads: Double?, debug: Boolean?): NetConfig {
+      return NetConfig(workerThreads, debug)
     }
   }
 }

package/nitrogen/generated/ios/RustCNet-Swift-Cxx-Bridge.cpp

@@ -8,6 +8,7 @@
 #include "RustCNet-Swift-Cxx-Bridge.hpp"
 
 // Include C++ implementation defined types
+#include "HybridHttpParserSpecSwift.hpp"
 #include "HybridNetDriverSpecSwift.hpp"
 #include "HybridNetServerDriverSpecSwift.hpp"
 #include "HybridNetSocketDriverSpecSwift.hpp"
@@ -56,6 +57,22 @@ namespace margelo::nitro::net::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::shared_ptr<HybridHttpParserSpec>
+  std::shared_ptr<HybridHttpParserSpec> create_std__shared_ptr_HybridHttpParserSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    RustCNet::HybridHttpParserSpec_cxx swiftPart = RustCNet::HybridHttpParserSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::net::HybridHttpParserSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridHttpParserSpec_(std__shared_ptr_HybridHttpParserSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::net::HybridHttpParserSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::net::HybridHttpParserSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridHttpParserSpec\" is not implemented in Swift!");
+    }
+    #endif
+    RustCNet::HybridHttpParserSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridNetDriverSpec>
   std::shared_ptr<HybridNetDriverSpec> create_std__shared_ptr_HybridNetDriverSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     RustCNet::HybridNetDriverSpec_cxx swiftPart = RustCNet::HybridNetDriverSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/RustCNet-Swift-Cxx-Bridge.hpp

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ArrayBufferHolder` to properly resolve imports.
 namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `HybridHttpParserSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridHttpParserSpec; }
 // Forward declaration of `HybridNetDriverSpec` to properly resolve imports.
 namespace margelo::nitro::net { class HybridNetDriverSpec; }
 // Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
@@ -18,6 +20,8 @@ namespace margelo::nitro::net { class HybridNetServerDriverSpec; }
 namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridHttpParserSpec_cxx` to properly resolve imports.
+namespace RustCNet { class HybridHttpParserSpec_cxx; }
 // Forward declaration of `HybridNetDriverSpec_cxx` to properly resolve imports.
 namespace RustCNet { class HybridNetDriverSpec_cxx; }
 // Forward declaration of `HybridNetServerDriverSpec_cxx` to properly resolve imports.
@@ -26,6 +30,7 @@ namespace RustCNet { class HybridNetServerDriverSpec_cxx; }
 namespace RustCNet { class HybridNetSocketDriverSpec_cxx; }
 
 // Include C++ defined types
+#include "HybridHttpParserSpec.hpp"
 #include "HybridNetDriverSpec.hpp"
 #include "HybridNetServerDriverSpec.hpp"
 #include "HybridNetSocketDriverSpec.hpp"
@@ -195,6 +200,18 @@ namespace margelo::nitro::net::bridge::swift {
   using std__weak_ptr_HybridNetServerDriverSpec_ = std::weak_ptr<HybridNetServerDriverSpec>;
   inline std__weak_ptr_HybridNetServerDriverSpec_ weakify_std__shared_ptr_HybridNetServerDriverSpec_(const std::shared_ptr<HybridNetServerDriverSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: std::shared_ptr<HybridHttpParserSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridHttpParserSpec>`.
+   */
+  using std__shared_ptr_HybridHttpParserSpec_ = std::shared_ptr<HybridHttpParserSpec>;
+  std::shared_ptr<HybridHttpParserSpec> create_std__shared_ptr_HybridHttpParserSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridHttpParserSpec_(std__shared_ptr_HybridHttpParserSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridHttpParserSpec>
+  using std__weak_ptr_HybridHttpParserSpec_ = std::weak_ptr<HybridHttpParserSpec>;
+  inline std__weak_ptr_HybridHttpParserSpec_ weakify_std__shared_ptr_HybridHttpParserSpec_(const std::shared_ptr<HybridHttpParserSpec>& strong) noexcept { return strong; }
+  
   // pragma MARK: std::shared_ptr<HybridNetDriverSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridNetDriverSpec>`.
@@ -225,6 +242,15 @@ namespace margelo::nitro::net::bridge::swift {
     return Result<std::shared_ptr<HybridNetServerDriverSpec>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<HybridHttpParserSpec>>
+  using Result_std__shared_ptr_HybridHttpParserSpec__ = Result<std::shared_ptr<HybridHttpParserSpec>>;
+  inline Result_std__shared_ptr_HybridHttpParserSpec__ create_Result_std__shared_ptr_HybridHttpParserSpec__(const std::shared_ptr<HybridHttpParserSpec>& value) noexcept {
+    return Result<std::shared_ptr<HybridHttpParserSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_HybridHttpParserSpec__ create_Result_std__shared_ptr_HybridHttpParserSpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<HybridHttpParserSpec>>::withError(error);
+  }
+  
   // pragma MARK: Result<double>
   using Result_double_ = Result<double>;
   inline Result_double_ create_Result_double_(double value) noexcept {

package/nitrogen/generated/ios/RustCNet-Swift-Cxx-Umbrella.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `HybridHttpParserSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridHttpParserSpec; }
 // Forward declaration of `HybridNetDriverSpec` to properly resolve imports.
 namespace margelo::nitro::net { class HybridNetDriverSpec; }
 // Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
@@ -18,6 +20,7 @@ namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
 namespace margelo::nitro::net { struct NetConfig; }
 
 // Include C++ defined types
+#include "HybridHttpParserSpec.hpp"
 #include "HybridNetDriverSpec.hpp"
 #include "HybridNetServerDriverSpec.hpp"
 #include "HybridNetSocketDriverSpec.hpp"
@@ -40,6 +43,8 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridHttpParserSpec_cxx` to properly resolve imports.
+namespace RustCNet { class HybridHttpParserSpec_cxx; }
 // Forward declaration of `HybridNetDriverSpec_cxx` to properly resolve imports.
 namespace RustCNet { class HybridNetDriverSpec_cxx; }
 // Forward declaration of `HybridNetServerDriverSpec_cxx` to properly resolve imports.

package/nitrogen/generated/ios/c++/HybridHttpParserSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridHttpParserSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridHttpParserSpecSwift.hpp"
+
+namespace margelo::nitro::net {
+} // namespace margelo::nitro::net