rezo 1.0.11 → 1.0.13

package/dist/platform/bun.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/deno.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/node.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/react-native.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/worker.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/plugin/index.cjs

@@ -1,36 +1,36 @@
-const _mod_rw5uzi = require('./crawler.cjs');
-exports.Crawler = _mod_rw5uzi.Crawler;;
-const _mod_uowipj = require('./crawler-options.cjs');
-exports.CrawlerOptions = _mod_uowipj.CrawlerOptions;;
-const _mod_o9zvdc = require('../cache/file-cacher.cjs');
-exports.FileCacher = _mod_o9zvdc.FileCacher;;
-const _mod_vh8a1z = require('../cache/url-store.cjs');
-exports.UrlStore = _mod_vh8a1z.UrlStore;;
-const _mod_7g0lot = require('./addon/oxylabs/index.cjs');
-exports.Oxylabs = _mod_7g0lot.Oxylabs;;
-const _mod_hjsucp = require('./addon/oxylabs/options.cjs');
-exports.OXYLABS_BROWSER_TYPES = _mod_hjsucp.OXYLABS_BROWSER_TYPES;
-exports.OXYLABS_COMMON_LOCALES = _mod_hjsucp.OXYLABS_COMMON_LOCALES;
-exports.OXYLABS_COMMON_GEO_LOCATIONS = _mod_hjsucp.OXYLABS_COMMON_GEO_LOCATIONS;
-exports.OXYLABS_US_STATES = _mod_hjsucp.OXYLABS_US_STATES;
-exports.OXYLABS_EUROPEAN_COUNTRIES = _mod_hjsucp.OXYLABS_EUROPEAN_COUNTRIES;
-exports.OXYLABS_ASIAN_COUNTRIES = _mod_hjsucp.OXYLABS_ASIAN_COUNTRIES;
-exports.getRandomOxylabsBrowserType = _mod_hjsucp.getRandomBrowserType;
-exports.getRandomOxylabsLocale = _mod_hjsucp.getRandomLocale;
-exports.getRandomOxylabsGeoLocation = _mod_hjsucp.getRandomGeoLocation;;
-const _mod_775tfq = require('./addon/decodo/index.cjs');
-exports.Decodo = _mod_775tfq.Decodo;;
-const _mod_hpojjz = require('./addon/decodo/options.cjs');
-exports.DECODO_DEVICE_TYPES = _mod_hpojjz.DECODO_DEVICE_TYPES;
-exports.DECODO_HEADLESS_MODES = _mod_hpojjz.DECODO_HEADLESS_MODES;
-exports.DECODO_COMMON_LOCALES = _mod_hpojjz.DECODO_COMMON_LOCALES;
-exports.DECODO_COMMON_COUNTRIES = _mod_hpojjz.DECODO_COMMON_COUNTRIES;
-exports.DECODO_EUROPEAN_COUNTRIES = _mod_hpojjz.DECODO_EUROPEAN_COUNTRIES;
-exports.DECODO_ASIAN_COUNTRIES = _mod_hpojjz.DECODO_ASIAN_COUNTRIES;
-exports.DECODO_US_STATES = _mod_hpojjz.DECODO_US_STATES;
-exports.DECODO_COMMON_CITIES = _mod_hpojjz.DECODO_COMMON_CITIES;
-exports.getRandomDecodoDeviceType = _mod_hpojjz.getRandomDeviceType;
-exports.getRandomDecodoLocale = _mod_hpojjz.getRandomLocale;
-exports.getRandomDecodoCountry = _mod_hpojjz.getRandomCountry;
-exports.getRandomDecodoCity = _mod_hpojjz.getRandomCity;
-exports.generateDecodoSessionId = _mod_hpojjz.generateSessionId;;
+const _mod_dq9ozb = require('./crawler.cjs');
+exports.Crawler = _mod_dq9ozb.Crawler;;
+const _mod_d0jsak = require('./crawler-options.cjs');
+exports.CrawlerOptions = _mod_d0jsak.CrawlerOptions;;
+const _mod_wbhzam = require('../cache/file-cacher.cjs');
+exports.FileCacher = _mod_wbhzam.FileCacher;;
+const _mod_ic6xnp = require('../cache/url-store.cjs');
+exports.UrlStore = _mod_ic6xnp.UrlStore;;
+const _mod_u5fn2x = require('./addon/oxylabs/index.cjs');
+exports.Oxylabs = _mod_u5fn2x.Oxylabs;;
+const _mod_mc3i9t = require('./addon/oxylabs/options.cjs');
+exports.OXYLABS_BROWSER_TYPES = _mod_mc3i9t.OXYLABS_BROWSER_TYPES;
+exports.OXYLABS_COMMON_LOCALES = _mod_mc3i9t.OXYLABS_COMMON_LOCALES;
+exports.OXYLABS_COMMON_GEO_LOCATIONS = _mod_mc3i9t.OXYLABS_COMMON_GEO_LOCATIONS;
+exports.OXYLABS_US_STATES = _mod_mc3i9t.OXYLABS_US_STATES;
+exports.OXYLABS_EUROPEAN_COUNTRIES = _mod_mc3i9t.OXYLABS_EUROPEAN_COUNTRIES;
+exports.OXYLABS_ASIAN_COUNTRIES = _mod_mc3i9t.OXYLABS_ASIAN_COUNTRIES;
+exports.getRandomOxylabsBrowserType = _mod_mc3i9t.getRandomBrowserType;
+exports.getRandomOxylabsLocale = _mod_mc3i9t.getRandomLocale;
+exports.getRandomOxylabsGeoLocation = _mod_mc3i9t.getRandomGeoLocation;;
+const _mod_d70cyo = require('./addon/decodo/index.cjs');
+exports.Decodo = _mod_d70cyo.Decodo;;
+const _mod_cmnvxg = require('./addon/decodo/options.cjs');
+exports.DECODO_DEVICE_TYPES = _mod_cmnvxg.DECODO_DEVICE_TYPES;
+exports.DECODO_HEADLESS_MODES = _mod_cmnvxg.DECODO_HEADLESS_MODES;
+exports.DECODO_COMMON_LOCALES = _mod_cmnvxg.DECODO_COMMON_LOCALES;
+exports.DECODO_COMMON_COUNTRIES = _mod_cmnvxg.DECODO_COMMON_COUNTRIES;
+exports.DECODO_EUROPEAN_COUNTRIES = _mod_cmnvxg.DECODO_EUROPEAN_COUNTRIES;
+exports.DECODO_ASIAN_COUNTRIES = _mod_cmnvxg.DECODO_ASIAN_COUNTRIES;
+exports.DECODO_US_STATES = _mod_cmnvxg.DECODO_US_STATES;
+exports.DECODO_COMMON_CITIES = _mod_cmnvxg.DECODO_COMMON_CITIES;
+exports.getRandomDecodoDeviceType = _mod_cmnvxg.getRandomDeviceType;
+exports.getRandomDecodoLocale = _mod_cmnvxg.getRandomLocale;
+exports.getRandomDecodoCountry = _mod_cmnvxg.getRandomCountry;
+exports.getRandomDecodoCity = _mod_cmnvxg.getRandomCity;
+exports.generateDecodoSessionId = _mod_cmnvxg.generateSessionId;;

