@onekeyfe/react-native-range-downloader 3.0.67 → 3.0.68

package/lib/typescript/src/ReactNativeRangeDownloader.nitro.d.ts

@@ -8,12 +8,18 @@ export interface RangeDownloadParams {
     expectedSha256?: string;
     segmentCount?: number;
     minConcurrentBytes?: number;
+    maxSegmentAttempts?: number;
+    requestTimeoutSeconds?: number;
+    stallTimeoutSeconds?: number;
+    overallDeadlineSeconds?: number;
 }
-export type RangeDownloadOutcome = 'completed' | 'fallback';
+export type RangeDownloadOutcome = 'completed' | 'fallbackTransient' | 'fallbackPermanent' | 'fallback';
+export type RangeFallbackKind = 'serverIgnoredRange' | 'rangeUnsupported' | 'authExpired' | 'notFound' | 'redirectRejected' | 'checksumMismatch' | 'multipartOrBadTotal' | 'transientNetwork' | 'throttled' | 'budgetExhausted';
 export interface RangeDownloadResult {
     outcome: RangeDownloadOutcome;
     filePath: string;
     fallbackReason?: string;
+    fallbackKind?: RangeFallbackKind;
 }
 export interface RangeDownloadEvent {
     channel: DownloadChannel;

package/lib/typescript/src/ReactNativeRangeDownloader.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactNativeRangeDownloader.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativeRangeDownloader.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAM/D,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC;AAEzD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,oBAAoB,GAC5B,WAAW,GACX,UAAU,CAAC;AAEf,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAIzD,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAMpE,gBAAgB,CACd,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IAKjB,MAAM,CACJ,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IAGjB,mBAAmB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,MAAM,CAAC;IAC3E,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAKzC,eAAe,IAAI,MAAM,CAAC;CAC3B"}
+{"version":3,"file":"ReactNativeRangeDownloader.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativeRangeDownloader.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAM/D,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC;AAEzD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAI5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAWD,MAAM,MAAM,oBAAoB,GAC5B,WAAW,GACX,mBAAmB,GACnB,mBAAmB,GACnB,UAAU,CAAC;AAKf,MAAM,MAAM,iBAAiB,GACzB,oBAAoB,GACpB,kBAAkB,GAClB,aAAa,GACb,UAAU,GACV,kBAAkB,GAClB,kBAAkB,GAClB,qBAAqB,GACrB,kBAAkB,GAClB,WAAW,GACX,iBAAiB,CAAC;AAEtB,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAIzD,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAMpE,gBAAgB,CACd,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IAKjB,MAAM,CACJ,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IAGjB,mBAAmB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,MAAM,CAAC;IAC3E,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAKzC,eAAe,IAAI,MAAM,CAAC;CAC3B"}

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

@@ -11,6 +11,8 @@
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadResult; }
 // Forward declaration of `RangeDownloadOutcome` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { enum class RangeDownloadOutcome; }
+// Forward declaration of `RangeFallbackKind` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { enum class RangeFallbackKind; }
 // Forward declaration of `RangeDownloadParams` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadParams; }
 // Forward declaration of `DownloadChannel` to properly resolve imports.
@@ -26,6 +28,8 @@ namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadEvent
 #include "JRangeDownloadOutcome.hpp"
 #include <string>
 #include <optional>
+#include "RangeFallbackKind.hpp"
+#include "JRangeFallbackKind.hpp"
 #include "RangeDownloadParams.hpp"
 #include "JRangeDownloadParams.hpp"
 #include "DownloadChannel.hpp"

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

