rezo 1.0.137 → 1.0.138

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

@@ -2776,34 +2776,36 @@ export interface RezoRequestConfig<D = any> {
 	 * 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`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`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
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * 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 });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -8581,7 +8583,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.138";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

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

@@ -4103,34 +4103,36 @@ export interface RezoRequestConfig<D = any> {
 	 * 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`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`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
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * 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 });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6096,7 +6098,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.138";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

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

@@ -4103,34 +4103,36 @@ export interface RezoRequestConfig<D = any> {
 	 * 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`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`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
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * 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 });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6171,7 +6173,7 @@ export declare function getSocketTelemetry(socket: Socket): SocketTelemetry | un
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.138";
 /**
  * Type guard to check if an error is a RezoError instance.
  */

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

@@ -4104,34 +4104,36 @@ export interface RezoRequestConfig<D = any> {
 	 * 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`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`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
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * 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 });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6122,7 +6124,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.138";
 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_bxvwu1 = require('../../platform/react-native-providers.cjs');
-exports.createFetchStreamTransport = _mod_bxvwu1.createFetchStreamTransport;
-exports.createExpoFileSystemAdapter = _mod_bxvwu1.createExpoFileSystemAdapter;
-exports.createReactNativeFsAdapter = _mod_bxvwu1.createReactNativeFsAdapter;
-exports.createNetInfoProvider = _mod_bxvwu1.createNetInfoProvider;
-exports.createExpoBackgroundTaskProvider = _mod_bxvwu1.createExpoBackgroundTaskProvider;;
+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;;
 exports.Rezo = Rezo;
 exports.RezoError = RezoError;
 exports.RezoErrorCode = RezoErrorCode;

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

@@ -4103,34 +4103,36 @@ export interface RezoRequestConfig<D = any> {
 	 * 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`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`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
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * 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 });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6096,7 +6098,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.138";
 export interface ExpoFileSystemFileLike {
 	uri?: string;
 	size?: number;

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

@@ -4103,34 +4103,36 @@ export interface RezoRequestConfig<D = any> {
 	 * 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`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`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
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * 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 });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6096,7 +6098,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.138";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/adapters/http.cjs

@@ -382,6 +382,7 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
   const ABSOLUTE_MAX_ATTEMPTS = 50;
   const visitedUrls = new Set;
   let totalAttempts = 0;
+  let staleSocketRetried = false;
   config.setSignal();
   const timeoutClearInstance = config.timeoutClearInstance;
   delete config.timeoutClearInstance;
@@ -414,6 +415,15 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
           duration: perform.now()
         });
         perform.reset();
+        if (response.isStaleSocketReset && !staleSocketRetried) {
+          const staleMethod = (fetchOptions.method || "GET").toUpperCase();
+          const staleBody = fetchOptions.body;
+          const bodyReplayable = staleBody === undefined || staleBody === null || typeof staleBody === "string" || Buffer.isBuffer(staleBody);
+          if (["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"].includes(staleMethod) && bodyReplayable) {
+            staleSocketRetried = true;
+            continue;
+          }
+        }
         if (!retryConfig) {
           throw response;
         }
@@ -734,8 +744,11 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
       if (timeoutManager.hasPhase("total")) {
         timeoutManager.startPhase("total");
       }
