rezo 1.0.12 → 1.0.13

package/dist/adapters/http2.cjs

@@ -4,14 +4,15 @@ const { URL } = require("node:url");
 const { Readable } = require("node:stream");
 const { RezoError } = require('../errors/rezo-error.cjs');
 const { buildSmartError, buildDecompressionError, builErrorFromResponse, buildDownloadError } = require('../responses/buildError.cjs');
-const { Cookie } = require('../utils/cookies.cjs');
+const { RezoCookieJar } = require('../utils/cookies.cjs');
 const RezoFormData = require('../utils/form-data.cjs');
 const { getDefaultConfig, prepareHTTPOptions } = require('../utils/http-config.cjs');
-const { RezoHeaders } = require('../utils/headers.cjs');
+const { RezoHeaders, sanitizeHttp2Headers } = require('../utils/headers.cjs');
 const { RezoURLSearchParams } = require('../utils/data-operations.cjs');
 const { StreamResponse } = require('../responses/stream.cjs');
 const { DownloadResponse } = require('../responses/download.cjs');
 const { UploadResponse } = require('../responses/upload.cjs');
+const { CompressionUtil } = require('../utils/compression.cjs');
 const { isSameDomain, RezoPerformance } = require('../utils/tools.cjs');
 const { ResponseCache } = require('../cache/response-cache.cjs');
 let zstdDecompressSync = null;
@@ -142,15 +143,14 @@ class Http2SessionPool {
           reject(new Error(`HTTP/2 connection timeout after ${timeout}ms`));
         }
       }, timeout) : null;
+      if (timeoutId && typeof timeoutId === "object" && "unref" in timeoutId) {
+        timeoutId.unref();
+      }
       session.on("connect", () => {
         if (!settled) {
           settled = true;
           if (timeoutId)
             clearTimeout(timeoutId);
-          const socket = session.socket;
-          if (socket && typeof socket.unref === "function") {
-            socket.unref();
-          }
           resolve(session);
         }
       });