@@ -42,11 +42,17 @@ namespace margelo::nitro::reactnativerangedownloader {
     static jni::alias_ref<JRangeDownloadOutcome> fromCpp(RangeDownloadOutcome value) {
       static const auto clazz = javaClassStatic();
       static const auto fieldCOMPLETED = clazz->getStaticField<JRangeDownloadOutcome>("COMPLETED");
+      static const auto fieldFALLBACKTRANSIENT = clazz->getStaticField<JRangeDownloadOutcome>("FALLBACKTRANSIENT");
+      static const auto fieldFALLBACKPERMANENT = clazz->getStaticField<JRangeDownloadOutcome>("FALLBACKPERMANENT");
       static const auto fieldFALLBACK = clazz->getStaticField<JRangeDownloadOutcome>("FALLBACK");
       
       switch (value) {
         case RangeDownloadOutcome::COMPLETED:
           return clazz->getStaticFieldValue(fieldCOMPLETED);
+        case RangeDownloadOutcome::FALLBACKTRANSIENT:
+          return clazz->getStaticFieldValue(fieldFALLBACKTRANSIENT);
+        case RangeDownloadOutcome::FALLBACKPERMANENT:
+          return clazz->getStaticFieldValue(fieldFALLBACKPERMANENT);
         case RangeDownloadOutcome::FALLBACK:
           return clazz->getStaticFieldValue(fieldFALLBACK);
         default:

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

@@ -48,6 +48,14 @@ namespace margelo::nitro::reactnativerangedownloader {
       jni::local_ref<jni::JDouble> segmentCount = this->getFieldValue(fieldSegmentCount);
       static const auto fieldMinConcurrentBytes = clazz->getField<jni::JDouble>("minConcurrentBytes");
       jni::local_ref<jni::JDouble> minConcurrentBytes = this->getFieldValue(fieldMinConcurrentBytes);
+      static const auto fieldMaxSegmentAttempts = clazz->getField<jni::JDouble>("maxSegmentAttempts");
+      jni::local_ref<jni::JDouble> maxSegmentAttempts = this->getFieldValue(fieldMaxSegmentAttempts);
+      static const auto fieldRequestTimeoutSeconds = clazz->getField<jni::JDouble>("requestTimeoutSeconds");
+      jni::local_ref<jni::JDouble> requestTimeoutSeconds = this->getFieldValue(fieldRequestTimeoutSeconds);
+      static const auto fieldStallTimeoutSeconds = clazz->getField<jni::JDouble>("stallTimeoutSeconds");
+      jni::local_ref<jni::JDouble> stallTimeoutSeconds = this->getFieldValue(fieldStallTimeoutSeconds);
+      static const auto fieldOverallDeadlineSeconds = clazz->getField<jni::JDouble>("overallDeadlineSeconds");
+      jni::local_ref<jni::JDouble> overallDeadlineSeconds = this->getFieldValue(fieldOverallDeadlineSeconds);
       return RangeDownloadParams(
         channel->toCpp(),
         taskId->toStdString(),
@@ -55,7 +63,11 @@ namespace margelo::nitro::reactnativerangedownloader {
         destFilePath->toStdString(),
         expectedSha256 != nullptr ? std::make_optional(expectedSha256->toStdString()) : std::nullopt,
         segmentCount != nullptr ? std::make_optional(segmentCount->value()) : std::nullopt,
-        minConcurrentBytes != nullptr ? std::make_optional(minConcurrentBytes->value()) : std::nullopt
+        minConcurrentBytes != nullptr ? std::make_optional(minConcurrentBytes->value()) : std::nullopt,
+        maxSegmentAttempts != nullptr ? std::make_optional(maxSegmentAttempts->value()) : std::nullopt,
+        requestTimeoutSeconds != nullptr ? std::make_optional(requestTimeoutSeconds->value()) : std::nullopt,
+        stallTimeoutSeconds != nullptr ? std::make_optional(stallTimeoutSeconds->value()) : std::nullopt,
+        overallDeadlineSeconds != nullptr ? std::make_optional(overallDeadlineSeconds->value()) : std::nullopt
       );
     }
 
@@ -65,7 +77,7 @@ namespace margelo::nitro::reactnativerangedownloader {
      */
     [[maybe_unused]]
     static jni::local_ref<JRangeDownloadParams::javaobject> fromCpp(const RangeDownloadParams& value) {
-      using JSignature = JRangeDownloadParams(jni::alias_ref<JDownloadChannel>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      using JSignature = JRangeDownloadParams(jni::alias_ref<JDownloadChannel>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -76,7 +88,11 @@ namespace margelo::nitro::reactnativerangedownloader {
         jni::make_jstring(value.destFilePath),
         value.expectedSha256.has_value() ? jni::make_jstring(value.expectedSha256.value()) : nullptr,
         value.segmentCount.has_value() ? jni::JDouble::valueOf(value.segmentCount.value()) : nullptr,
-        value.minConcurrentBytes.has_value() ? jni::JDouble::valueOf(value.minConcurrentBytes.value()) : nullptr
+        value.minConcurrentBytes.has_value() ? jni::JDouble::valueOf(value.minConcurrentBytes.value()) : nullptr,
+        value.maxSegmentAttempts.has_value() ? jni::JDouble::valueOf(value.maxSegmentAttempts.value()) : nullptr,
+        value.requestTimeoutSeconds.has_value() ? jni::JDouble::valueOf(value.requestTimeoutSeconds.value()) : nullptr,
+        value.stallTimeoutSeconds.has_value() ? jni::JDouble::valueOf(value.stallTimeoutSeconds.value()) : nullptr,
+        value.overallDeadlineSeconds.has_value() ? jni::JDouble::valueOf(value.overallDeadlineSeconds.value()) : nullptr
       );
     }
   };

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

@@ -11,7 +11,9 @@
 #include "RangeDownloadResult.hpp"
 
 #include "JRangeDownloadOutcome.hpp"
+#include "JRangeFallbackKind.hpp"
 #include "RangeDownloadOutcome.hpp"
+#include "RangeFallbackKind.hpp"
 #include <optional>
 #include <string>
 
@@ -40,10 +42,13 @@ namespace margelo::nitro::reactnativerangedownloader {
       jni::local_ref<jni::JString> filePath = this->getFieldValue(fieldFilePath);
       static const auto fieldFallbackReason = clazz->getField<jni::JString>("fallbackReason");
       jni::local_ref<jni::JString> fallbackReason = this->getFieldValue(fieldFallbackReason);
+      static const auto fieldFallbackKind = clazz->getField<JRangeFallbackKind>("fallbackKind");
+      jni::local_ref<JRangeFallbackKind> fallbackKind = this->getFieldValue(fieldFallbackKind);
       return RangeDownloadResult(
         outcome->toCpp(),
         filePath->toStdString(),
-        fallbackReason != nullptr ? std::make_optional(fallbackReason->toStdString()) : std::nullopt
+        fallbackReason != nullptr ? std::make_optional(fallbackReason->toStdString()) : std::nullopt,
+        fallbackKind != nullptr ? std::make_optional(fallbackKind->toCpp()) : std::nullopt
       );
     }
 
@@ -53,14 +58,15 @@ namespace margelo::nitro::reactnativerangedownloader {
      */
     [[maybe_unused]]
     static jni::local_ref<JRangeDownloadResult::javaobject> fromCpp(const RangeDownloadResult& value) {
-      using JSignature = JRangeDownloadResult(jni::alias_ref<JRangeDownloadOutcome>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      using JSignature = JRangeDownloadResult(jni::alias_ref<JRangeDownloadOutcome>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JRangeFallbackKind>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         JRangeDownloadOutcome::fromCpp(value.outcome),
         jni::make_jstring(value.filePath),
-        value.fallbackReason.has_value() ? jni::make_jstring(value.fallbackReason.value()) : nullptr
+        value.fallbackReason.has_value() ? jni::make_jstring(value.fallbackReason.value()) : nullptr,
+        value.fallbackKind.has_value() ? JRangeFallbackKind::fromCpp(value.fallbackKind.value()) : nullptr
       );
     }
   };

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

@@ -0,0 +1,83 @@
+///
+/// JRangeFallbackKind.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RangeFallbackKind.hpp"
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RangeFallbackKind" and the the Kotlin enum "RangeFallbackKind".
+   */
+  struct JRangeFallbackKind final: public jni::JavaClass<JRangeFallbackKind> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/RangeFallbackKind;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RangeFallbackKind.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RangeFallbackKind toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RangeFallbackKind>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRangeFallbackKind> fromCpp(RangeFallbackKind value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSERVERIGNOREDRANGE = clazz->getStaticField<JRangeFallbackKind>("SERVERIGNOREDRANGE");
+      static const auto fieldRANGEUNSUPPORTED = clazz->getStaticField<JRangeFallbackKind>("RANGEUNSUPPORTED");
+      static const auto fieldAUTHEXPIRED = clazz->getStaticField<JRangeFallbackKind>("AUTHEXPIRED");
+      static const auto fieldNOTFOUND = clazz->getStaticField<JRangeFallbackKind>("NOTFOUND");
+      static const auto fieldREDIRECTREJECTED = clazz->getStaticField<JRangeFallbackKind>("REDIRECTREJECTED");
+      static const auto fieldCHECKSUMMISMATCH = clazz->getStaticField<JRangeFallbackKind>("CHECKSUMMISMATCH");
+      static const auto fieldMULTIPARTORBADTOTAL = clazz->getStaticField<JRangeFallbackKind>("MULTIPARTORBADTOTAL");
+      static const auto fieldTRANSIENTNETWORK = clazz->getStaticField<JRangeFallbackKind>("TRANSIENTNETWORK");
+      static const auto fieldTHROTTLED = clazz->getStaticField<JRangeFallbackKind>("THROTTLED");
+      static const auto fieldBUDGETEXHAUSTED = clazz->getStaticField<JRangeFallbackKind>("BUDGETEXHAUSTED");
+      
+      switch (value) {
+        case RangeFallbackKind::SERVERIGNOREDRANGE:
+          return clazz->getStaticFieldValue(fieldSERVERIGNOREDRANGE);
+        case RangeFallbackKind::RANGEUNSUPPORTED:
+          return clazz->getStaticFieldValue(fieldRANGEUNSUPPORTED);
+        case RangeFallbackKind::AUTHEXPIRED:
+          return clazz->getStaticFieldValue(fieldAUTHEXPIRED);
+        case RangeFallbackKind::NOTFOUND:
+          return clazz->getStaticFieldValue(fieldNOTFOUND);
+        case RangeFallbackKind::REDIRECTREJECTED:
+          return clazz->getStaticFieldValue(fieldREDIRECTREJECTED);
+        case RangeFallbackKind::CHECKSUMMISMATCH:
+          return clazz->getStaticFieldValue(fieldCHECKSUMMISMATCH);
+        case RangeFallbackKind::MULTIPARTORBADTOTAL:
+          return clazz->getStaticFieldValue(fieldMULTIPARTORBADTOTAL);
+        case RangeFallbackKind::TRANSIENTNETWORK:
+          return clazz->getStaticFieldValue(fieldTRANSIENTNETWORK);
+        case RangeFallbackKind::THROTTLED:
+          return clazz->getStaticFieldValue(fieldTHROTTLED);
+        case RangeFallbackKind::BUDGETEXHAUSTED:
+          return clazz->getStaticFieldValue(fieldBUDGETEXHAUSTED);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativerangedownloader/RangeDownloadOutcome.kt

@@ -17,5 +17,7 @@ import com.facebook.proguard.annotations.DoNotStrip
 @Keep
 enum class RangeDownloadOutcome(@DoNotStrip @Keep val value: Int) {
   COMPLETED(0),
-  FALLBACK(1);
+  FALLBACKTRANSIENT(1),
+  FALLBACKPERMANENT(2),
+  FALLBACK(3);
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativerangedownloader/RangeDownloadParams.kt

@@ -37,7 +37,19 @@ data class RangeDownloadParams(
   val segmentCount: Double?,
   @DoNotStrip
   @Keep
-  val minConcurrentBytes: Double?
+  val minConcurrentBytes: Double?,
+  @DoNotStrip
+  @Keep
+  val maxSegmentAttempts: Double?,
+  @DoNotStrip
+  @Keep
+  val requestTimeoutSeconds: Double?,
+  @DoNotStrip
+  @Keep
+  val stallTimeoutSeconds: Double?,
+  @DoNotStrip
+  @Keep
+  val overallDeadlineSeconds: Double?
 ) {
   /* primary constructor */
 
@@ -49,8 +61,8 @@ data class RangeDownloadParams(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(channel: DownloadChannel, taskId: String, url: String, destFilePath: String, expectedSha256: String?, segmentCount: Double?, minConcurrentBytes: Double?): RangeDownloadParams {
-      return RangeDownloadParams(channel, taskId, url, destFilePath, expectedSha256, segmentCount, minConcurrentBytes)
+    private fun fromCpp(channel: DownloadChannel, taskId: String, url: String, destFilePath: String, expectedSha256: String?, segmentCount: Double?, minConcurrentBytes: Double?, maxSegmentAttempts: Double?, requestTimeoutSeconds: Double?, stallTimeoutSeconds: Double?, overallDeadlineSeconds: Double?): RangeDownloadParams {
+      return RangeDownloadParams(channel, taskId, url, destFilePath, expectedSha256, segmentCount, minConcurrentBytes, maxSegmentAttempts, requestTimeoutSeconds, stallTimeoutSeconds, overallDeadlineSeconds)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativerangedownloader/RangeDownloadResult.kt

@@ -25,7 +25,10 @@ data class RangeDownloadResult(
   val filePath: String,
   @DoNotStrip
   @Keep
-  val fallbackReason: String?
+  val fallbackReason: String?,
+  @DoNotStrip
+  @Keep
+  val fallbackKind: RangeFallbackKind?
 ) {
   /* primary constructor */
 
@@ -37,8 +40,8 @@ data class RangeDownloadResult(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(outcome: RangeDownloadOutcome, filePath: String, fallbackReason: String?): RangeDownloadResult {
-      return RangeDownloadResult(outcome, filePath, fallbackReason)
+    private fun fromCpp(outcome: RangeDownloadOutcome, filePath: String, fallbackReason: String?, fallbackKind: RangeFallbackKind?): RangeDownloadResult {
+      return RangeDownloadResult(outcome, filePath, fallbackReason, fallbackKind)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativerangedownloader/RangeFallbackKind.kt

@@ -0,0 +1,29 @@
+///
+/// RangeFallbackKind.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativerangedownloader
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "RangeFallbackKind".
+ */
+@DoNotStrip
+@Keep
+enum class RangeFallbackKind(@DoNotStrip @Keep val value: Int) {
+  SERVERIGNOREDRANGE(0),
+  RANGEUNSUPPORTED(1),
+  AUTHEXPIRED(2),
+  NOTFOUND(3),
+  REDIRECTREJECTED(4),
+  CHECKSUMMISMATCH(5),
+  MULTIPARTORBADTOTAL(6),
+  TRANSIENTNETWORK(7),
+  THROTTLED(8),
+  BUDGETEXHAUSTED(9);
+}

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

@@ -18,6 +18,8 @@ namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadEvent
 namespace margelo::nitro::reactnativerangedownloader { enum class RangeDownloadOutcome; }
 // Forward declaration of `RangeDownloadResult` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadResult; }
+// Forward declaration of `RangeFallbackKind` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { enum class RangeFallbackKind; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridReactNativeRangeDownloaderSpec_cxx` to properly resolve imports.
@@ -29,6 +31,7 @@ namespace ReactNativeRangeDownloader { class HybridReactNativeRangeDownloaderSpe
 #include "RangeDownloadEvent.hpp"
 #include "RangeDownloadOutcome.hpp"
 #include "RangeDownloadResult.hpp"
+#include "RangeFallbackKind.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -59,6 +62,21 @@ namespace margelo::nitro::reactnativerangedownloader::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<RangeFallbackKind>
+  /**
+   * Specialized version of `std::optional<RangeFallbackKind>`.
+   */
+  using std__optional_RangeFallbackKind_ = std::optional<RangeFallbackKind>;
+  inline std::optional<RangeFallbackKind> create_std__optional_RangeFallbackKind_(const RangeFallbackKind& value) noexcept {
+    return std::optional<RangeFallbackKind>(value);
+  }
+  inline bool has_value_std__optional_RangeFallbackKind_(const std::optional<RangeFallbackKind>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline RangeFallbackKind get_std__optional_RangeFallbackKind_(const std::optional<RangeFallbackKind>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<RangeDownloadResult>>
   /**
    * Specialized version of `std::shared_ptr<Promise<RangeDownloadResult>>`.

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

@@ -20,6 +20,8 @@ namespace margelo::nitro::reactnativerangedownloader { enum class RangeDownloadO
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadParams; }
 // Forward declaration of `RangeDownloadResult` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadResult; }
+// Forward declaration of `RangeFallbackKind` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { enum class RangeFallbackKind; }
 
 // Include C++ defined types
 #include "DownloadChannel.hpp"
@@ -28,6 +30,7 @@ namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadResul
 #include "RangeDownloadOutcome.hpp"
 #include "RangeDownloadParams.hpp"
 #include "RangeDownloadResult.hpp"
+#include "RangeFallbackKind.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>

package/nitrogen/generated/ios/c++/HybridReactNativeRangeDownloaderSpecSwift.hpp

@@ -16,6 +16,8 @@ namespace ReactNativeRangeDownloader { class HybridReactNativeRangeDownloaderSpe
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadResult; }
 // Forward declaration of `RangeDownloadOutcome` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { enum class RangeDownloadOutcome; }
+// Forward declaration of `RangeFallbackKind` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { enum class RangeFallbackKind; }
 // Forward declaration of `RangeDownloadParams` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadParams; }
 // Forward declaration of `DownloadChannel` to properly resolve imports.
@@ -28,6 +30,7 @@ namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadEvent
 #include "RangeDownloadOutcome.hpp"
 #include <string>
 #include <optional>
+#include "RangeFallbackKind.hpp"
 #include "RangeDownloadParams.hpp"
 #include "DownloadChannel.hpp"
 #include "RangeDownloadEvent.hpp"

package/nitrogen/generated/ios/swift/RangeDownloadOutcome.swift

@@ -19,6 +19,10 @@ public extension RangeDownloadOutcome {
     switch string {
       case "completed":
         self = .completed
+      case "fallbackTransient":
+        self = .fallbacktransient
+      case "fallbackPermanent":
+        self = .fallbackpermanent
       case "fallback":
         self = .fallback
       default:
@@ -33,6 +37,10 @@ public extension RangeDownloadOutcome {
     switch self {
       case .completed:
         return "completed"
+      case .fallbacktransient:
+        return "fallbackTransient"
+      case .fallbackpermanent:
+        return "fallbackPermanent"
       case .fallback:
         return "fallback"
     }

package/nitrogen/generated/ios/swift/RangeDownloadParams.swift

@@ -19,7 +19,7 @@ public extension RangeDownloadParams {
   /**
    * Create a new instance of `RangeDownloadParams`.
    */
-  init(channel: DownloadChannel, taskId: String, url: String, destFilePath: String, expectedSha256: String?, segmentCount: Double?, minConcurrentBytes: Double?) {
+  init(channel: DownloadChannel, taskId: String, url: String, destFilePath: String, expectedSha256: String?, segmentCount: Double?, minConcurrentBytes: Double?, maxSegmentAttempts: Double?, requestTimeoutSeconds: Double?, stallTimeoutSeconds: Double?, overallDeadlineSeconds: Double?) {
     self.init(channel, std.string(taskId), std.string(url), std.string(destFilePath), { () -> bridge.std__optional_std__string_ in
       if let __unwrappedValue = expectedSha256 {
         return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
@@ -38,6 +38,30 @@ public extension RangeDownloadParams {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = maxSegmentAttempts {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = requestTimeoutSeconds {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = stallTimeoutSeconds {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = overallDeadlineSeconds {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -142,4 +166,72 @@ public extension RangeDownloadParams {
       }()
     }
   }
+  
+  var maxSegmentAttempts: Double? {
+    @inline(__always)
+    get {
+      return self.__maxSegmentAttempts.value
+    }
+    @inline(__always)
+    set {
+      self.__maxSegmentAttempts = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var requestTimeoutSeconds: Double? {
+    @inline(__always)
+    get {
+      return self.__requestTimeoutSeconds.value
+    }
+    @inline(__always)
+    set {
+      self.__requestTimeoutSeconds = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var stallTimeoutSeconds: Double? {
+    @inline(__always)
+    get {
+      return self.__stallTimeoutSeconds.value
+    }
+    @inline(__always)
+    set {
+      self.__stallTimeoutSeconds = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var overallDeadlineSeconds: Double? {
+    @inline(__always)
+    get {
+      return self.__overallDeadlineSeconds.value
+    }
+    @inline(__always)
+    set {
+      self.__overallDeadlineSeconds = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }

package/nitrogen/generated/ios/swift/RangeDownloadResult.swift

@@ -19,13 +19,19 @@ public extension RangeDownloadResult {
   /**
    * Create a new instance of `RangeDownloadResult`.
    */
-  init(outcome: RangeDownloadOutcome, filePath: String, fallbackReason: String?) {
+  init(outcome: RangeDownloadOutcome, filePath: String, fallbackReason: String?, fallbackKind: RangeFallbackKind?) {
     self.init(outcome, std.string(filePath), { () -> bridge.std__optional_std__string_ in
       if let __unwrappedValue = fallbackReason {
         return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_RangeFallbackKind_ in
+      if let __unwrappedValue = fallbackKind {
+        return bridge.create_std__optional_RangeFallbackKind_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -74,4 +80,21 @@ public extension RangeDownloadResult {
       }()
     }
   }
+  
+  var fallbackKind: RangeFallbackKind? {
+    @inline(__always)
+    get {
+      return self.__fallbackKind.value
+    }
+    @inline(__always)
+    set {
+      self.__fallbackKind = { () -> bridge.std__optional_RangeFallbackKind_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_RangeFallbackKind_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }