rezo 1.0.138 → 1.0.139

package/dist/adapters/curl.cjs

@@ -11,6 +11,7 @@ const { RezoCookieJar, Cookie } = require('../cookies/cookie-jar.cjs');
 const RezoFormData = require('../utils/form-data.cjs');
 const { existsSync } = require("node:fs");
 const { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay, shouldRetry } = require('../utils/http-config.cjs');
+const { debugErrorDump } = require('../utils/debug-error-dump.cjs');
 const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const { RezoHeaders } = require('../utils/headers.cjs');
 const { StreamResponse } = require('../responses/stream.cjs');
@@ -2470,12 +2471,15 @@ async function executeRequest(options, defaultOptions, jar) {
             }
           }
         }
+        debugErrorDump(config, error);
         throw error;
       }
       if (proxyManager && selectedProxy) {
         proxyManager.reportFailure(selectedProxy, error);
       }
-      throw buildSmartError(config, originalRequest, error);
+      const smartError = buildSmartError(config, originalRequest, error);
+      debugErrorDump(config, smartError);
+      throw smartError;
     }
   }
 }

package/dist/adapters/curl.js

@@ -11,6 +11,7 @@ import { RezoCookieJar, Cookie } from '../cookies/cookie-jar.js';
 import RezoFormData from '../utils/form-data.js';
 import { existsSync } from "node:fs";
 import { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay, shouldRetry } from '../utils/http-config.js';
+import { debugErrorDump } from '../utils/debug-error-dump.js';
 import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 import { RezoHeaders } from '../utils/headers.js';
 import { StreamResponse } from '../responses/stream.js';
@@ -2470,12 +2471,15 @@ export async function executeRequest(options, defaultOptions, jar) {
             }
           }
         }
+        debugErrorDump(config, error);
         throw error;
       }
       if (proxyManager && selectedProxy) {
         proxyManager.reportFailure(selectedProxy, error);
       }
-      throw buildSmartError(config, originalRequest, error);
+      const smartError = buildSmartError(config, originalRequest, error);
+      debugErrorDump(config, smartError);
+      throw smartError;
     }
   }
 }

package/dist/adapters/entries/curl.d.ts

@@ -761,6 +761,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -2767,6 +2773,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -4015,6 +4046,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -8583,7 +8616,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.138";
+export declare const VERSION = "1.0.139";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/adapters/entries/fetch.d.ts

@@ -759,6 +759,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3035,6 +3041,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4094,6 +4102,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -6098,7 +6131,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.138";
+export declare const VERSION = "1.0.139";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/adapters/entries/http.d.ts

@@ -759,6 +759,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3035,6 +3041,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4094,6 +4102,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -6173,7 +6206,7 @@ export declare function getSocketTelemetry(socket: Socket): SocketTelemetry | un
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.138";
+export declare const VERSION = "1.0.139";
 /**
  * Type guard to check if an error is a RezoError instance.
  */

package/dist/adapters/entries/http2.d.ts

@@ -760,6 +760,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3036,6 +3042,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4095,6 +4103,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -6124,7 +6157,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.138";
+export declare const VERSION = "1.0.139";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/adapters/entries/react-native.cjs

@@ -6,12 +6,12 @@ const { RezoFormData } = require('../../utils/form-data.cjs');
 const { RezoCookieJar, Cookie } = require('../../cookies/cookie-jar.cjs');
 const { createDefaultHooks, mergeHooks } = require('../../core/hooks.cjs');
 const { VERSION } = require('../../version.cjs');
-const _mod_uyu65l = require('../../platform/react-native-providers.cjs');
-exports.createFetchStreamTransport = _mod_uyu65l.createFetchStreamTransport;
-exports.createExpoFileSystemAdapter = _mod_uyu65l.createExpoFileSystemAdapter;
-exports.createReactNativeFsAdapter = _mod_uyu65l.createReactNativeFsAdapter;
-exports.createNetInfoProvider = _mod_uyu65l.createNetInfoProvider;
-exports.createExpoBackgroundTaskProvider = _mod_uyu65l.createExpoBackgroundTaskProvider;;
+const _mod_hxyeij = require('../../platform/react-native-providers.cjs');
+exports.createFetchStreamTransport = _mod_hxyeij.createFetchStreamTransport;
+exports.createExpoFileSystemAdapter = _mod_hxyeij.createExpoFileSystemAdapter;
+exports.createReactNativeFsAdapter = _mod_hxyeij.createReactNativeFsAdapter;
+exports.createNetInfoProvider = _mod_hxyeij.createNetInfoProvider;
+exports.createExpoBackgroundTaskProvider = _mod_hxyeij.createExpoBackgroundTaskProvider;;
 exports.Rezo = Rezo;
 exports.RezoError = RezoError;
 exports.RezoErrorCode = RezoErrorCode;

