lifecycleion 0.0.20 → 0.0.21

package/dist/lib/http-client/index.cjs

@@ -1227,18 +1227,204 @@ function isFunction(value) {
   return typeof value === "function" || value instanceof Function;
 }
 
+// src/lib/global-event-target.ts
+var GLOBAL_KEY = "__lifecycleion_global_event_target__";
+var METHOD_NAMES = [
+  "addEventListener",
+  "removeEventListener",
+  "dispatchEvent"
+];
+var g = globalThis;
+function getState() {
+  const value = readGlobal(GLOBAL_KEY);
+  return value === UNREADABLE ? void 0 : asUsableState(value);
+}
+function asUsableState(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  return asUsableTarget(readMember(value, "target")) === null ? void 0 : value;
+}
+function asUsableTarget(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  for (const name of METHOD_NAMES) {
+    if (typeof readMember(value, name) !== "function") {
+      return null;
+    }
+  }
+  return value;
+}
+function bindTargetMethods(target) {
+  const bound = {};
+  for (const name of METHOD_NAMES) {
+    const method = readMember(target, name);
+    if (typeof method !== "function") {
+      return null;
+    }
+    let boundMethod;
+    try {
+      boundMethod = method.bind(target);
+    } catch {
+      return null;
+    }
+    if (typeof boundMethod !== "function") {
+      return null;
+    }
+    bound[name] = boundMethod;
+  }
+  return bound;
+}
+function isStateInstalled(state) {
+  return state !== void 0 && readMember(state, "isInstalled") === true;
+}
+function readStateTarget(state) {
+  if (state === void 0) {
+    return null;
+  }
+  return asUsableTarget(readMember(state, "target"));
+}
+var UNREADABLE = /* @__PURE__ */ Symbol("lifecycleion.unreadable");
+function readGlobal(name) {
+  try {
+    return g[name];
+  } catch {
+    return UNREADABLE;
+  }
+}
+function readMember(source, key) {
+  try {
+    return source[key];
+  } catch {
+    return UNREADABLE;
+  }
+}
+function probeMember(name) {
+  const value = readGlobal(name);
+  if (value === UNREADABLE) {
+    return "hostile";
+  }
+  if (typeof value === "function") {
+    return "usable";
+  }
+  return value === void 0 ? "absent" : "occupied";
+}
+function canDefineProperty(key) {
+  const descriptor = Object.getOwnPropertyDescriptor(g, key);
+  if (descriptor === void 0) {
+    return Object.isExtensible(g);
+  }
+  return descriptor.configurable === true;
+}
+function installGlobalEventTarget() {
+  const members = METHOD_NAMES.map((name) => probeMember(name));
+  if (members.every((member) => member === "usable")) {
+    return isStateInstalled(getState()) ? "already-installed" : "native";
+  }
+  if (members.some((member) => member !== "absent")) {
+    return "partial";
+  }
+  const eventTargetConstructor = readGlobal("EventTarget");
+  if (typeof eventTargetConstructor !== "function") {
+    return "unsupported";
+  }
+  const isDefinable = [...METHOD_NAMES, GLOBAL_KEY].every(
+    (key) => canDefineProperty(key)
+  );
+  if (!isDefinable) {
+    return "blocked";
+  }
+  const existingState = getState();
+  const defined = [];
+  const priorStateDescriptor = Object.getOwnPropertyDescriptor(g, GLOBAL_KEY);
+  const rollback = () => {
+    for (const key of defined) {
+      if (key === GLOBAL_KEY && priorStateDescriptor !== void 0) {
+        try {
+          Object.defineProperty(g, GLOBAL_KEY, priorStateDescriptor);
+        } catch {
+        }
+        continue;
+      }
+      try {
+        Reflect.deleteProperty(g, key);
+      } catch {
+      }
+    }
+  };
+  const reusableTarget = readStateTarget(existingState);
+  const reusableMethods = reusableTarget === null ? null : bindTargetMethods(reusableTarget);
+  let state;
+  let methods;
+  try {
+    if (existingState === void 0 || reusableMethods === null) {
+      let target;
+      try {
+        target = new eventTargetConstructor();
+      } catch {
+        return "unsupported";
+      }
+      const freshMethods = bindTargetMethods(target);
+      if (freshMethods === null) {
+        return "unsupported";
+      }
+      state = { target, isInstalled: false };
+      methods = freshMethods;
+      Object.defineProperty(g, GLOBAL_KEY, {
+        value: state,
+        enumerable: false,
+        writable: false,
+        configurable: true
+      });
+      defined.push(GLOBAL_KEY);
+    } else {
+      state = existingState;
+      methods = reusableMethods;
+    }
+    for (const name of METHOD_NAMES) {
+      Object.defineProperty(g, name, {
+        value: methods[name],
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+      defined.push(name);
+    }
+    if (readMember(state, "isInstalled") !== true) {
+      state.isInstalled = true;
+    }
+  } catch {
+    rollback();
+    return "blocked";
+  }
+  return "installed";
+}
+function isGlobalEventTargetAvailable() {
+  return METHOD_NAMES.every((name) => probeMember(name) === "usable") && probeMember("ErrorEvent") === "usable";
+}
+
 // src/lib/safe-handle-callback.ts
+installGlobalEventTarget();
+function reportCallbackError(callbackName, error) {
+  installGlobalEventTarget();
+  if (!isGlobalEventTargetAvailable()) {
+    return;
+  }
+  try {
+    globalThis.dispatchEvent(
+      new ErrorEvent("reportError", {
+        error: new Error(
+          `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
+        )
+      })
+    );
+  } catch {
+  }
+}
 async function safeHandleCallbackAndWait(callbackName, callback, ...args) {
   const handleError = (error) => {
-    if (typeof globalThis.dispatchEvent === "function") {
-      globalThis.dispatchEvent(
-        new ErrorEvent("reportError", {
-          error: new Error(
-            `Error in a callback ${callbackName}: ${DOUBLE_EOL}${errorToString(error)}`
-          )
-        })
-      );
-    }
+    reportCallbackError(callbackName, error);
     return { success: false, error };
   };
   if (isFunction(callback)) {
@@ -2003,6 +2189,74 @@ function matchesFilter(filter, context, phaseType, kind) {
   return true;
 }
 
+// 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",
+  "CERT_REVOKED"
+]);
+var CRL_CODE_PATTERN = /(?:^|_)CRLS?(?:_|$)/;
+var TRANSPORT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "EPIPE",
+  "EHOSTUNREACH",
+  "EHOSTDOWN",
+  "ENETUNREACH",
+  "ENETDOWN",
+  "EADDRNOTAVAIL"
+]);
+var UNDICI_TRANSPORT_ERROR_PREFIX = "UND_ERR_";
+function isTLSCertificateError(error) {
+  if (isTLSCertificateErrorSelf(error)) {
+    return true;
+  }
+  const cause = readMember2(error, "cause");
+  return isErrorValue(cause) ? isTLSCertificateErrorSelf(cause) : false;
+}
+function isErrorValue(value) {
+  try {
+    return value instanceof Error;
+  } catch {
+    return false;
+  }
+}
+function isTLSCertificateErrorSelf(error) {
+  const rawCode = readMember2(error, "code");
+  const code = typeof rawCode === "string" ? rawCode : "";
+  if (CERT_ERROR_CODES.has(code)) {
+    return true;
+  }
+  if (CRL_CODE_PATTERN.test(code)) {
+    return true;
+  }
+  if ((code.startsWith("ERR_TLS_") || code.startsWith("ERR_SSL_")) && code.includes("CERT")) {
+    return true;
+  }
+  if (TRANSPORT_ERROR_CODES.has(code) || code.startsWith(UNDICI_TRANSPORT_ERROR_PREFIX)) {
+    return false;
+  }
+  const message = readMember2(error, "message");
+  return typeof message === "string" ? /certificate|self signed|unable to verify|altname/i.test(message) : false;
+}
+function readMember2(error, key) {
+  try {
+    return error[key];
+  } catch {
+    return void 0;
+  }
+}
+
 // src/lib/http-client/consts.ts
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([
   // 0: Browser/XHR-style "no response" status.
@@ -2038,6 +2292,7 @@ var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([
   // 599 Network Connect Timeout Error (non-standard)
   599
 ]);
+var NON_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["POST", "PATCH"]);
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_REQUEST_ID_HEADER = "x-local-client-request-id";
 var DEFAULT_REQUEST_ATTEMPT_HEADER = "x-local-client-request-attempt";
@@ -2123,12 +2378,23 @@ var FetchAdapter = class {
       if (isAbortError(error) || signal?.aborted) {
         throw error;
       }
+      const normalizedError = normalizeError(error);
+      if (isTLSCertificateError(normalizedError)) {
+        return {
+          status: 495,
+          isTransportError: true,
+          isRetryable: false,
+          headers: {},
+          body: null,
+          errorCause: normalizedError
+        };
+      }
       return {
         status: 0,
         isTransportError: true,
         headers: {},
         body: null,
-        errorCause: error instanceof Error ? error : new Error(String(error))
+        errorCause: normalizedError
       };
     }
     if (response.type === "opaqueredirect") {
@@ -2142,13 +2408,43 @@ var FetchAdapter = class {
       };
     }
     request.onUploadProgress?.({ loaded: 1, total: 1, progress: 1 });
-    const rawBody = await readResponseBody(method, response);
+    const responseHeadersForBody = extractFetchHeaders(response.headers);
+    let rawBody;
+    try {
+      rawBody = await readResponseBody(method, response);
+    } catch (error) {
+      if (isAbortError(error) || signal?.aborted) {
+        throw markResponseStreamAbort(
+          error,
+          response.status,
+          responseHeadersForBody
+        );
+      }
+      const detectedRedirectURL2 = resolveDetectedRedirectURL(
+        requestURL,
+        response.status,
+        responseHeadersForBody
+      );
+      return {
+        status: response.status,
+        wasRedirectDetected: detectedRedirectURL2 !== void 0 || REDIRECT_STATUS_CODES.has(response.status),
+        ...detectedRedirectURL2 ? { detectedRedirectURL: detectedRedirectURL2 } : {},
+        headers: responseHeadersForBody,
+        body: null,
+        isStreamError: true,
+        // fetch buffers the body for us, so there is no per-chunk delivery to
+        // distinguish a local write failure from an upstream stream failure.
+        // Everything reaching here is an upstream/transfer failure.
+        streamErrorCode: "stream_response_error",
+        errorCause: normalizeError(error)
+      };
+    }
     request.onDownloadProgress?.({
       loaded: rawBody?.length ?? 0,
       total: rawBody?.length ?? 0,
       progress: 1
     });
-    const responseHeaders = extractFetchHeaders(response.headers);
+    const responseHeaders = responseHeadersForBody;
     const detectedRedirectURL = resolveDetectedRedirectURL(
       requestURL,
       response.status,
@@ -2173,7 +2469,33 @@ async function readResponseBody(method, response) {
   return new Uint8Array(buffer);
 }
 function isAbortError(error) {
-  return error instanceof Error && error.name === "AbortError";
+  const normalized = asError(error);
+  return normalized !== void 0 && readObjectMember(normalized, "name") === "AbortError";
+}
+function asError(value) {
+  try {
+    return value instanceof Error ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function normalizeError(value) {
+  const existing = asError(value);
+  if (existing !== void 0) {
+    return existing;
+  }
+  try {
+    return new Error(String(value));
+  } catch {
+    return new Error("Unknown error");
+  }
+}
+function readObjectMember(source, key) {
+  try {
+    return source[key];
+  } catch {
+    return void 0;
+  }
 }
 function materializeFetchHeaders(headers) {
   let shouldUseHeadersObject = false;
@@ -2202,6 +2524,22 @@ function materializeFetchHeaders(headers) {
   }
   return materialized;
 }
+function markResponseStreamAbort(error, status, headers) {
+  const original = asError(error);
+  const originalMessage = original === void 0 ? void 0 : readObjectMember(original, "message");
+  const originalName = original === void 0 ? void 0 : readObjectMember(original, "name");
+  const tagged = new Error(
+    typeof originalMessage === "string" ? originalMessage : "Request aborted"
+  );
+  tagged.name = typeof originalName === "string" ? originalName : "AbortError";
+  Object.assign(tagged, {
+    [RESPONSE_STREAM_ABORT_FLAG]: true,
+    streamAbortStatus: status,
+    streamAbortHeaders: headers,
+    cause: error
+  });
+  return tagged;
+}
 
 // src/lib/http-client/internal/header-utils.ts
 function isBrowserRestrictedHeader(key, value) {
@@ -2361,6 +2699,7 @@ var HTTPRequestBuilder = class {
   _timeout;
   _signal;
   _retryPolicy;
+  _retryNonIdempotentMethods;
   _label;
   _onUploadProgress;
   _onDownloadProgress;
@@ -2445,6 +2784,15 @@ var HTTPRequestBuilder = class {
     this._retryPolicy = options;
     return this;
   }
+  /**
+   * Allow or forbid retrying this request when its method is not idempotent
+   * (`POST`, `PATCH`). Overrides the client config for this request only.
+   */
+  retryNonIdempotentMethods(allow) {
+    this._assertNotSent("retryNonIdempotentMethods");
+    this._retryNonIdempotentMethods = allow;
+    return this;
+  }
   onUploadProgress(fn) {
     this._assertNotSent("onUploadProgress");
     this._onUploadProgress = fn;
@@ -2573,6 +2921,7 @@ var HTTPRequestBuilder = class {
         timeout: this._timeout,
         signal: this._signal,
         retryPolicy: this._retryPolicy,
+        retryNonIdempotentMethods: this._retryNonIdempotentMethods,
         label: this._label,
         onUploadProgress: this._onUploadProgress,
         onDownloadProgress: this._onDownloadProgress,
@@ -2632,6 +2981,9 @@ var HTTPRequestBuilder = class {
     if (opts.retryPolicy !== void 0) {
       this.retryPolicy(opts.retryPolicy);
     }
+    if (opts.retryNonIdempotentMethods !== void 0) {
+      this.retryNonIdempotentMethods(opts.retryNonIdempotentMethods);
+    }
     if (opts.label !== void 0) {
       this.label(opts.label);
     }
@@ -2830,6 +3182,7 @@ var BaseHTTPClient = class {
       timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
       cookieJar: config.cookieJar,
       retryPolicy: config.retryPolicy,
+      retryNonIdempotentMethods: config.retryNonIdempotentMethods ?? false,
       includeRequestID: config.includeRequestID ?? false,
       includeAttemptHeader: config.includeAttemptHeader ?? false,
       userAgent: config.userAgent,
@@ -3109,7 +3462,7 @@ var BaseHTTPClient = class {
             requestID,
             false,
             "interceptor_error",
-            error instanceof Error ? error : new Error(String(error))
+            normalizeError2(error)
           );
           callbacks.setError(normalizedError);
           trackedCallbacks.setState("failed");
@@ -3214,7 +3567,14 @@ var BaseHTTPClient = class {
                 body: null
               },
               requestID,
+              // Provably false: a cancel settles with no adapter response, and
+              // this branch is guarded on having one.
               wasCancelled: false,
+              // Hardcoded even when a per-attempt timeout struck mid-body. The
+              // request ends at the redirect either way, so `redirect_disabled`
+              // is the outcome the caller acts on; surfacing the timeout would
+              // reclassify the error code on whether the body happened to
+              // finish. See docs/http-client.md.
               wasTimeout: false,
               adapterType: this._adapter.getType(),
               initialURL: finalRequest.requestURL,
@@ -3225,7 +3585,7 @@ var BaseHTTPClient = class {
             errorCode = "redirect_disabled";
             break;
           }
-          if (this._config.followRedirects && adapterResponse && REDIRECT_STATUS_CODES.has(adapterResponse.status)) {
+          if (this._config.followRedirects && adapterResponse && !adapterResponse.isStreamError && REDIRECT_STATUS_CODES.has(adapterResponse.status)) {
             hopCount++;
             if (hopCount > this._config.maxRedirects) {
               response = this._buildResponse({
@@ -3340,7 +3700,7 @@ var BaseHTTPClient = class {
                 isNetworkErrorOverride: false
               });
               errorCode = "interceptor_error";
-              adapterCause = error instanceof Error ? error : new Error(String(error));
+              adapterCause = normalizeError2(error);
               break;
             }
             if ("cancel" in redirectIntercept) {
@@ -3418,7 +3778,7 @@ var BaseHTTPClient = class {
           requestID,
           false,
           "request_setup_error",
-          error instanceof Error ? error : new Error(String(error))
+          normalizeError2(error)
         );
         callbacks.setAttemptCount(completedAttemptCount);
         callbacks.setNextRetryDelayMS(null);
@@ -3555,11 +3915,28 @@ var BaseHTTPClient = class {
     const startAttempt = params.startAttemptNumber ?? 1;
     const redirectHistory = params.redirectHistory ?? [];
     const cookieJar = params.cookieJar ?? null;
+    const isRetryAvailable = () => policy !== null && policy.errors.length < policy.maxRetryAttempts;
+    const allowNonIdempotentRetry = options.retryNonIdempotentMethods ?? this._config.retryNonIdempotentMethods;
     let attemptNumber = startAttempt - 1;
     let isRetriesExhausted = false;
     while (true) {
       attemptNumber++;
       const isRetry = attemptNumber > startAttempt;
+      const emitAttemptEnd = (outcome) => {
+        options.onAttemptEnd?.({
+          attemptNumber,
+          isRetry,
+          nextRetryDelayMS: void 0,
+          nextRetryAt: void 0,
+          ...outcome,
+          requestID,
+          initialURL,
+          ...hopContext ? {
+            hopNumber: hopContext.hopNumber,
+            redirect: hopContext.redirect
+          } : {}
+        });
+      };
       if (attemptNumber === 1) {
         callbacks.setStartedAt(Date.now());
       } else {
@@ -3621,19 +3998,11 @@ var BaseHTTPClient = class {
           }
         } catch (error) {
           clearTimeout(timeoutID);
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: false,
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: 0
           });
           return {
             adapterResponse: null,
@@ -3647,24 +4016,16 @@ var BaseHTTPClient = class {
             wasTimeout: false,
             isRetriesExhausted: false,
             errorCode: "interceptor_error",
-            adapterCause: error instanceof Error ? error : new Error(String(error))
+            adapterCause: normalizeError2(error)
           };
         }
         if ("cancel" in retryIntercept) {
           clearTimeout(timeoutID);
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: false,
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: 0
           });
           return {
             adapterResponse: null,
@@ -3737,19 +4098,11 @@ var BaseHTTPClient = class {
           );
         }
         if (adapterResponse.wasRedirectDetected && adapterResponse.status === 0 && !this._config.followRedirects) {
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: false,
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: 0
           });
           return {
             adapterResponse,
@@ -3761,7 +4114,10 @@ var BaseHTTPClient = class {
             errorCode: "redirect_disabled"
           };
         }
-        if (policy && adapterResponse.isRetryable !== false && !adapterResponse.isStreamError && RETRYABLE_STATUS_CODES.has(adapterResponse.status) && !cancelSignal.aborted) {
+        const isTransportOutcome = adapterResponse.isTransportError === true;
+        const isMethodReplayable = allowNonIdempotentRetry || !NON_IDEMPOTENT_METHODS.has(sentRequest.method) || isTransportOutcome && adapterResponse.wasDefinitelyNotSent === true;
+        const retrySuppressedReason = isRetryAvailable() && RETRYABLE_STATUS_CODES.has(adapterResponse.status) && !cancelSignal.aborted ? adapterResponse.isRetryable === false ? "adapter_veto" : adapterResponse.isStreamError ? "stream_error" : !isMethodReplayable ? "non_idempotent_method" : void 0 : void 0;
+        if (policy && adapterResponse.isRetryable !== false && !adapterResponse.isStreamError && isMethodReplayable && RETRYABLE_STATUS_CODES.has(adapterResponse.status) && !cancelSignal.aborted) {
           const { shouldRetry, delayMS } = policy.shouldRetry(
             new Error(`HTTP ${adapterResponse.status}`)
           );
@@ -3771,19 +4127,11 @@ var BaseHTTPClient = class {
             callbacks.setNextRetryAt(nextRetryAt ?? null);
             callbacks.setState("waiting_for_retry");
           }
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: shouldRetry,
             nextRetryDelayMS: shouldRetry ? delayMS : void 0,
             nextRetryAt,
-            status: adapterResponse.status,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: adapterResponse.status
           });
           if (shouldRetry) {
             const retryHTTPResponse = this._buildResponse({
@@ -3822,22 +4170,18 @@ var BaseHTTPClient = class {
           }
           isRetriesExhausted = true;
         } else {
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: false,
+            ...retrySuppressedReason ? { retrySuppressedReason } : {},
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: adapterResponse.status,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: adapterResponse.status
           });
         }
-        const responseCause = adapterResponse.errorCause instanceof Error ? adapterResponse.errorCause : void 0;
+        const responseCauseValue = adapterResponse.errorCause;
+        const responseCause = asErrorValue(
+          responseCauseValue
+        ) ? responseCauseValue : void 0;
         const streamErrorCode = adapterResponse.isStreamError ? adapterResponse.streamErrorCode ?? "stream_write_error" : void 0;
         return {
           adapterResponse,
@@ -3851,20 +4195,19 @@ var BaseHTTPClient = class {
         };
       } catch (error) {
         clearTimeout(timeoutID);
+        const abortedResponse = isResponseStreamAbortError(error) ? getResponseStreamAbortInfo(error) : void 0;
+        if (cookieJar && abortedResponse) {
+          cookieJar.processResponseHeaders(
+            abortedResponse.headers,
+            sentRequest.requestURL
+          );
+        }
         if (cancelSignal.aborted && !isAbortError2(error)) {
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: false,
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: 0
           });
           const signalReason = getSignalCancelReason(cancelSignal);
           return {
@@ -3877,21 +4220,26 @@ var BaseHTTPClient = class {
             ...signalReason !== void 0 ? { cancelReason: signalReason } : {}
           };
         }
-        if (isAbortError2(error) && isResponseStreamAbortError(error)) {
+        if (isResponseStreamAbortError(error)) {
+          const streamCause = normalizeError2(error);
+          const streamSuppressionReason = (status) => isRetryAvailable() && RETRYABLE_STATUS_CODES.has(status) && !cancelSignal.aborted ? "stream_error" : void 0;
+          const redirectFieldsFor = (status, headers) => {
+            const detectedRedirectURL = resolveDetectedRedirectURL(
+              sentRequest.requestURL,
+              status,
+              headers
+            );
+            return {
+              wasRedirectDetected: detectedRedirectURL !== void 0 || REDIRECT_STATUS_CODES.has(status),
+              ...detectedRedirectURL ? { detectedRedirectURL } : {}
+            };
+          };
           if (cancelSignal.aborted) {
-            options.onAttemptEnd?.({
-              attemptNumber,
-              isRetry,
+            emitAttemptEnd({
               willRetry: false,
               nextRetryDelayMS: void 0,
               nextRetryAt: void 0,
-              status: 0,
-              requestID,
-              initialURL,
-              ...hopContext ? {
-                hopNumber: hopContext.hopNumber,
-                redirect: hopContext.redirect
-              } : {}
+              status: 0
             });
             const signalReason = getSignalCancelReason(cancelSignal);
             return {
@@ -3908,30 +4256,29 @@ var BaseHTTPClient = class {
               ...signalReason !== void 0 ? { cancelReason: signalReason } : {}
             };
           }
-          const streamedAbort = getResponseStreamAbortInfo(error);
-          if (isTimedOut && streamedAbort) {
-            options.onAttemptEnd?.({
-              attemptNumber,
-              isRetry,
+          if (isTimedOut && abortedResponse) {
+            const suppressedReason = streamSuppressionReason(
+              abortedResponse.status
+            );
+            emitAttemptEnd({
               willRetry: false,
+              ...suppressedReason ? { retrySuppressedReason: suppressedReason } : {},
               nextRetryDelayMS: void 0,
               nextRetryAt: void 0,
-              status: streamedAbort.status,
-              requestID,
-              initialURL,
-              ...hopContext ? {
-                hopNumber: hopContext.hopNumber,
-                redirect: hopContext.redirect
-              } : {}
+              status: abortedResponse.status
             });
             return {
               adapterResponse: {
-                status: streamedAbort.status,
-                headers: streamedAbort.headers,
+                status: abortedResponse.status,
+                ...redirectFieldsFor(
+                  abortedResponse.status,
+                  abortedResponse.headers
+                ),
+                headers: abortedResponse.headers,
                 body: null,
                 isStreamError: true,
                 streamErrorCode: "stream_response_error",
-                errorCause: error,
+                errorCause: streamCause,
                 effectiveRequestHeaders: getEffectiveRequestHeadersFromError(error)
               },
               sentRequest: sentRequestForObservedAdapterError(
@@ -3944,31 +4291,30 @@ var BaseHTTPClient = class {
               wasTimeout: true,
               isRetriesExhausted: false,
               errorCode: "stream_response_error",
-              adapterCause: error
+              adapterCause: streamCause
             };
           }
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          const fallbackSuppressedReason = streamSuppressionReason(
+            abortedResponse?.status ?? 0
+          );
+          emitAttemptEnd({
             willRetry: false,
+            ...fallbackSuppressedReason ? { retrySuppressedReason: fallbackSuppressedReason } : {},
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: streamedAbort?.status ?? 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: abortedResponse?.status ?? 0
           });
+          const fallbackStatus = abortedResponse?.status ?? 0;
+          const fallbackHeaders = abortedResponse?.headers ?? {};
           return {
             adapterResponse: {
-              status: streamedAbort?.status ?? 0,
-              headers: streamedAbort?.headers ?? {},
+              status: fallbackStatus,
+              ...redirectFieldsFor(fallbackStatus, fallbackHeaders),
+              headers: fallbackHeaders,
               body: null,
               isStreamError: true,
               streamErrorCode: "stream_response_error",
-              errorCause: error,
+              errorCause: streamCause,
               effectiveRequestHeaders: getEffectiveRequestHeadersFromError(error)
             },
             sentRequest: sentRequestForObservedAdapterError(
@@ -3981,24 +4327,16 @@ var BaseHTTPClient = class {
             wasTimeout: isTimedOut,
             isRetriesExhausted: false,
             errorCode: "stream_response_error",
-            adapterCause: error
+            adapterCause: streamCause
           };
         }
         if (isAbortError2(error)) {
           if (cancelSignal.aborted) {
-            options.onAttemptEnd?.({
-              attemptNumber,
-              isRetry,
+            emitAttemptEnd({
               willRetry: false,
               nextRetryDelayMS: void 0,
               nextRetryAt: void 0,
-              status: 0,
-              requestID,
-              initialURL,
-              ...hopContext ? {
-                hopNumber: hopContext.hopNumber,
-                redirect: hopContext.redirect
-              } : {}
+              status: 0
             });
             const signalReason = getSignalCancelReason(cancelSignal);
             return {
@@ -4015,21 +4353,16 @@ var BaseHTTPClient = class {
             if (isXHRBrowserTimeout(error)) {
               isTimedOut = true;
             } else {
-              const factoryCancelValue = error !== null && typeof error === "object" && STREAM_FACTORY_CANCEL_KEY in error ? error[STREAM_FACTORY_CANCEL_KEY] : void 0;
+              const factoryCancelValue = readObjectMember2(
+                error,
+                STREAM_FACTORY_CANCEL_KEY
+              );
               const factoryCancelReason = typeof factoryCancelValue === "string" ? factoryCancelValue : void 0;
-              options.onAttemptEnd?.({
-                attemptNumber,
-                isRetry,
+              emitAttemptEnd({
                 willRetry: false,
                 nextRetryDelayMS: void 0,
                 nextRetryAt: void 0,
-                status: 0,
-                requestID,
-                initialURL,
-                ...hopContext ? {
-                  hopNumber: hopContext.hopNumber,
-                  redirect: hopContext.redirect
-                } : {}
+                status: 0
               });
               return {
                 adapterResponse: null,
@@ -4046,19 +4379,11 @@ var BaseHTTPClient = class {
         const didTimeoutThisAttempt = isAbortError2(error) && isTimedOut;
         const isNonRetryableClientCallbackFailure = isNonRetryableClientCallbackError(error);
         if (isNonRetryableClientCallbackFailure) {
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: false,
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: 0
           });
           const isStreamFactoryError = isStreamFactoryClientCallbackError(error);
           return {
@@ -4073,12 +4398,12 @@ var BaseHTTPClient = class {
             wasTimeout: didTimeoutThisAttempt,
             isRetriesExhausted: false,
             errorCode: isStreamFactoryError ? "stream_setup_error" : "interceptor_error",
-            adapterCause: error instanceof Error ? error : new Error(String(error))
+            adapterCause: normalizeError2(error)
           };
         }
-        if (policy && !cancelSignal.aborted) {
+        if (policy && !cancelSignal.aborted && (allowNonIdempotentRetry || !NON_IDEMPOTENT_METHODS.has(sentRequest.method))) {
           const { shouldRetry, delayMS } = policy.shouldRetry(
-            error instanceof Error ? error : new Error(String(error))
+            normalizeError2(error)
           );
           const nextRetryAt = shouldRetry ? Date.now() + delayMS : void 0;
           if (shouldRetry) {
@@ -4086,19 +4411,11 @@ var BaseHTTPClient = class {
             callbacks.setNextRetryAt(nextRetryAt ?? null);
             callbacks.setState("waiting_for_retry");
           }
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          emitAttemptEnd({
             willRetry: shouldRetry,
             nextRetryDelayMS: shouldRetry ? delayMS : void 0,
             nextRetryAt,
-            status: 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: 0
           });
           if (shouldRetry) {
             const failedAttemptResponse = this._buildResponse({
@@ -4117,7 +4434,7 @@ var BaseHTTPClient = class {
               requestID,
               false,
               "adapter_error",
-              error instanceof Error ? error : new Error(String(error))
+              normalizeError2(error)
             );
             await this._runErrorObservers(
               retryError,
@@ -4145,19 +4462,13 @@ var BaseHTTPClient = class {
           }
           isRetriesExhausted = true;
         } else {
-          options.onAttemptEnd?.({
-            attemptNumber,
-            isRetry,
+          const isSuppressedByMethod = isRetryAvailable() && !cancelSignal.aborted && !allowNonIdempotentRetry && NON_IDEMPOTENT_METHODS.has(sentRequest.method);
+          emitAttemptEnd({
             willRetry: false,
+            ...isSuppressedByMethod ? { retrySuppressedReason: "non_idempotent_method" } : {},
             nextRetryDelayMS: void 0,
             nextRetryAt: void 0,
-            status: 0,
-            requestID,
-            initialURL,
-            ...hopContext ? {
-              hopNumber: hopContext.hopNumber,
-              redirect: hopContext.redirect
-            } : {}
+            status: 0
           });
         }
         return {
@@ -4168,7 +4479,7 @@ var BaseHTTPClient = class {
           wasTimeout: didTimeoutThisAttempt,
           isRetriesExhausted,
           errorCode: "adapter_error",
-          adapterCause: error instanceof Error ? error : new Error(String(error))
+          adapterCause: normalizeError2(error)
         };
       }
     }
@@ -4538,7 +4849,7 @@ var BaseHTTPClient = class {
       return AbortSignal.any([a, b]);
     }
     const controller = new AbortController();
-    const abort = (signal) => controller.abort(signal.reason);
+    const abort = (signal) => controller.abort(readObjectMember2(signal, "reason"));
     if (a.aborted) {
       abort(a);
     } else if (b.aborted) {
@@ -4622,7 +4933,24 @@ function cloneBodyValue(body) {
   return body;
 }
 function isAbortError2(err) {
-  return err instanceof Error && err.name === "AbortError";
+  return asErrorValue(err) && readObjectMember2(err, "name") === "AbortError";
+}
+function asErrorValue(value) {
+  try {
+    return value instanceof Error;
+  } catch {
+    return false;
+  }
+}
+function normalizeError2(value) {
+  if (asErrorValue(value)) {
+    return value;
+  }
+  try {
+    return new Error(String(value));
+  } catch {
+    return new Error("Unknown error");
+  }
 }
 function sentRequestForNonRetryableAdapterCallbackError(sentRequest, error, observedAfterAdapterResolve) {
   return sentRequestForObservedAdapterError(
@@ -4632,12 +4960,10 @@ function sentRequestForNonRetryableAdapterCallbackError(sentRequest, error, obse
   );
 }
 function isNonRetryableClientCallbackError(err) {
-  return Boolean(
-    err && typeof err === "object" && NON_RETRYABLE_HTTP_CLIENT_CALLBACK_ERROR_FLAG in err && err[NON_RETRYABLE_HTTP_CLIENT_CALLBACK_ERROR_FLAG] === true
-  );
+  return readObjectMember2(err, NON_RETRYABLE_HTTP_CLIENT_CALLBACK_ERROR_FLAG) === true;
 }
 function isStreamFactoryClientCallbackError(err) {
-  return err !== null && typeof err === "object" && STREAM_FACTORY_ERROR_FLAG in err;
+  return readObjectMember2(err, STREAM_FACTORY_ERROR_FLAG) === true;
 }
 function sentRequestForObservedAdapterError(sentRequest, error, observedAfterAdapterResolve) {
   const eff = getEffectiveRequestHeadersFromError(error);
@@ -4650,24 +4976,58 @@ function sentRequestForObservedAdapterError(sentRequest, error, observedAfterAda
   };
 }
 function getEffectiveRequestHeadersFromError(error) {
-  if (error && typeof error === "object" && "effectiveRequestHeaders" in error && error.effectiveRequestHeaders) {
-    return error.effectiveRequestHeaders;
+  return snapshotHeaderRecord(
+    readObjectMember2(error, "effectiveRequestHeaders")
+  );
+}
+function readObjectMember2(source, key) {
+  if (typeof source !== "object" && typeof source !== "function" || source === null) {
+    return void 0;
+  }
+  try {
+    return source[key];
+  } catch {
+    return void 0;
   }
-  return void 0;
+}
+function snapshotHeaderRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  try {
+    const snapshot = {};
+    for (const [name, headerValue] of Object.entries(value)) {
+      if (typeof headerValue === "string") {
+        snapshot[name] = headerValue;
+      } else if (Array.isArray(headerValue) && headerValue.every((item) => typeof item === "string")) {
+        snapshot[name] = [...headerValue];
+      } else {
+        return void 0;
+      }
+    }
+    return snapshot;
+  } catch {
+    return void 0;
+  }
+}
+function hasAdapterMarker(err, flag) {
+  return readObjectMember2(err, flag) === true;
 }
 function isResponseStreamAbortError(err) {
-  return err !== null && typeof err === "object" && RESPONSE_STREAM_ABORT_FLAG in err;
+  return hasAdapterMarker(err, RESPONSE_STREAM_ABORT_FLAG);
 }
 function isXHRBrowserTimeout(err) {
-  return err !== null && typeof err === "object" && XHR_BROWSER_TIMEOUT_FLAG in err;
+  return hasAdapterMarker(err, XHR_BROWSER_TIMEOUT_FLAG);
 }
 function getResponseStreamAbortInfo(err) {
-  if (!err || typeof err !== "object" || !("streamAbortStatus" in err) || !("streamAbortHeaders" in err)) {
+  const status = readObjectMember2(err, "streamAbortStatus");
+  if (typeof status !== "number") {
     return void 0;
   }
-  const status = err.streamAbortStatus;
-  const headers = err.streamAbortHeaders;
-  if (typeof status !== "number" || !headers || typeof headers !== "object") {
+  const headers = snapshotHeaderRecord(
+    readObjectMember2(err, "streamAbortHeaders")
+  );
+  if (headers === void 0) {
     return void 0;
   }
   return {
@@ -4676,7 +5036,8 @@ function getResponseStreamAbortInfo(err) {
   };
 }
 function getSignalCancelReason(signal) {
-  return typeof signal.reason === "string" ? signal.reason : void 0;
+  const reason = readObjectMember2(signal, "reason");
+  return typeof reason === "string" ? reason : void 0;
 }
 
 // src/lib/http-client/cookie-jar.ts