lifecycleion 0.0.9 → 0.0.11

package/dist/lib/http-client-node/index.js

@@ -0,0 +1,1075 @@
+// src/lib/http-client/adapters/node-adapter.ts
+import * as http from "http";
+import * as https from "https";
+import { urlToHttpOptions } from "url";
+
+// src/lib/http-client/consts.ts
+var NON_RETRYABLE_HTTP_CLIENT_CALLBACK_ERROR_FLAG = "_lifecycleion_non_retryable_http_client_callback_error";
+var STREAM_FACTORY_ERROR_FLAG = "_lifecycleion_stream_factory_error";
+var STREAM_FACTORY_CANCEL_KEY = "_lifecycleion_stream_factory_cancel_reason";
+var RESPONSE_STREAM_ABORT_FLAG = "_lifecycleion_response_stream_abort";
+var REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+  // 301 Moved Permanently
+  301,
+  // 302 Found
+  302,
+  // 303 See Other
+  303,
+  // 307 Temporary Redirect
+  307,
+  // 308 Permanent Redirect
+  308
+]);
+
+// src/lib/http-client/internal/multipart.ts
+function formatFilename(filename) {
+  const fallback = toSafeASCIIQuotedFilenameFallback(filename);
+  const base = isSafeASCIIQuotedFilename(filename) ? `filename="${filename}"` : `filename="${fallback}"`;
+  if (isSafeASCIIQuotedFilename(filename)) {
+    return base;
+  }
+  const encoded = encodeURIComponent(filename).replace(/'/g, "%27").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/\*/g, "%2A");
+  return `${base}; filename*=UTF-8''${encoded}`;
+}
+function isSafeASCIIQuotedFilename(value) {
+  return /^[\u0020-\u007E]+$/.test(value) && !/["\\]/.test(value);
+}
+function toSafeASCIIQuotedFilenameFallback(value) {
+  const normalized = value.normalize("NFKD");
+  let result = "";
+  let wasUnderscore = false;
+  for (const char of normalized) {
+    const code = char.charCodeAt(0);
+    if (code >= 768 && code <= 879) {
+      continue;
+    }
+    const isSafeASCII = (
+      // 0-9
+      code >= 48 && code <= 57 || // A-Z
+      code >= 65 && code <= 90 || // a-z
+      code >= 97 && code <= 122 || char === "." || char === "-" || char === "_"
+    );
+    if (isSafeASCII) {
+      result += char;
+      wasUnderscore = false;
+    } else if (!wasUnderscore) {
+      result += "_";
+      wasUnderscore = true;
+    }
+  }
+  result = result.replace(/^_+|_+$/g, "");
+  return result.length > 0 ? result : "file";
+}
+function formatFieldName(name) {
+  return name.replace(/\r\n|\r|\n/g, " ").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function sanitizeContentType(raw) {
+  return raw.replace(/\r\n|\r|\n/g, "");
+}
+function generateMultipartBoundary() {
+  return `----NodeAdapterFormBoundary${Math.random().toString(36).slice(2)}`;
+}
+function calculateMultipartFormDataSize(formData, boundary) {
+  let size = 0;
+  for (const [name, value] of formData.entries()) {
+    const fieldName = formatFieldName(name);
+    size += Buffer.byteLength(`--${boundary}\r
+`);
+    if (typeof value === "string") {
+      size += Buffer.byteLength(
+        `Content-Disposition: form-data; name="${fieldName}"\r
+\r
+${value}\r
+`
+      );
+    } else {
+      const filename = value.name || "blob";
+      const contentType = sanitizeContentType(value.type) || "application/octet-stream";
+      size += Buffer.byteLength(
+        `Content-Disposition: form-data; name="${fieldName}"; ${formatFilename(filename)}\r
+Content-Type: ${contentType}\r
+\r
+`
+      );
+      size += value.size;
+      size += Buffer.byteLength("\r\n");
+    }
+  }
+  size += Buffer.byteLength(`--${boundary}--\r
+`);
+  return size;
+}
+async function serializeMultipartFormData(formData, req, boundary, onProgress) {
+  const totalSize = calculateMultipartFormDataSize(formData, boundary);
+  req.setHeader("Content-Type", `multipart/form-data; boundary=${boundary}`);
+  req.setHeader("Content-Length", totalSize.toString());
+  let uploadedBytes = 0;
+  const write = (data) => new Promise((resolve, reject) => {
+    let hasWriteReturned = false;
+    let isWriteCallbackDone = false;
+    let isDrainDone = true;
+    const cleanup = () => {
+      req.off("drain", onDrain);
+      req.off("close", onClose);
+      req.off("error", onError);
+    };
+    const maybeResolve = () => {
+      if (isWriteCallbackDone && isDrainDone) {
+        cleanup();
+        uploadedBytes += Buffer.byteLength(data);
+        onProgress?.({
+          loaded: uploadedBytes,
+          total: totalSize,
+          progress: uploadedBytes / totalSize
+        });
+        resolve();
+      }
+    };
+    const onDrain = () => {
+      isDrainDone = true;
+      maybeResolve();
+    };
+    const onClose = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const canContinue = req.write(data, (error) => {
+      if (error) {
+        cleanup();
+        reject(error);
+        return;
+      }
+      isWriteCallbackDone = true;
+      if (hasWriteReturned) {
+        maybeResolve();
+      }
+    });
+    hasWriteReturned = true;
+    if (!canContinue) {
+      isDrainDone = false;
+      req.once("drain", onDrain);
+      req.once("close", onClose);
+      req.once("error", onError);
+      if (req.destroyed) {
+        onClose();
+      }
+    }
+    maybeResolve();
+  });
+  for (const [name, value] of formData.entries()) {
+    const fieldName = formatFieldName(name);
+    if (req.destroyed) {
+      break;
+    }
+    await write(`--${boundary}\r
+`);
+    if (typeof value === "string") {
+      await write(
+        `Content-Disposition: form-data; name="${fieldName}"\r
+\r
+${value}\r
+`
+      );
+    } else {
+      const filename = value.name || "blob";
+      const contentType = sanitizeContentType(value.type) || "application/octet-stream";
+      await write(
+        `Content-Disposition: form-data; name="${fieldName}"; ${formatFilename(filename)}\r
+Content-Type: ${contentType}\r
+\r
+`
+      );
+      const reader = value.stream().getReader();
+      try {
+        while (true) {
+          if (req.destroyed) {
+            await cancelReaderQuietly(reader);
+            break;
+          }
+          const { done: isDone, value: chunk } = await reader.read();
+          if (isDone) {
+            break;
+          }
+          if (req.destroyed) {
+            await cancelReaderQuietly(reader);
+            break;
+          }
+          if (chunk) {
+            await write(chunk);
+          }
+        }
+      } finally {
+        if (req.destroyed) {
+          await cancelReaderQuietly(reader);
+        }
+      }
+      if (!req.destroyed) {
+        await write("\r\n");
+      }
+    }
+  }
+  if (!req.destroyed) {
+    await write(`--${boundary}--\r
+`);
+  }
+}
+async function cancelReaderQuietly(reader) {
+  try {
+    await reader.cancel();
+  } catch {
+  }
+}
+
+// src/lib/http-client/internal/request-body-writer.ts
+var REQUEST_BODY_CHUNK_SIZE = 16 * 1024;
+async function writeRequestBodyChunked(data, req, onProgress) {
+  const totalSize = data.length;
+  if (totalSize === 0) {
+    onProgress?.({ loaded: 0, total: 0, progress: 1 });
+    return;
+  }
+  let uploadedBytes = 0;
+  while (uploadedBytes < totalSize && !req.destroyed) {
+    const chunk = data.subarray(
+      uploadedBytes,
+      uploadedBytes + REQUEST_BODY_CHUNK_SIZE
+    );
+    await writeChunkWithBackpressure(req, chunk, () => {
+      uploadedBytes += chunk.length;
+      onProgress?.({
+        loaded: uploadedBytes,
+        total: totalSize,
+        progress: uploadedBytes / totalSize
+      });
+    });
+  }
+}
+function writeChunkWithBackpressure(req, chunk, onAccepted) {
+  return new Promise((resolve, reject) => {
+    let hasWriteReturned = false;
+    let isWriteCallbackDone = false;
+    let isDrainDone = true;
+    let isSettled = false;
+    const cleanup = () => {
+      req.off("drain", onDrain);
+      req.off("close", onClose);
+      req.off("error", onError);
+    };
+    const maybeResolve = () => {
+      if (isSettled || !isWriteCallbackDone || !isDrainDone) {
+        return;
+      }
+      isSettled = true;
+      cleanup();
+      onAccepted?.();
+      resolve();
+    };
+    const onDrain = () => {
+      isDrainDone = true;
+      maybeResolve();
+    };
+    const onClose = () => {
+      if (isSettled) {
+        return;
+      }
+      isSettled = true;
+      cleanup();
+      resolve();
+    };
+    const onError = (error) => {
+      if (isSettled) {
+        return;
+      }
+      isSettled = true;
+      cleanup();
+      reject(error);
+    };
+    const canContinue = req.write(
+      chunk,
+      (error) => {
+        if (error) {
+          cleanup();
+          reject(error);
+          return;
+        }
+        isWriteCallbackDone = true;
+        if (hasWriteReturned) {
+          maybeResolve();
+        }
+      }
+    );
+    hasWriteReturned = true;
+    if (!canContinue) {
+      isDrainDone = false;
+      req.once("drain", onDrain);
+      req.once("close", onClose);
+      req.once("error", onError);
+      if (req.destroyed) {
+        onClose();
+      }
+    }
+    maybeResolve();
+  });
+}
+
+// src/lib/http-client/internal/tls-error-utils.ts
+var CERT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "CERT_HAS_EXPIRED",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "ERR_TLS_CERT_ALTNAME_INVALID",
+  "ERR_SSL_TLSV13_ALERT_CERTIFICATE_REQUIRED",
+  "ERR_SSL_PEER_DID_NOT_RETURN_A_CERTIFICATE",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY"
+]);
+function isTLSCertificateError(error) {
+  const code = error.code ?? "";
+  if (CERT_ERROR_CODES.has(code)) {
+    return true;
+  }
+  if ((code.startsWith("ERR_TLS_") || code.startsWith("ERR_SSL_")) && code.includes("CERT")) {
+    return true;
+  }
+  return /certificate|self signed|unable to verify|altname/i.test(
+    error.message
+  );
+}
+
+// src/lib/http-client/adapters/node-adapter-utils.ts
+function normalizeNodeRequestHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0) {
+      continue;
+    }
+    result[key.toLowerCase()] = Array.isArray(value) ? value.map((item) => String(item)) : String(value);
+  }
+  return result;
+}
+function materializeNodeRequestHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (!Array.isArray(value)) {
+      result[key] = value;
+      continue;
+    }
+    result[key] = key.toLowerCase() === "cookie" ? (
+      // RFC 6265 cookie-pair delimiter for a single Cookie header field.
+      value.join("; ")
+    ) : value.join(", ");
+  }
+  return result;
+}
+
+// src/lib/http-client/utils.ts
+import qs from "qs";
+
+// src/lib/domain-utils/domain-utils.ts
+import { getDomain, getSubdomain, getPublicSuffix } from "tldts";
+
+// src/lib/domain-utils/helpers.ts
+import { toASCII } from "tr46";
+var INTERNAL_PSEUDO_TLDS = Object.freeze(
+  /* @__PURE__ */ new Set(["localhost", "local", "test", "internal"])
+);
+
+// src/lib/domain-utils/domain-utils.ts
+import { getDomain as getDomain2, getSubdomain as getSubdomain2 } from "tldts";
+
+// src/lib/http-client/utils.ts
+function resolveAbsoluteURL(url, baseURL) {
+  if (!url) {
+    return url;
+  }
+  try {
+    return new URL(url).href;
+  } catch {
+  }
+  if (baseURL) {
+    try {
+      const base = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+      return new URL(url, base).href;
+    } catch {
+    }
+  }
+  return url;
+}
+function scalarHeader(headers, lowercaseName) {
+  const v = headers[lowercaseName];
+  if (v === void 0) {
+    return void 0;
+  }
+  return Array.isArray(v) ? v[0] : v;
+}
+function resolveDetectedRedirectURL(requestURL, status, headers, baseURL) {
+  if (![301, 302, 303, 307, 308].includes(status)) {
+    return void 0;
+  }
+  const location = scalarHeader(headers, "location");
+  if (!location) {
+    return void 0;
+  }
+  try {
+    const absoluteRequestURL = resolveAbsoluteURL(requestURL, baseURL);
+    return new URL(location, absoluteRequestURL).toString();
+  } catch {
+    return location;
+  }
+}
+
+// src/lib/http-client/adapters/node-adapter.ts
+var NodeAdapter = class {
+  _config;
+  constructor(config = {}) {
+    this._config = config;
+  }
+  getType() {
+    return "node";
+  }
+  async send(request) {
+    const parsedURL = new URL(request.requestURL);
+    const urlOptions = urlToHttpOptions(parsedURL);
+    const isHTTPS = parsedURL.protocol === "https:";
+    const httpModule = isHTTPS ? https : http;
+    const options = {
+      method: request.method,
+      headers: materializeNodeRequestHeaders(request.headers)
+      // Timeout is managed by the client via abort signal — the adapter does
+      // not impose its own timeout so the client retains full control.
+    };
+    if (urlOptions.auth) {
+      options.auth = urlOptions.auth;
+    }
+    if (this._config.socketPath) {
+      options.socketPath = this._config.socketPath;
+      options.hostname = urlOptions.hostname;
+      options.port = urlOptions.port;
+      options.path = urlOptions.path;
+    } else {
+      options.hostname = urlOptions.hostname;
+      options.port = urlOptions.port ?? (isHTTPS ? 443 : 80);
+      options.path = urlOptions.path;
+    }
+    if (isHTTPS) {
+      const httpsOptions = options;
+      if (this._config.mtls) {
+        httpsOptions.cert = this._config.mtls.cert;
+        httpsOptions.key = this._config.mtls.key;
+        if (this._config.mtls.ca) {
+          httpsOptions.ca = this._config.mtls.ca;
+        }
+        httpsOptions.rejectUnauthorized = true;
+      }
+      if (this._config.rejectUnauthorized === false) {
+        httpsOptions.rejectUnauthorized = false;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      let activeResponseStream;
+      let activeBufferedResponse;
+      let isStreamFactoryPending = false;
+      let uploadedBodyBytes = 0;
+      let didFireUpload100 = false;
+      const reportUploadProgress = (event) => {
+        if (didFireUpload100) {
+          return;
+        }
+        if (event.progress === 1) {
+          didFireUpload100 = true;
+        }
+        uploadedBodyBytes = Math.max(uploadedBodyBytes, event.loaded);
+        request.onUploadProgress?.(event);
+      };
+      reportUploadProgress({ loaded: 0, total: 0, progress: 0 });
+      const req = httpModule.request(options, (res) => {
+        void (async () => {
+          const status = res.statusCode ?? 0;
+          const headers = normalizeResponseHeaders(res.headers);
+          if (request.streamResponse && status === 200) {
+            const streamAbort = new AbortController();
+            if (request.signal) {
+              if (request.signal.aborted) {
+                streamAbort.abort();
+              }
+              request.signal.addEventListener(
+                "abort",
+                () => {
+                  streamAbort.abort();
+                },
+                { once: true }
+              );
+            }
+            let writable;
+            try {
+              isStreamFactoryPending = true;
+              writable = await request.streamResponse(
+                {
+                  status: 200,
+                  headers,
+                  url: request.requestURL,
+                  attempt: request.attemptNumber ?? 1,
+                  requestID: request.requestID ?? ""
+                },
+                { signal: streamAbort.signal }
+              );
+            } catch (error) {
+              isStreamFactoryPending = false;
+              streamAbort.abort();
+              req.destroy();
+              reject(markStreamFactoryError(error, req, request.headers));
+              return;
+            }
+            isStreamFactoryPending = false;
+            if (streamAbort.signal.aborted) {
+              if (writable && !isStreamResponseCancel(writable)) {
+                writable.destroy();
+              }
+              return;
+            }
+            if (writable === null || isStreamResponseCancel(writable)) {
+              const cancelReason = writable !== null ? writable.reason : void 0;
+              streamAbort.abort();
+              req.destroy();
+              const abortErr = new Error(
+                "Request cancelled by streamResponse factory"
+              );
+              abortErr.name = "AbortError";
+              Object.assign(abortErr, {
+                [STREAM_FACTORY_CANCEL_KEY]: cancelReason ?? true
+              });
+              reject(abortErr);
+              return;
+            }
+            activeResponseStream = {
+              status,
+              headers,
+              writable
+            };
+            const totalBytes2 = parseInt(String(headers["content-length"] ?? "0"), 10) || 0;
+            const streamResult = await streamResponseBody(
+              res,
+              writable,
+              totalBytes2,
+              request.onDownloadProgress
+            );
+            if (streamResult === true) {
+              activeResponseStream = void 0;
+              resolveAdapterResponse(
+                resolve,
+                req,
+                request.requestURL,
+                request.headers,
+                {
+                  status,
+                  headers,
+                  body: null,
+                  isStreamed: true
+                }
+              );
+            } else {
+              activeResponseStream = void 0;
+              streamAbort.abort();
+              destroyWritableQuietly(writable);
+              req.destroy();
+              resolveAdapterResponse(
+                resolve,
+                req,
+                request.requestURL,
+                request.headers,
+                {
+                  status,
+                  headers,
+                  body: null,
+                  isStreamError: true,
+                  streamErrorCode: streamResult.code,
+                  errorCause: streamResult.cause
+                }
+              );
+            }
+            return;
+          }
+          activeBufferedResponse = {
+            status,
+            headers
+          };
+          const chunks = [];
+          let loadedBytes = 0;
+          let didFireDownload100 = false;
+          const totalBytes = parseInt(String(headers["content-length"] ?? "0"), 10) || 0;
+          res.on("data", (chunk) => {
+            chunks.push(chunk);
+            loadedBytes += chunk.length;
+            const progress = totalBytes > 0 ? loadedBytes / totalBytes : -1;
+            if (progress === 1) {
+              didFireDownload100 = true;
+            }
+            request.onDownloadProgress?.({
+              loaded: loadedBytes,
+              // When total is unknown fall back to loaded so the event always
+              // has a sensible non-zero total.
+              total: totalBytes > 0 ? totalBytes : loadedBytes,
+              progress
+            });
+          });
+          res.on("end", () => {
+            activeBufferedResponse = void 0;
+            if (!didFireDownload100) {
+              request.onDownloadProgress?.({
+                loaded: loadedBytes,
+                total: loadedBytes,
+                progress: 1
+              });
+            }
+            const body = chunks.length > 0 ? new Uint8Array(Buffer.concat(chunks)) : null;
+            resolveAdapterResponse(
+              resolve,
+              req,
+              request.requestURL,
+              request.headers,
+              {
+                status,
+                headers,
+                body
+              }
+            );
+          });
+          res.on("error", (err) => {
+            if (!activeBufferedResponse) {
+              return;
+            }
+            activeBufferedResponse = void 0;
+            resolveAdapterResponse(
+              resolve,
+              req,
+              request.requestURL,
+              request.headers,
+              {
+                status,
+                headers,
+                body: null,
+                isStreamError: true,
+                streamErrorCode: "stream_response_error",
+                errorCause: makeResponseStreamError(
+                  "Response stream error",
+                  err
+                )
+              }
+            );
+          });
+          res.on("aborted", () => {
+            if (!activeBufferedResponse) {
+              return;
+            }
+            activeBufferedResponse = void 0;
+            resolveAdapterResponse(
+              resolve,
+              req,
+              request.requestURL,
+              request.headers,
+              {
+                status,
+                headers,
+                body: null,
+                isStreamError: true,
+                streamErrorCode: "stream_response_error",
+                errorCause: makeResponseStreamError("Response stream aborted")
+              }
+            );
+          });
+          res.on("close", () => {
+            if (!activeBufferedResponse) {
+              return;
+            }
+            activeBufferedResponse = void 0;
+            resolveAdapterResponse(
+              resolve,
+              req,
+              request.requestURL,
+              request.headers,
+              {
+                status,
+                headers,
+                body: null,
+                isStreamError: true,
+                streamErrorCode: "stream_response_error",
+                errorCause: makeResponseStreamError(
+                  "Response stream closed before completion"
+                )
+              }
+            );
+          });
+        })().catch((error) => {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        });
+      });
+      req.on("error", (error) => {
+        if (request.signal?.aborted) {
+          const abortErr = new Error("Request aborted");
+          abortErr.name = "AbortError";
+          reject(abortErr);
+          return;
+        }
+        if (isTLSCertificateError(error)) {
+          resolveAdapterResponse(
+            resolve,
+            req,
+            request.requestURL,
+            request.headers,
+            {
+              status: 495,
+              isTransportError: true,
+              isRetryable: false,
+              headers: {},
+              body: null,
+              errorCause: error
+            }
+          );
+          return;
+        }
+        const isRetryableTransportError = uploadedBodyBytes === 0;
+        resolveAdapterResponse(
+          resolve,
+          req,
+          request.requestURL,
+          request.headers,
+          {
+            status: 0,
+            isTransportError: true,
+            isRetryable: isRetryableTransportError,
+            headers: {},
+            body: null,
+            errorCause: error
+          }
+        );
+      });
+      if (request.signal) {
+        if (request.signal.aborted) {
+          req.destroy();
+          const abortErr = new Error("Request aborted");
+          abortErr.name = "AbortError";
+          reject(abortErr);
+          return;
+        }
+        request.signal.addEventListener(
+          "abort",
+          () => {
+            if (activeResponseStream) {
+              const { status, headers, writable } = activeResponseStream;
+              activeResponseStream = void 0;
+              destroyWritableQuietly(writable);
+              req.destroy();
+              const error = new Error(
+                "Request aborted during response streaming"
+              );
+              error.name = "AbortError";
+              reject(
+                markResponseStreamAbortError(
+                  error,
+                  req,
+                  request.headers,
+                  status,
+                  headers
+                )
+              );
+              return;
+            }
+            if (activeBufferedResponse) {
+              const { status, headers } = activeBufferedResponse;
+              activeBufferedResponse = void 0;
+              req.destroy();
+              const error = new Error(
+                "Request aborted during response streaming"
+              );
+              error.name = "AbortError";
+              reject(
+                markResponseStreamAbortError(
+                  error,
+                  req,
+                  request.headers,
+                  status,
+                  headers
+                )
+              );
+              return;
+            }
+            if (isStreamFactoryPending) {
+              req.destroy();
+              const abortErr2 = new Error(
+                "Request aborted during streamResponse setup"
+              );
+              abortErr2.name = "AbortError";
+              reject(markStreamFactoryError(abortErr2, req, request.headers));
+              return;
+            }
+            req.destroy();
+            const abortErr = new Error("Request aborted");
+            abortErr.name = "AbortError";
+            reject(abortErr);
+          },
+          { once: true }
+        );
+      }
+      if (request.body instanceof FormData) {
+        const boundary = generateMultipartBoundary();
+        serializeMultipartFormData(
+          request.body,
+          req,
+          boundary,
+          reportUploadProgress
+        ).then(() => {
+          req.end();
+        }).catch((error) => {
+          req.destroy();
+          resolveAdapterResponse(
+            resolve,
+            req,
+            request.requestURL,
+            request.headers,
+            {
+              status: 0,
+              isTransportError: true,
+              isRetryable: false,
+              headers: {},
+              body: null,
+              errorCause: error instanceof Error ? error : new Error(String(error))
+            }
+          );
+        });
+      } else if (typeof request.body === "string" || request.body instanceof Uint8Array) {
+        const bytes = typeof request.body === "string" ? Buffer.from(request.body, "utf8") : Buffer.from(request.body);
+        req.setHeader("Content-Length", bytes.length.toString());
+        writeRequestBodyChunked(bytes, req, reportUploadProgress).then(() => {
+          req.end();
+        }).catch((error) => {
+          req.destroy();
+          resolveAdapterResponse(
+            resolve,
+            req,
+            request.requestURL,
+            request.headers,
+            {
+              status: 0,
+              isTransportError: true,
+              isRetryable: false,
+              headers: {},
+              body: null,
+              errorCause: error instanceof Error ? error : new Error(String(error))
+            }
+          );
+        });
+      } else {
+        reportUploadProgress({ loaded: 0, total: 0, progress: 1 });
+        req.end();
+      }
+    });
+  }
+};
+async function streamResponseBody(res, writable, totalBytes, onProgress) {
+  return new Promise((resolve) => {
+    let loadedBytes = 0;
+    let didFireDownload100 = false;
+    let isPaused = false;
+    let isSettled = false;
+    let didReceiveEnd = false;
+    const cleanup = () => {
+      removeWritableListener(writable, "drain", onWritableDrain);
+      removeWritableListener(writable, "error", onWritableError);
+      res.off("data", onResponseData);
+      res.off("end", onResponseEnd);
+      res.off("error", onResponseError);
+      res.off("aborted", onResponseAborted);
+      res.off("close", onResponseClose);
+    };
+    const settle = (result) => {
+      if (isSettled) {
+        return;
+      }
+      isSettled = true;
+      cleanup();
+      resolve(result);
+    };
+    const onWritableDrain = () => {
+      if (isPaused) {
+        isPaused = false;
+        res.resume();
+      }
+    };
+    const onWritableError = (error) => {
+      settle({ code: "stream_write_error", cause: error });
+    };
+    const onResponseData = (chunk) => {
+      if (isSettled) {
+        return;
+      }
+      let canContinue;
+      try {
+        canContinue = writable.write(chunk, (error) => {
+          if (error || isSettled) {
+            return;
+          }
+          loadedBytes += chunk.length;
+          const progress = totalBytes > 0 ? loadedBytes / totalBytes : -1;
+          if (progress === 1) {
+            didFireDownload100 = true;
+          }
+          onProgress?.({
+            loaded: loadedBytes,
+            // Fall back to loaded when total is unknown so the event always
+            // has a sensible non-zero total.
+            total: totalBytes > 0 ? totalBytes : loadedBytes,
+            progress
+          });
+        });
+      } catch (error) {
+        settle({
+          code: "stream_write_error",
+          cause: error instanceof Error ? error : new Error(String(error))
+        });
+        return;
+      }
+      if (!canContinue) {
+        isPaused = true;
+        res.pause();
+      }
+    };
+    const onResponseEnd = () => {
+      if (isSettled) {
+        return;
+      }
+      didReceiveEnd = true;
+      try {
+        writable.end(() => {
+          if (isSettled) {
+            return;
+          }
+          if (!didFireDownload100) {
+            onProgress?.({
+              loaded: loadedBytes,
+              total: loadedBytes,
+              progress: 1
+            });
+          }
+          settle(true);
+        });
+      } catch (error) {
+        settle({
+          code: "stream_write_error",
+          cause: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    };
+    const onResponseError = (err) => {
+      const streamError = new Error("Response stream error");
+      streamError.cause = err;
+      settle({ code: "stream_response_error", cause: streamError });
+    };
+    const onResponseAborted = () => {
+      const streamError = new Error("Response stream aborted");
+      settle({ code: "stream_response_error", cause: streamError });
+    };
+    const onResponseClose = () => {
+      if (didReceiveEnd || isSettled) {
+        return;
+      }
+      const streamError = new Error("Response stream closed before completion");
+      settle({ code: "stream_response_error", cause: streamError });
+    };
+    writable.on("drain", onWritableDrain);
+    writable.on("error", onWritableError);
+    res.on("data", onResponseData);
+    res.on("end", onResponseEnd);
+    res.on("error", onResponseError);
+    res.on("aborted", onResponseAborted);
+    res.on("close", onResponseClose);
+  });
+}
+function normalizeResponseHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0) {
+      continue;
+    }
+    result[key] = Array.isArray(value) ? value : String(value);
+  }
+  return result;
+}
+function snapshotEffectiveRequestHeaders(req, fallbackHeaders) {
+  return normalizeNodeRequestHeaders({
+    // Start with the client-level attempt headers, then overlay any adapter-side
+    // mutations (for example multipart Content-Type/Content-Length).
+    ...fallbackHeaders,
+    ...req.getHeaders()
+  });
+}
+function resolveAdapterResponse(resolve, req, requestURL, fallbackHeaders, response) {
+  const detectedRedirectURL = resolveDetectedRedirectURL(
+    requestURL,
+    response.status,
+    response.headers
+  );
+  resolve({
+    ...response,
+    // Flag redirect responses so HTTPClient can surface wasRedirectDetected on
+    // the final HTTPResponse consistently across all adapters. The actual
+    // follow-or-disable decision is still made by HTTPClient's redirect loop.
+    wasRedirectDetected: REDIRECT_STATUS_CODES.has(response.status),
+    ...detectedRedirectURL ? { detectedRedirectURL } : {},
+    effectiveRequestHeaders: snapshotEffectiveRequestHeaders(
+      req,
+      fallbackHeaders
+    )
+  });
+}
+function destroyWritableQuietly(writable) {
+  try {
+    writable.destroy();
+  } catch {
+  }
+}
+function removeWritableListener(writable, event, listener) {
+  const removable = writable;
+  removable.off?.(event, listener);
+}
+function makeResponseStreamError(message, cause) {
+  const error = new Error(message);
+  if (cause) {
+    error.cause = cause;
+  }
+  return error;
+}
+function markStreamFactoryError(error, req, fallbackHeaders) {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  const tagged = normalized;
+  tagged[NON_RETRYABLE_HTTP_CLIENT_CALLBACK_ERROR_FLAG] = true;
+  Object.assign(normalized, { [STREAM_FACTORY_ERROR_FLAG]: true });
+  Object.assign(normalized, {
+    effectiveRequestHeaders: snapshotEffectiveRequestHeaders(
+      req,
+      fallbackHeaders
+    )
+  });
+  return normalized;
+}
+function markResponseStreamAbortError(error, req, fallbackHeaders, status, headers) {
+  const tagged = error;
+  Object.assign(tagged, { [RESPONSE_STREAM_ABORT_FLAG]: true });
+  tagged.effectiveRequestHeaders = snapshotEffectiveRequestHeaders(
+    req,
+    fallbackHeaders
+  );
+  tagged.streamAbortStatus = status;
+  tagged.streamAbortHeaders = headers;
+  return error;
+}
+function isStreamResponseCancel(value) {
+  return value !== null && typeof value === "object" && value.cancel === true;
+}
+export {
+  NodeAdapter
+};
+//# sourceMappingURL=index.js.map