package/dist/adapters/entries/react-native.d.ts

@@ -759,6 +759,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3035,6 +3041,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4094,6 +4102,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -6098,7 +6131,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.138";
+export declare const VERSION = "1.0.139";
 export interface ExpoFileSystemFileLike {
 	uri?: string;
 	size?: number;

package/dist/adapters/entries/xhr.d.ts

@@ -759,6 +759,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3035,6 +3041,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4094,6 +4102,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -6098,7 +6131,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.138";
+export declare const VERSION = "1.0.139";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/adapters/fetch.cjs

@@ -12,6 +12,7 @@ const { isSameDomain, RezoPerformance } = require('../utils/tools.cjs');
 const { ResponseCache } = require('../cache/universal-response-cache.cjs');
 const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const { resolveTimeoutMs } = require('../utils/staged-timeout.cjs');
+const { debugErrorDump } = require('../utils/debug-error-dump.cjs');
 const { importNodeModule } = require('../utils/node-runtime.cjs');
 const Environment = {
   isNode: typeof process !== "undefined" && process.versions?.node,
@@ -476,16 +477,19 @@ async function executeRequest(options, defaultOptions, jar) {
     const res = executeFetchRequest(fetchOptions, mainConfig, options, perform, streamResponse, downloadResponse, uploadResponse, jar);
     if (streamResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         streamResponse.emit("error", err);
       });
       return streamResponse;
     } else if (downloadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         downloadResponse.emit("error", err);
       });
       return downloadResponse;
     } else if (uploadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         uploadResponse.emit("error", err);
       });
       return uploadResponse;
@@ -506,6 +510,7 @@ async function executeRequest(options, defaultOptions, jar) {
     }
     return response;
   } catch (error) {
+    debugErrorDump(mainConfig, error);
     throw error;
   }
 }

package/dist/adapters/fetch.js

@@ -12,6 +12,7 @@ import { isSameDomain, RezoPerformance } from '../utils/tools.js';
 import { ResponseCache } from '../cache/universal-response-cache.js';
 import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 import { resolveTimeoutMs } from '../utils/staged-timeout.js';
+import { debugErrorDump } from '../utils/debug-error-dump.js';
 import { importNodeModule } from '../utils/node-runtime.js';
 const Environment = {
   isNode: typeof process !== "undefined" && process.versions?.node,
@@ -476,16 +477,19 @@ export async function executeRequest(options, defaultOptions, jar) {
     const res = executeFetchRequest(fetchOptions, mainConfig, options, perform, streamResponse, downloadResponse, uploadResponse, jar);
     if (streamResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         streamResponse.emit("error", err);
       });
       return streamResponse;
     } else if (downloadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         downloadResponse.emit("error", err);
       });
       return downloadResponse;
     } else if (uploadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         uploadResponse.emit("error", err);
       });
       return uploadResponse;
@@ -506,6 +510,7 @@ export async function executeRequest(options, defaultOptions, jar) {
     }
     return response;
   } catch (error) {
+    debugErrorDump(mainConfig, error);
     throw error;
   }
 }

package/dist/adapters/http.cjs

@@ -21,6 +21,7 @@ const { ResponseCache } = require('../cache/response-cache.cjs');
 const { getGlobalAgentPool } = require('../utils/agent-pool.cjs');
 const { buildTlsOptions } = require('../stealth/tls-fingerprint.cjs');
 const { StagedTimeoutManager, parseStagedTimeouts, resolveTimeoutMs } = require('../utils/staged-timeout.cjs');
+const { debugErrorDump } = require('../utils/debug-error-dump.cjs');
 const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const { getSocketTelemetry, beginRequestContext } = require('../utils/socket-telemetry.cjs');
 const dns = require("node:dns");
@@ -70,6 +71,7 @@ const debugLog = {
       console.log(`[Rezo Track]   ✗ Max retries reached`);
     }
   },
+  errorDump: (config, error) => debugErrorDump(config, error),
   response: (config, status, statusText, duration) => {
     if (config.debug) {
       console.log(`[Rezo Debug] Response: ${status} ${statusText} (${duration.toFixed(2)}ms)`);
@@ -312,16 +314,19 @@ async function executeRequest(options, defaultOptions, jar) {
     const res = executeHttp1Request(config.fetchOptions, mainConfig, config.options, perform, d_options.fs, streamResponse, downloadResponse, uploadResponse, jar);
     if (streamResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         streamResponse.emit("error", err);
       });
       return streamResponse;
     } else if (downloadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         downloadResponse.emit("error", err);
       });
       return downloadResponse;
     } else if (uploadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         uploadResponse.emit("error", err);
       });
       return uploadResponse;