+      let connectionWasReused = false;
+      let responseReceived = false;
       try {
         const req = httpModule.request(requestOptions, async (res) => {
+          responseReceived = true;
           timeoutManager.clearPhase("headers");
           if (timeoutManager.hasPhase("body")) {
             timeoutManager.startPhase("body");
@@ -859,6 +872,8 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
           let contentLengthCounter = 0;
           if (streamResult) {
             if (isRedirected) {
+              timeoutManager.clearAll();
+              res.resume();
               resolve(null);
               return;
             }
@@ -1134,6 +1149,9 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
             }
           }
           const error = buildSmartError(config, fetchOptions, err);
+          if (err?.code === "ECONNRESET" && connectionWasReused && !responseReceived) {
+            error.isStaleSocketReset = true;
+          }
           resolve(error);
         });
         req.on("socket", (socket) => {
@@ -1164,6 +1182,7 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
           });
           const reqContext = beginRequestContext(socket, isSecure);
           const telemetry = getSocketTelemetry(socket);
+          connectionWasReused = reqContext.connectionReused;
           if (reqContext.connectionReused) {
             timeoutManager.clearPhase("connect");
             if (timeoutManager.hasPhase("headers")) {
@@ -1531,6 +1550,13 @@ function buildHTTPOptions(fetchOptions, isSecure, url) {
       keepAlive,
       keepAliveMsecs: keepAlive ? keepAliveMsecs : undefined
     });
+  } else if (keepAlive === false) {
+    agent = isSecure ? new https.Agent({
+      keepAlive: false,
+      ...useSecureContext ? { secureContext: createSecureContext() } : {},
+      servername: url.hostname,
+      rejectUnauthorized
+    }) : new http.Agent({ keepAlive: false });
   } else if (useAgentPool) {
     const agentPool = getGlobalAgentPool({
       keepAlive: true,

package/dist/adapters/http.js

@@ -382,6 +382,7 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
   const ABSOLUTE_MAX_ATTEMPTS = 50;
   const visitedUrls = new Set;
   let totalAttempts = 0;
+  let staleSocketRetried = false;
   config.setSignal();
   const timeoutClearInstance = config.timeoutClearInstance;
   delete config.timeoutClearInstance;
@@ -414,6 +415,15 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
           duration: perform.now()
         });
         perform.reset();
+        if (response.isStaleSocketReset && !staleSocketRetried) {
+          const staleMethod = (fetchOptions.method || "GET").toUpperCase();
+          const staleBody = fetchOptions.body;
+          const bodyReplayable = staleBody === undefined || staleBody === null || typeof staleBody === "string" || Buffer.isBuffer(staleBody);
+          if (["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"].includes(staleMethod) && bodyReplayable) {
+            staleSocketRetried = true;
+            continue;
+          }
+        }
         if (!retryConfig) {
           throw response;
         }
@@ -734,8 +744,11 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
       if (timeoutManager.hasPhase("total")) {
         timeoutManager.startPhase("total");
       }
+      let connectionWasReused = false;
+      let responseReceived = false;
       try {
         const req = httpModule.request(requestOptions, async (res) => {
+          responseReceived = true;
           timeoutManager.clearPhase("headers");
           if (timeoutManager.hasPhase("body")) {
             timeoutManager.startPhase("body");
@@ -859,6 +872,8 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
           let contentLengthCounter = 0;
           if (streamResult) {
             if (isRedirected) {
+              timeoutManager.clearAll();
+              res.resume();
               resolve(null);
               return;
             }
@@ -1134,6 +1149,9 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
             }
           }
           const error = buildSmartError(config, fetchOptions, err);
+          if (err?.code === "ECONNRESET" && connectionWasReused && !responseReceived) {
+            error.isStaleSocketReset = true;
+          }
           resolve(error);
         });
         req.on("socket", (socket) => {
@@ -1164,6 +1182,7 @@ async function request(config, fetchOptions, requestCount, timing, _stats, _resp
           });
           const reqContext = beginRequestContext(socket, isSecure);
           const telemetry = getSocketTelemetry(socket);
+          connectionWasReused = reqContext.connectionReused;
           if (reqContext.connectionReused) {
             timeoutManager.clearPhase("connect");
             if (timeoutManager.hasPhase("headers")) {
@@ -1531,6 +1550,13 @@ function buildHTTPOptions(fetchOptions, isSecure, url) {
       keepAlive,
       keepAliveMsecs: keepAlive ? keepAliveMsecs : undefined
     });
+  } else if (keepAlive === false) {
+    agent = isSecure ? new https.Agent({
+      keepAlive: false,
+      ...useSecureContext ? { secureContext: createSecureContext() } : {},
+      servername: url.hostname,
+      rejectUnauthorized
+    }) : new http.Agent({ keepAlive: false });
   } else if (useAgentPool) {
     const agentPool = getGlobalAgentPool({
       keepAlive: true,

package/dist/adapters/index.cjs

@@ -1,10 +1,10 @@
-const _mod_d6ixx4 = require('./picker.cjs');
-exports.detectRuntime = _mod_d6ixx4.detectRuntime;
-exports.getAdapterCapabilities = _mod_d6ixx4.getAdapterCapabilities;
-exports.buildAdapterContext = _mod_d6ixx4.buildAdapterContext;
-exports.getAvailableAdapters = _mod_d6ixx4.getAvailableAdapters;
-exports.selectAdapter = _mod_d6ixx4.selectAdapter;
-exports.getAdapterDiagnostics = _mod_d6ixx4.getAdapterDiagnostics;
-exports.createAdapterPicker = _mod_d6ixx4.createAdapterPicker;
-exports.clearAdapterCache = _mod_d6ixx4.clearAdapterCache;
-exports.loadAdapter = _mod_d6ixx4.loadAdapter;;
+const _mod_jy8lw5 = require('./picker.cjs');
+exports.detectRuntime = _mod_jy8lw5.detectRuntime;
+exports.getAdapterCapabilities = _mod_jy8lw5.getAdapterCapabilities;
+exports.buildAdapterContext = _mod_jy8lw5.buildAdapterContext;
+exports.getAvailableAdapters = _mod_jy8lw5.getAvailableAdapters;
+exports.selectAdapter = _mod_jy8lw5.selectAdapter;
+exports.getAdapterDiagnostics = _mod_jy8lw5.getAdapterDiagnostics;
+exports.createAdapterPicker = _mod_jy8lw5.createAdapterPicker;
+exports.clearAdapterCache = _mod_jy8lw5.clearAdapterCache;
+exports.loadAdapter = _mod_jy8lw5.loadAdapter;;

package/dist/adapters/index.d.ts

@@ -4028,34 +4028,36 @@ export interface RezoRequestConfig<D = any> {
 	 * 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`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`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
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * 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 });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**

package/dist/cache/index.cjs

@@ -1,9 +1,9 @@
-const _mod_i4ek3a = require('./lru-cache.cjs');
-exports.LRUCache = _mod_i4ek3a.LRUCache;;
-const _mod_ekaq2h = require('./dns-cache.cjs');
-exports.DNSCache = _mod_ekaq2h.DNSCache;
-exports.getGlobalDNSCache = _mod_ekaq2h.getGlobalDNSCache;
-exports.resetGlobalDNSCache = _mod_ekaq2h.resetGlobalDNSCache;;
-const _mod_6jt456 = require('./response-cache.cjs');
-exports.ResponseCache = _mod_6jt456.ResponseCache;
-exports.normalizeResponseCacheConfig = _mod_6jt456.normalizeResponseCacheConfig;;
+const _mod_a07f40 = require('./lru-cache.cjs');
+exports.LRUCache = _mod_a07f40.LRUCache;;
+const _mod_e8bo0m = require('./dns-cache.cjs');
+exports.DNSCache = _mod_e8bo0m.DNSCache;
+exports.getGlobalDNSCache = _mod_e8bo0m.getGlobalDNSCache;
+exports.resetGlobalDNSCache = _mod_e8bo0m.resetGlobalDNSCache;;
+const _mod_xklic4 = require('./response-cache.cjs');
+exports.ResponseCache = _mod_xklic4.ResponseCache;
+exports.normalizeResponseCacheConfig = _mod_xklic4.normalizeResponseCacheConfig;;