package/dist/proxy/index.cjs

@@ -1,8 +1,8 @@
 const { SocksProxyAgent: RezoSocksProxy } = require("socks-proxy-agent");
 const { HttpsProxyAgent: RezoHttpsSocks } = require("https-proxy-agent");
 const { HttpProxyAgent: RezoHttpSocks } = require("http-proxy-agent");
-const _mod_6xqrgv = require('./manager.cjs');
-exports.ProxyManager = _mod_6xqrgv.ProxyManager;;
+const _mod_p28kf5 = require('./manager.cjs');
+exports.ProxyManager = _mod_p28kf5.ProxyManager;;
 function createOptions(uri, opts) {
   if (uri instanceof URL || typeof uri === "string") {
     return {

package/dist/queue/index.cjs

@@ -1,8 +1,8 @@
-const _mod_9p4qhc = require('./queue.cjs');
-exports.RezoQueue = _mod_9p4qhc.RezoQueue;;
-const _mod_iowt5d = require('./http-queue.cjs');
-exports.HttpQueue = _mod_iowt5d.HttpQueue;
-exports.extractDomain = _mod_iowt5d.extractDomain;;
-const _mod_ihr43x = require('./types.cjs');
-exports.Priority = _mod_ihr43x.Priority;
-exports.HttpMethodPriority = _mod_ihr43x.HttpMethodPriority;;
+const _mod_5bxokv = require('./queue.cjs');
+exports.RezoQueue = _mod_5bxokv.RezoQueue;;
+const _mod_12mknl = require('./http-queue.cjs');
+exports.HttpQueue = _mod_12mknl.HttpQueue;
+exports.extractDomain = _mod_12mknl.extractDomain;;
+const _mod_u9vq92 = require('./types.cjs');
+exports.Priority = _mod_u9vq92.Priority;
+exports.HttpMethodPriority = _mod_u9vq92.HttpMethodPriority;;

package/dist/responses/buildError.cjs

@@ -348,7 +348,11 @@ function buildRedirectError(messageOrParams, config, request, response) {
   return RezoError.createRedirectError("Redirect location not found", errorConfig, errorRequest, errorResponse);
 }
 function builErrorFromResponse(message, response, config, request) {
-  return RezoError.createRedirectError(message, config, request, response);
+  const statusCode = response?.status || 0;
+  if (statusCode >= 400) {
+    return RezoError.createHttpError(statusCode, config, request, response);
+  }
+  return new RezoError(message, config, "REZ_UNKNOWN_ERROR", request, response);
 }
 function buildNetworkError(message, code, config, request) {
   return RezoError.createNetworkError(message, code, config, request);

package/dist/responses/buildError.js

@@ -348,7 +348,11 @@ export function buildRedirectError(messageOrParams, config, request, response) {
   return RezoError.createRedirectError("Redirect location not found", errorConfig, errorRequest, errorResponse);
 }
 export function builErrorFromResponse(message, response, config, request) {
-  return RezoError.createRedirectError(message, config, request, response);
+  const statusCode = response?.status || 0;
+  if (statusCode >= 400) {
+    return RezoError.createHttpError(statusCode, config, request, response);
+  }
+  return new RezoError(message, config, "REZ_UNKNOWN_ERROR", request, response);
 }
 export function buildNetworkError(message, code, config, request) {
   return RezoError.createNetworkError(message, code, config, request);

package/dist/responses/buildResponse.cjs

@@ -297,11 +297,36 @@ function buildResponse(params) {
   const rezoHeaders = new RezoHeaders(headers);
   rezoHeaders.delete("set-cookie");
   let cookieData;
+  const mergedCookiesArray = [];
+  const cookieKeyDomainMap = new Map;
+  if (config.requestCookies && config.requestCookies.length > 0) {
+    for (const cookie of config.requestCookies) {
+      const key = `${cookie.key}|${cookie.domain || ""}`;
+      mergedCookiesArray.push(cookie);
+      cookieKeyDomainMap.set(key, mergedCookiesArray.length - 1);
+    }
+  }
+  let responseCookiesArray = [];
   if (config.responseCookies && config.responseCookies.array && config.responseCookies.array.length > 0) {
-    cookieData = config.responseCookies;
+    responseCookiesArray = config.responseCookies.array;
   } else if (cookies.length > 0) {
-    const cookieJar = new RezoCookieJar;
-    cookieData = cookieJar.setCookiesSync(cookies, url);
+    const tempJar = new RezoCookieJar;
+    const parsed = tempJar.setCookiesSync(cookies, url);
+    responseCookiesArray = parsed.array;
+  }
+  for (const cookie of responseCookiesArray) {
+    const key = `${cookie.key}|${cookie.domain || ""}`;
+    const existingIndex = cookieKeyDomainMap.get(key);
+    if (existingIndex !== undefined) {
+      mergedCookiesArray[existingIndex] = cookie;
+    } else {
+      mergedCookiesArray.push(cookie);
+      cookieKeyDomainMap.set(key, mergedCookiesArray.length - 1);
+    }
+  }
+  if (mergedCookiesArray.length > 0) {
+    const mergedJar = new RezoCookieJar(mergedCookiesArray, url);
+    cookieData = mergedJar.cookies();
   } else {
     cookieData = {
       array: [],
@@ -314,6 +339,8 @@ function buildResponse(params) {
       setCookiesString: []
     };
   }
+  config.status = statusCode;
+  config.statusText = statusMessage;
   return {
     data: formatResponse(body, config, rezoHeaders),
     status: statusCode,

package/dist/responses/buildResponse.js

@@ -297,11 +297,36 @@ export function buildResponse(params) {
   const rezoHeaders = new RezoHeaders(headers);
   rezoHeaders.delete("set-cookie");
   let cookieData;
+  const mergedCookiesArray = [];
+  const cookieKeyDomainMap = new Map;
+  if (config.requestCookies && config.requestCookies.length > 0) {
+    for (const cookie of config.requestCookies) {
+      const key = `${cookie.key}|${cookie.domain || ""}`;
+      mergedCookiesArray.push(cookie);
+      cookieKeyDomainMap.set(key, mergedCookiesArray.length - 1);
+    }
+  }
+  let responseCookiesArray = [];
   if (config.responseCookies && config.responseCookies.array && config.responseCookies.array.length > 0) {
-    cookieData = config.responseCookies;
+    responseCookiesArray = config.responseCookies.array;
   } else if (cookies.length > 0) {
-    const cookieJar = new RezoCookieJar;
-    cookieData = cookieJar.setCookiesSync(cookies, url);
+    const tempJar = new RezoCookieJar;
+    const parsed = tempJar.setCookiesSync(cookies, url);
+    responseCookiesArray = parsed.array;
+  }
+  for (const cookie of responseCookiesArray) {
+    const key = `${cookie.key}|${cookie.domain || ""}`;
+    const existingIndex = cookieKeyDomainMap.get(key);
+    if (existingIndex !== undefined) {
+      mergedCookiesArray[existingIndex] = cookie;
+    } else {
+      mergedCookiesArray.push(cookie);
+      cookieKeyDomainMap.set(key, mergedCookiesArray.length - 1);
+    }
+  }
+  if (mergedCookiesArray.length > 0) {
+    const mergedJar = new RezoCookieJar(mergedCookiesArray, url);
+    cookieData = mergedJar.cookies();
   } else {
     cookieData = {
       array: [],
@@ -314,6 +339,8 @@ export function buildResponse(params) {
       setCookiesString: []
     };
   }
+  config.status = statusCode;
+  config.statusText = statusMessage;
   return {
     data: formatResponse(body, config, rezoHeaders),
     status: statusCode,

package/dist/utils/compression.cjs

@@ -50,16 +50,16 @@ class CompressionUtil {
     if (!config) {
       return true;
     }
+    if (config.decompress === false) {
+      return false;
+    }
     if (config.compression?.enabled === false) {
       return false;
     }
-    if (config.compression?.enabled === undefined) {
-      if (config.compression?.algorithms) {
-        return config.compression.algorithms.includes(contentEncoding.toLowerCase());
-      }
-      return true;
+    if (config.compression?.algorithms) {
+      return config.compression.algorithms.includes(contentEncoding.toLowerCase());
     }
-    return config.compression.enabled;
+    return true;
   }
   static createZstdDecompressStream(response) {
     const decompressor = getZstdDecompressor();

package/dist/utils/compression.js

@@ -50,16 +50,16 @@ export class CompressionUtil {
     if (!config) {
       return true;
     }
+    if (config.decompress === false) {
+      return false;
+    }
     if (config.compression?.enabled === false) {
       return false;
     }
-    if (config.compression?.enabled === undefined) {
-      if (config.compression?.algorithms) {
-        return config.compression.algorithms.includes(contentEncoding.toLowerCase());
-      }
-      return true;
+    if (config.compression?.algorithms) {
+      return config.compression.algorithms.includes(contentEncoding.toLowerCase());
     }
-    return config.compression.enabled;
+    return true;
   }
   static createZstdDecompressStream(response) {
     const decompressor = getZstdDecompressor();