@@ -366,6 +371,7 @@ async function executeRequest(options, defaultOptions, jar) {
         }
       }
     }
+    debugErrorDump(mainConfig, error);
     throw error;
   }
 }
@@ -1106,6 +1112,16 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
                 resolve(partialResponse);
                 return;
               }
+              if (fetchOptions.acceptPartialBody && data.length > 0 && statusCode) {
+                const _validateStatus = fetchOptions.validateStatus ?? ((s) => s >= 200 && s < 300);
+                if (fetchOptions.validateStatus === null || _validateStatus(statusCode)) {
+                  _stats.statusOnNext = "success";
+                  const salvagedResponse = buildResponseFromIncoming(res, data, config, url.toString(), buildUrlTree(config, url.toString()), undefined, undefined, contentLengthCounter);
+                  salvagedResponse.truncated = true;
+                  resolve(salvagedResponse);
+                  return;
+                }
+              }
               const isNetworkError = err.code && ["ECONNRESET", "ECONNABORTED", "ETIMEDOUT", "EPIPE", "ENOTFOUND", "ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH", "ERR_STREAM_PREMATURE_CLOSE"].includes(err.code);
               if (isNetworkError) {
                 const partialResponse = buildResponseFromIncoming(res, data, config, url.toString(), buildUrlTree(config, url.toString()), undefined, undefined, contentLengthCounter);

package/dist/adapters/http.js

@@ -21,6 +21,7 @@ import { ResponseCache } from '../cache/response-cache.js';
 import { getGlobalAgentPool } from '../utils/agent-pool.js';
 import { buildTlsOptions } from '../stealth/tls-fingerprint.js';
 import { StagedTimeoutManager, parseStagedTimeouts, resolveTimeoutMs } from '../utils/staged-timeout.js';
+import { debugErrorDump } from '../utils/debug-error-dump.js';
 import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 import { getSocketTelemetry, beginRequestContext } from '../utils/socket-telemetry.js';
 import dns from "node:dns";
@@ -70,6 +71,7 @@ const debugLog = {
       console.log(`[Rezo Track]   ✗ Max retries reached`);
     }
   },
+  errorDump: (config, error) => debugErrorDump(config, error),
   response: (config, status, statusText, duration) => {
     if (config.debug) {
       console.log(`[Rezo Debug] Response: ${status} ${statusText} (${duration.toFixed(2)}ms)`);
@@ -312,16 +314,19 @@ export async function executeRequest(options, defaultOptions, jar) {
     const res = executeHttp1Request(config.fetchOptions, mainConfig, config.options, perform, d_options.fs, streamResponse, downloadResponse, uploadResponse, jar);
     if (streamResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         streamResponse.emit("error", err);
       });
       return streamResponse;
     } else if (downloadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         downloadResponse.emit("error", err);
       });
       return downloadResponse;
     } else if (uploadResponse) {
       res.catch((err) => {
+        debugErrorDump(mainConfig, err);
         uploadResponse.emit("error", err);
       });
       return uploadResponse;
@@ -366,6 +371,7 @@ export async function executeRequest(options, defaultOptions, jar) {
         }
       }
     }
+    debugErrorDump(mainConfig, error);
     throw error;
   }
 }
@@ -1106,6 +1112,16 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
                 resolve(partialResponse);
                 return;
               }
+              if (fetchOptions.acceptPartialBody && data.length > 0 && statusCode) {
+                const _validateStatus = fetchOptions.validateStatus ?? ((s) => s >= 200 && s < 300);
+                if (fetchOptions.validateStatus === null || _validateStatus(statusCode)) {
+                  _stats.statusOnNext = "success";
+                  const salvagedResponse = buildResponseFromIncoming(res, data, config, url.toString(), buildUrlTree(config, url.toString()), undefined, undefined, contentLengthCounter);
+                  salvagedResponse.truncated = true;
+                  resolve(salvagedResponse);
+                  return;
+                }
+              }
               const isNetworkError = err.code && ["ECONNRESET", "ECONNABORTED", "ETIMEDOUT", "EPIPE", "ENOTFOUND", "ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH", "ERR_STREAM_PREMATURE_CLOSE"].includes(err.code);
               if (isNetworkError) {
                 const partialResponse = buildResponseFromIncoming(res, data, config, url.toString(), buildUrlTree(config, url.toString()), undefined, undefined, contentLengthCounter);