@@ -170,6 +170,12 @@ class Http2SessionPool {
     if (entry) {
       entry.refCount = Math.max(0, entry.refCount - 1);
       entry.lastUsed = Date.now();
+      if (entry.refCount === 0) {
+        const socket = entry.session.socket;
+        if (socket && typeof socket.unref === "function") {
+          socket.unref();
+        }
+      }
     }
   }
   closeSession(url) {
@@ -275,38 +281,66 @@ function updateCookies(config, headers, url) {
   if (!setCookieHeaders)
     return;
   const cookieHeaderArray = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
-  if (!config.responseCookies) {
-    config.responseCookies = {
-      array: [],
-      serialized: [],
-      netscape: "",
-      string: "",
-      setCookiesString: []
-    };
+  if (cookieHeaderArray.length === 0)
+    return;
+  const jar = new RezoCookieJar;
+  jar.setCookiesSync(cookieHeaderArray, url);
+  if (config.enableCookieJar && config.cookieJar) {
+    config.cookieJar.setCookiesSync(cookieHeaderArray, url);
   }
-  for (const cookieStr of cookieHeaderArray) {
-    config.responseCookies.setCookiesString.push(cookieStr);
-    const parts = cookieStr.split(";");
-    const [nameValue] = parts;
-    const [name, ...valueParts] = nameValue.split("=");
-    const value = valueParts.join("=");
-    if (name && value !== undefined) {
-      const cookie = new Cookie({
-        key: name.trim(),
-        value: value.trim(),
-        domain: new URL(url).hostname,
-        path: "/",
-        httpOnly: cookieStr.toLowerCase().includes("httponly"),
-        secure: cookieStr.toLowerCase().includes("secure"),
-        sameSite: "lax"
-      });
-      config.responseCookies.array.push(cookie);
+  const cookies = jar.cookies();
+  cookies.setCookiesString = cookieHeaderArray;
+  if (config.useCookies) {
+    const existingArray = config.responseCookies?.array || [];
+    for (const cookie of cookies.array) {
+      const existingIndex = existingArray.findIndex((c) => c.key === cookie.key && c.domain === cookie.domain);
+      if (existingIndex >= 0) {
+        existingArray[existingIndex] = cookie;
+      } else {
+        existingArray.push(cookie);
+      }
+    }
+    const mergedJar = new RezoCookieJar(existingArray, url);
+    config.responseCookies = mergedJar.cookies();
+    config.responseCookies.setCookiesString = cookieHeaderArray;
+  } else {
+    config.responseCookies = cookies;
+  }
+}
+function mergeRequestAndResponseCookies(config, responseCookies, url) {
+  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);
     }
   }
-  config.responseCookies.string = config.responseCookies.array.map((c) => `${c.key}=${c.value}`).join("; ");
-  config.responseCookies.serialized = config.responseCookies.array.map((c) => c.toJSON());
-  config.responseCookies.netscape = config.responseCookies.array.map((c) => c.toNetscapeFormat()).join(`
-`);
+  for (const cookie of responseCookies.array) {
+    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);
+    return mergedJar.cookies();
+  }
+  return {
+    array: [],
+    serialized: [],
+    netscape: `# Netscape HTTP Cookie File
+# This file was generated by Rezo HTTP client
+# Based on uniqhtt cookie implementation
+`,
+    string: "",
+    setCookiesString: []
+  };
 }
 async function executeRequest(options, defaultOptions, jar) {
   if (!options.responseType) {
@@ -484,6 +518,8 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         if (fileName && fs && fs.existsSync(fileName)) {
           fs.unlinkSync(fileName);
         }
+        if (!config.errors)
+          config.errors = [];
         config.errors.push({
           attempt: config.retryAttempts + 1,
           error: response,
@@ -521,7 +557,7 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         }
         continue;
       }
-      if (statusOnNext === "success") {
+      if (statusOnNext === "success" || statusOnNext === "error") {
         return response;
       }
       if (statusOnNext === "redirect") {
@@ -620,6 +656,13 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
       if (!headers["accept-encoding"]) {
         headers["accept-encoding"] = "gzip, deflate, br";
       }
+      if (body instanceof RezoFormData) {
+        headers["content-type"] = `multipart/form-data; boundary=${body.getBoundary()}`;
+      } else if (body instanceof FormData) {
+        const tempForm = await RezoFormData.fromNativeFormData(body);
+        headers["content-type"] = `multipart/form-data; boundary=${tempForm.getBoundary()}`;
+        fetchOptions._convertedFormData = tempForm;
+      }
       const eventEmitter = streamResult || downloadResult || uploadResult;
       if (eventEmitter && requestCount === 0) {
         const startEvent = {
@@ -735,6 +778,25 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         config.timing.endTimestamp = Date.now();
         config.timing.durationMs = performance.now() - timing.startTime;
         config.timing.transferMs = timing.firstByteTime ? performance.now() - timing.firstByteTime : config.timing.durationMs;
+        if (!config.transfer) {
+          config.transfer = { requestSize: 0, responseSize: 0, headerSize: 0, bodySize: 0 };
+        }
+        if (config.transfer.requestSize === undefined) {
+          config.transfer.requestSize = 0;
+        }
+        if (config.transfer.requestSize === 0 && body) {
+          if (typeof body === "string") {
+            config.transfer.requestSize = Buffer.byteLength(body, "utf8");
+          } else if (body instanceof Buffer || body instanceof Uint8Array) {
+            config.transfer.requestSize = body.length;
+          } else if (body instanceof URLSearchParams || body instanceof RezoURLSearchParams) {
+            config.transfer.requestSize = Buffer.byteLength(body.toString(), "utf8");
+          } else if (body instanceof RezoFormData) {
+            config.transfer.requestSize = body.getLengthSync();
+          } else if (typeof body === "object") {
+            config.transfer.requestSize = Buffer.byteLength(JSON.stringify(body), "utf8");
+          }
+        }
         config.transfer.bodySize = contentLengthCounter;
         config.transfer.responseSize = contentLengthCounter;
         (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
@@ -743,7 +805,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             data: "",
             status,
             statusText,
-            headers: new RezoHeaders(responseHeaders),
+            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
             cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
             config,
             contentType: responseHeaders["content-type"],
@@ -756,14 +818,14 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         }
         let responseBody = Buffer.concat(chunks);
         const contentEncoding = responseHeaders["content-encoding"];
-        if (contentEncoding && contentLengthCounter > 0) {
+        if (contentEncoding && contentLengthCounter > 0 && CompressionUtil.shouldDecompress(contentEncoding, config)) {
           try {
             const decompressed = await decompressBuffer(responseBody, contentEncoding);
             responseBody = decompressed;
           } catch (err) {
             const error = buildDecompressionError({
               statusCode: status,
-              headers: responseHeaders,
+              headers: sanitizeHttp2Headers(responseHeaders),
               contentType: responseHeaders["content-type"],
               contentLength: String(contentLengthCounter),
               cookies: config.responseCookies?.setCookiesString || [],
@@ -803,24 +865,17 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             data = responseBody.toString("utf-8");
           }
         }
-        if (status >= 400) {
-          const error = builErrorFromResponse(`HTTP Error ${status}: ${statusText}`, {
-            status,
-            statusText,
-            headers: new RezoHeaders(responseHeaders),
-            data
-          }, config, fetchOptions);
-          _stats.statusOnNext = "error";
-          resolve(error);
-          return;
-        }
-        _stats.statusOnNext = "success";
+        config.status = status;
+        config.statusText = statusText;
+        _stats.statusOnNext = status >= 400 ? "error" : "success";
+        const responseCookies = config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] };
+        const mergedCookies = mergeRequestAndResponseCookies(config, responseCookies, url.href);
         const finalResponse = {
           data,
           status,
           statusText,
-          headers: new RezoHeaders(responseHeaders),
-          cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+          headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
+          cookies: mergedCookies,
           config,
           contentType,
           contentLength: contentLengthCounter,
@@ -833,11 +888,11 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             const downloadFinishEvent = {
               status,
               statusText,
-              headers: new RezoHeaders(responseHeaders),
+              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
               contentType,
               contentLength: responseBody.length,
               finalUrl: url.href,
-              cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+              cookies: mergedCookies,
               urls: buildUrlTree(config, url.href),
               fileName: config.fileName,
               fileSize: responseBody.length,
@@ -858,7 +913,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           } catch (err) {
             const error = buildDownloadError({
               statusCode: status,
-              headers: responseHeaders,
+              headers: sanitizeHttp2Headers(responseHeaders),
               contentType,
               contentLength: String(contentLengthCounter),
               cookies: config.responseCookies?.setCookiesString || [],
@@ -878,7 +933,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           const streamFinishEvent = {
             status,
             statusText,
-            headers: new RezoHeaders(responseHeaders),
+            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
             contentType,
             contentLength: contentLengthCounter,
             finalUrl: url.href,
@@ -904,7 +959,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             response: {
               status,
               statusText,
-              headers: new RezoHeaders(responseHeaders),
+              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
               data,
               contentType,
               contentLength: contentLengthCounter
@@ -949,7 +1004,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             body.pipe(req);
             return;
           } else {
-            const form = await RezoFormData.fromNativeFormData(body);
+            const form = fetchOptions._convertedFormData || await RezoFormData.fromNativeFormData(body);
             form.pipe(req);
             return;
           }

package/dist/adapters/http2.js

@@ -4,14 +4,15 @@ import { URL } from "node:url";
 import { Readable } from "node:stream";
 import { RezoError } from '../errors/rezo-error.js';
 import { buildSmartError, buildDecompressionError, builErrorFromResponse, buildDownloadError } from '../responses/buildError.js';
-import { Cookie } from '../utils/cookies.js';
+import { RezoCookieJar } from '../utils/cookies.js';
 import RezoFormData from '../utils/form-data.js';
 import { getDefaultConfig, prepareHTTPOptions } from '../utils/http-config.js';
-import { RezoHeaders } from '../utils/headers.js';
+import { RezoHeaders, sanitizeHttp2Headers } from '../utils/headers.js';
 import { RezoURLSearchParams } from '../utils/data-operations.js';
 import { StreamResponse } from '../responses/stream.js';
 import { DownloadResponse } from '../responses/download.js';
 import { UploadResponse } from '../responses/upload.js';
+import { CompressionUtil } from '../utils/compression.js';
 import { isSameDomain, RezoPerformance } from '../utils/tools.js';
 import { ResponseCache } from '../cache/response-cache.js';
 let zstdDecompressSync = null;
@@ -142,15 +143,14 @@ class Http2SessionPool {
           reject(new Error(`HTTP/2 connection timeout after ${timeout}ms`));
         }
       }, timeout) : null;
+      if (timeoutId && typeof timeoutId === "object" && "unref" in timeoutId) {
+        timeoutId.unref();
+      }
       session.on("connect", () => {
         if (!settled) {
           settled = true;
           if (timeoutId)
             clearTimeout(timeoutId);
-          const socket = session.socket;
-          if (socket && typeof socket.unref === "function") {
-            socket.unref();
-          }
           resolve(session);
         }
       });
@@ -170,6 +170,12 @@ class Http2SessionPool {
     if (entry) {
       entry.refCount = Math.max(0, entry.refCount - 1);
       entry.lastUsed = Date.now();
+      if (entry.refCount === 0) {
+        const socket = entry.session.socket;
+        if (socket && typeof socket.unref === "function") {
+          socket.unref();
+        }
+      }
     }
   }
   closeSession(url) {
@@ -275,38 +281,66 @@ function updateCookies(config, headers, url) {
   if (!setCookieHeaders)
     return;
   const cookieHeaderArray = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
-  if (!config.responseCookies) {
-    config.responseCookies = {
-      array: [],
-      serialized: [],
-      netscape: "",
-      string: "",
-      setCookiesString: []
-    };
+  if (cookieHeaderArray.length === 0)
+    return;
+  const jar = new RezoCookieJar;
+  jar.setCookiesSync(cookieHeaderArray, url);
+  if (config.enableCookieJar && config.cookieJar) {
+    config.cookieJar.setCookiesSync(cookieHeaderArray, url);
   }
-  for (const cookieStr of cookieHeaderArray) {
-    config.responseCookies.setCookiesString.push(cookieStr);
-    const parts = cookieStr.split(";");
-    const [nameValue] = parts;
-    const [name, ...valueParts] = nameValue.split("=");
-    const value = valueParts.join("=");
-    if (name && value !== undefined) {
-      const cookie = new Cookie({
-        key: name.trim(),
-        value: value.trim(),
-        domain: new URL(url).hostname,
-        path: "/",
-        httpOnly: cookieStr.toLowerCase().includes("httponly"),
-        secure: cookieStr.toLowerCase().includes("secure"),
-        sameSite: "lax"
-      });
-      config.responseCookies.array.push(cookie);
+  const cookies = jar.cookies();
+  cookies.setCookiesString = cookieHeaderArray;
+  if (config.useCookies) {
+    const existingArray = config.responseCookies?.array || [];
+    for (const cookie of cookies.array) {
+      const existingIndex = existingArray.findIndex((c) => c.key === cookie.key && c.domain === cookie.domain);
+      if (existingIndex >= 0) {
+        existingArray[existingIndex] = cookie;
+      } else {
+        existingArray.push(cookie);
+      }
+    }
+    const mergedJar = new RezoCookieJar(existingArray, url);
+    config.responseCookies = mergedJar.cookies();
+    config.responseCookies.setCookiesString = cookieHeaderArray;
+  } else {
+    config.responseCookies = cookies;
+  }
+}
+function mergeRequestAndResponseCookies(config, responseCookies, url) {
+  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);
     }
   }
-  config.responseCookies.string = config.responseCookies.array.map((c) => `${c.key}=${c.value}`).join("; ");
-  config.responseCookies.serialized = config.responseCookies.array.map((c) => c.toJSON());
-  config.responseCookies.netscape = config.responseCookies.array.map((c) => c.toNetscapeFormat()).join(`
-`);
+  for (const cookie of responseCookies.array) {
+    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);
+    return mergedJar.cookies();
+  }
+  return {
+    array: [],
+    serialized: [],
+    netscape: `# Netscape HTTP Cookie File
+# This file was generated by Rezo HTTP client
+# Based on uniqhtt cookie implementation
+`,
+    string: "",
+    setCookiesString: []
+  };
 }
 export async function executeRequest(options, defaultOptions, jar) {
   if (!options.responseType) {
@@ -484,6 +518,8 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         if (fileName && fs && fs.existsSync(fileName)) {
           fs.unlinkSync(fileName);
         }
+        if (!config.errors)
+          config.errors = [];
         config.errors.push({
           attempt: config.retryAttempts + 1,
           error: response,
@@ -521,7 +557,7 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         }
         continue;
       }
-      if (statusOnNext === "success") {
+      if (statusOnNext === "success" || statusOnNext === "error") {
         return response;
       }
       if (statusOnNext === "redirect") {
@@ -620,6 +656,13 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
       if (!headers["accept-encoding"]) {
         headers["accept-encoding"] = "gzip, deflate, br";
       }
+      if (body instanceof RezoFormData) {
+        headers["content-type"] = `multipart/form-data; boundary=${body.getBoundary()}`;
+      } else if (body instanceof FormData) {
+        const tempForm = await RezoFormData.fromNativeFormData(body);
+        headers["content-type"] = `multipart/form-data; boundary=${tempForm.getBoundary()}`;
+        fetchOptions._convertedFormData = tempForm;
+      }
       const eventEmitter = streamResult || downloadResult || uploadResult;
       if (eventEmitter && requestCount === 0) {
         const startEvent = {
@@ -735,6 +778,25 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         config.timing.endTimestamp = Date.now();
         config.timing.durationMs = performance.now() - timing.startTime;
         config.timing.transferMs = timing.firstByteTime ? performance.now() - timing.firstByteTime : config.timing.durationMs;
+        if (!config.transfer) {
+          config.transfer = { requestSize: 0, responseSize: 0, headerSize: 0, bodySize: 0 };
+        }
+        if (config.transfer.requestSize === undefined) {
+          config.transfer.requestSize = 0;
+        }
+        if (config.transfer.requestSize === 0 && body) {
+          if (typeof body === "string") {
+            config.transfer.requestSize = Buffer.byteLength(body, "utf8");
+          } else if (body instanceof Buffer || body instanceof Uint8Array) {
+            config.transfer.requestSize = body.length;
+          } else if (body instanceof URLSearchParams || body instanceof RezoURLSearchParams) {
+            config.transfer.requestSize = Buffer.byteLength(body.toString(), "utf8");
+          } else if (body instanceof RezoFormData) {
+            config.transfer.requestSize = body.getLengthSync();
+          } else if (typeof body === "object") {
+            config.transfer.requestSize = Buffer.byteLength(JSON.stringify(body), "utf8");
+          }
+        }
         config.transfer.bodySize = contentLengthCounter;
         config.transfer.responseSize = contentLengthCounter;
         (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
@@ -743,7 +805,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             data: "",
             status,
             statusText,
-            headers: new RezoHeaders(responseHeaders),
+            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
             cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
             config,
             contentType: responseHeaders["content-type"],
@@ -756,14 +818,14 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         }
         let responseBody = Buffer.concat(chunks);
         const contentEncoding = responseHeaders["content-encoding"];
-        if (contentEncoding && contentLengthCounter > 0) {
+        if (contentEncoding && contentLengthCounter > 0 && CompressionUtil.shouldDecompress(contentEncoding, config)) {
           try {
             const decompressed = await decompressBuffer(responseBody, contentEncoding);
             responseBody = decompressed;
           } catch (err) {
             const error = buildDecompressionError({
               statusCode: status,
-              headers: responseHeaders,
+              headers: sanitizeHttp2Headers(responseHeaders),
               contentType: responseHeaders["content-type"],
               contentLength: String(contentLengthCounter),
               cookies: config.responseCookies?.setCookiesString || [],
@@ -803,24 +865,17 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             data = responseBody.toString("utf-8");
           }
         }
-        if (status >= 400) {
-          const error = builErrorFromResponse(`HTTP Error ${status}: ${statusText}`, {
-            status,
-            statusText,
-            headers: new RezoHeaders(responseHeaders),
-            data
-          }, config, fetchOptions);
-          _stats.statusOnNext = "error";
-          resolve(error);
-          return;
-        }
-        _stats.statusOnNext = "success";
+        config.status = status;
+        config.statusText = statusText;
+        _stats.statusOnNext = status >= 400 ? "error" : "success";
+        const responseCookies = config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] };
+        const mergedCookies = mergeRequestAndResponseCookies(config, responseCookies, url.href);
         const finalResponse = {
           data,
           status,
           statusText,
-          headers: new RezoHeaders(responseHeaders),
-          cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+          headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
+          cookies: mergedCookies,
           config,
           contentType,
           contentLength: contentLengthCounter,
@@ -833,11 +888,11 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             const downloadFinishEvent = {
               status,
               statusText,
-              headers: new RezoHeaders(responseHeaders),
+              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
               contentType,
               contentLength: responseBody.length,
               finalUrl: url.href,
-              cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+              cookies: mergedCookies,
               urls: buildUrlTree(config, url.href),
               fileName: config.fileName,
               fileSize: responseBody.length,
@@ -858,7 +913,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           } catch (err) {
             const error = buildDownloadError({
               statusCode: status,
-              headers: responseHeaders,
+              headers: sanitizeHttp2Headers(responseHeaders),
               contentType,
               contentLength: String(contentLengthCounter),
               cookies: config.responseCookies?.setCookiesString || [],
@@ -878,7 +933,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           const streamFinishEvent = {
             status,
             statusText,
-            headers: new RezoHeaders(responseHeaders),
+            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
             contentType,
             contentLength: contentLengthCounter,
             finalUrl: url.href,
@@ -904,7 +959,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             response: {
               status,
               statusText,
-              headers: new RezoHeaders(responseHeaders),
+              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
               data,
               contentType,
               contentLength: contentLengthCounter
@@ -949,7 +1004,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             body.pipe(req);
             return;
           } else {
-            const form = await RezoFormData.fromNativeFormData(body);
+            const form = fetchOptions._convertedFormData || await RezoFormData.fromNativeFormData(body);
             form.pipe(req);
             return;
           }

package/dist/adapters/index.cjs

@@ -1,6 +1,6 @@
-const _mod_879ve5 = require('./picker.cjs');
-exports.detectRuntime = _mod_879ve5.detectRuntime;
-exports.getAdapterCapabilities = _mod_879ve5.getAdapterCapabilities;
-exports.buildAdapterContext = _mod_879ve5.buildAdapterContext;
-exports.getAvailableAdapters = _mod_879ve5.getAvailableAdapters;
-exports.selectAdapter = _mod_879ve5.selectAdapter;;
+const _mod_h6yyuw = require('./picker.cjs');
+exports.detectRuntime = _mod_h6yyuw.detectRuntime;
+exports.getAdapterCapabilities = _mod_h6yyuw.getAdapterCapabilities;
+exports.buildAdapterContext = _mod_h6yyuw.buildAdapterContext;
+exports.getAvailableAdapters = _mod_h6yyuw.getAvailableAdapters;
+exports.selectAdapter = _mod_h6yyuw.selectAdapter;;

package/dist/cache/index.cjs

@@ -1,13 +1,13 @@
-const _mod_2rlcbw = require('./lru-cache.cjs');
-exports.LRUCache = _mod_2rlcbw.LRUCache;;
-const _mod_faep7r = require('./dns-cache.cjs');
-exports.DNSCache = _mod_faep7r.DNSCache;
-exports.getGlobalDNSCache = _mod_faep7r.getGlobalDNSCache;
-exports.resetGlobalDNSCache = _mod_faep7r.resetGlobalDNSCache;;
-const _mod_kp3skc = require('./response-cache.cjs');
-exports.ResponseCache = _mod_kp3skc.ResponseCache;
-exports.normalizeResponseCacheConfig = _mod_kp3skc.normalizeResponseCacheConfig;;
-const _mod_dok148 = require('./file-cacher.cjs');
-exports.FileCacher = _mod_dok148.FileCacher;;
-const _mod_wzzzfr = require('./url-store.cjs');
-exports.UrlStore = _mod_wzzzfr.UrlStore;;
+const _mod_vgyhxh = require('./lru-cache.cjs');
+exports.LRUCache = _mod_vgyhxh.LRUCache;;
+const _mod_57d30y = require('./dns-cache.cjs');
+exports.DNSCache = _mod_57d30y.DNSCache;
+exports.getGlobalDNSCache = _mod_57d30y.getGlobalDNSCache;
+exports.resetGlobalDNSCache = _mod_57d30y.resetGlobalDNSCache;;
+const _mod_qx55fg = require('./response-cache.cjs');
+exports.ResponseCache = _mod_qx55fg.ResponseCache;
+exports.normalizeResponseCacheConfig = _mod_qx55fg.normalizeResponseCacheConfig;;
+const _mod_clz0cm = require('./file-cacher.cjs');
+exports.FileCacher = _mod_clz0cm.FileCacher;;
+const _mod_39vswi = require('./url-store.cjs');
+exports.UrlStore = _mod_39vswi.UrlStore;;