@code-yeongyu/senpi 2026.9.12-3 → 2026.9.12

package/node_modules/undici/lib/handler/deduplication-handler.js

@@ -365,22 +365,12 @@ class DeduplicationHandler {
       get aborted () { return state.aborted },
       get reason () { return state.reason },
       abort: (reason) => {
-        if (state.aborted) {
-          return
-        }
-
         state.aborted = true
         state.reason = reason ?? null
         waitingHandler.done = true
         waitingHandler.pendingTrailers = null
         waitingHandler.bufferedChunks = []
         waitingHandler.bufferedBytes = 0
-
-        try {
-          handler.onResponseError?.(waitingHandler.controller, state.reason ?? new RequestAbortedError())
-        } catch {
-          // Ignore errors from waiting handlers
-        }
       }
     }
 
@@ -454,8 +444,12 @@ class DeduplicationHandler {
     waitingHandler.bufferedChunks = []
     waitingHandler.bufferedBytes = 0
 
-    // controller.abort(err) notifies the handler via onResponseError
-    waitingHandler.controller.abort(err)
+    try {
+      waitingHandler.controller.abort(err)
+      waitingHandler.handler.onResponseError?.(waitingHandler.controller, err)
+    } catch {
+      // Ignore errors from waiting handlers
+    }
   }
 
   #pruneDoneWaitingHandlers () {

package/node_modules/undici/lib/handler/redirect-handler.js

@@ -3,7 +3,6 @@
 const util = require('../core/util')
 const assert = require('node:assert')
 const { InvalidArgumentError } = require('../core/errors')
-const { kRequestOrigin } = require('../core/symbols')
 
 const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
 
@@ -44,14 +43,6 @@ class RedirectHandler {
     this.handler.onRequestStart?.(controller, { ...context, history: this.history })
   }
 
-  onBodySent (chunk) {
-    this.handler.onBodySent?.(chunk)
-  }
-
-  onRequestSent () {
-    this.handler.onRequestSent?.()
-  }
-
   onRequestUpgrade (controller, statusCode, headers, socket) {
     this.handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
   }
@@ -90,12 +81,8 @@ class RedirectHandler {
       ? null
       : headers.location
 
-    const requestOrigin = this.opts[kRequestOrigin] === undefined
-      ? this.opts.origin
-      : this.opts[kRequestOrigin]
-
-    if (requestOrigin) {
-      this.history.push(new URL(this.opts.path, requestOrigin))
+    if (this.opts.origin) {
+      this.history.push(new URL(this.opts.path, this.opts.origin))
     }
 
     if (!this.location) {
@@ -103,10 +90,7 @@ class RedirectHandler {
       return
     }
 
-    const baseUrl = requestOrigin
-      ? new URL(this.opts.path, requestOrigin)
-      : undefined
-    const { origin, pathname, search } = util.parseURL(new URL(this.location, baseUrl))
+    const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
     const path = search ? `${pathname}${search}` : pathname
 
     // Check for redirect loops by seeing if we've already visited this URL in our history
@@ -122,10 +106,9 @@ class RedirectHandler {
     // Remove headers referring to the original URL.
     // By default it is Host only. A 303 or a 301/302 POST-to-GET redirect also removes all Content-* headers.
     // https://tools.ietf.org/html/rfc7231#section-6.4
-    this.opts.headers = cleanRequestHeaders(this.opts.headers, removeContentHeaders, requestOrigin !== origin, this.stripHeadersOnRedirect, this.stripHeadersOnCrossOriginRedirect)
+    this.opts.headers = cleanRequestHeaders(this.opts.headers, removeContentHeaders, this.opts.origin !== origin, this.stripHeadersOnRedirect, this.stripHeadersOnCrossOriginRedirect)
     this.opts.path = path
     this.opts.origin = origin
-    this.opts[kRequestOrigin] = origin
     this.opts.query = null
   }
 

package/node_modules/undici/lib/handler/retry-handler.js

@@ -2,7 +2,7 @@
 const assert = require('node:assert')
 
 const { kRetryHandlerDefaultRetry } = require('../core/symbols')
-const { RequestRetryError, RequestAbortedError } = require('../core/errors')
+const { RequestRetryError } = require('../core/errors')
 const {
   isDisturbed,
   parseRangeHeader,
@@ -41,42 +41,19 @@ function validatePartialResponseContentLength (headers, range, statusCode, retry
 // new one: backpressure pauses the new connection's controller, but the
 // consumer's resume() targets the old one, so the resumed body stalls forever.
 // The proxy always forwards to the controller of the currently active connection.
-// An abort is additionally reported to the handler so it can cancel a pending
-// retry backoff instead of letting the request hang until the backoff elapses.
-// The notification is a private callback the handler hands over on construction,
-// so nothing outside the handler can trigger it.
 class RetryController {
-  #onAbort
-
-  constructor (onAbort) {
-    this.#onAbort = onAbort
+  constructor () {
     this.target = null
   }
 
   pause () { this.target?.pause() }
   resume () { this.target?.resume() }
-
-  abort (reason) {
-    this.target?.abort(reason)
-    this.#onAbort(reason)
-  }
-
+  abort (reason) { this.target?.abort(reason) }
   get paused () { return this.target?.paused ?? false }
   get aborted () { return this.target?.aborted ?? false }
   get reason () { return this.target?.reason ?? null }
   get rawHeaders () { return this.target?.rawHeaders ?? null }
-  set rawHeaders (value) {
-    if (this.target) {
-      this.target.rawHeaders = value
-    }
-  }
-
   get rawTrailers () { return this.target?.rawTrailers ?? null }
-  set rawTrailers (value) {
-    if (this.target) {
-      this.target.rawTrailers = value
-    }
-  }
 }
 
 class RetryHandler {
@@ -135,32 +112,15 @@ class RetryHandler {
     this.etag = null
     this.statusCode = null
     this.headers = null
-    this.controllerProxy = new RetryController(reason => this.#onAbort(reason))
-    // A retry decision is in flight (the policy may be holding a backoff
-    // timer). While pending, a consumer abort cancels the wait.
-    this.retryPending = false
-    // Backoff timer returned by the retry policy, so #onAbort can cancel it.
-    // Null for custom policies that do not return their timer.
-    this.retryTimer = null
-    // Set once an abort during the backoff delivered the terminal error
-    // downstream; late policy callbacks and connection errors are then moot.
-    this.aborted = false
+    this.controllerProxy = new RetryController()
   }
 
   onResponseStartWithRetry (controller, statusCode, headers, statusMessage, err) {
     if (this.retryOpts.throwOnError) {
       // Preserve old behavior for status codes that are not eligible for retry
       if (this.retryOpts.statusCodes.includes(statusCode) === false) {
-        if (this.headersSent) {
-          // The downstream handler already received the response from an
-          // earlier attempt. Forwarding this response would replace the
-          // downstream body and leave the original body pending forever.
-          this.handler.onResponseError?.(this.controllerProxy, err)
-        } else {
-          this.headersSent = true
-          this.checkpointResponseEnd(headers)
-          this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage)
-        }
+        this.headersSent = true
+        this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage)
       } else {
         this.error = err
       }
@@ -170,30 +130,14 @@ class RetryHandler {
 
     if (isDisturbed(this.opts.body)) {
       this.headersSent = true
-      this.checkpointResponseEnd(headers)
       this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage)
       return
     }
 
     function shouldRetry (passedErr) {
-      if (this.aborted) {
-        // Aborted while the policy was deciding; the decision is moot.
-        return
-      }
-      this.retryPending = false
-      this.retryTimer = null
-
       if (passedErr) {
-        if (this.headersSent) {
-          // The downstream handler already received the response from an
-          // earlier attempt. Forwarding this response would replace the
-          // downstream body and leave the original body pending forever.
-          this.handler.onResponseError?.(this.controllerProxy, passedErr)
-        } else {
-          this.headersSent = true
-          this.checkpointResponseEnd(headers)
-          this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage)
-        }
+        this.headersSent = true
+        this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage)
         controller.resume()
         return
       }
@@ -210,31 +154,14 @@ class RetryHandler {
     // between, leaving this one paused forever -- the very stall the proxy exists
     // to prevent.
     controller.pause()
-    // The default policy returns its backoff timer so an abort can cancel it;
-    // a custom policy may return anything (or nothing), which is ignored.
-    this.retryPending = true
-    this.retryTimer = this.retryOpts.retry(
+    this.retryOpts.retry(
       err,
       {
         state: { counter: this.retryCount },
         opts: { retryOptions: this.retryOpts, ...this.opts }
       },
       shouldRetry.bind(this)
-    ) ?? null
-  }
-
-  checkpointResponseEnd (headers) {
-    if (this.end == null && this.opts.method !== 'HEAD') {
-      const contentLength = headers['content-length']
-      this.end = contentLength != null ? Number(contentLength) - 1 : null
-
-      assert(
-        this.end == null || Number.isFinite(this.end),
-        'invalid content-length'
-      )
-
-      this.resume = this.end != null
-    }
+    )
   }
 
   onRequestStart (controller, context) {
@@ -249,14 +176,6 @@ class RetryHandler {
     }
   }
 
-  onBodySent (chunk) {
-    this.handler.onBodySent?.(chunk)
-  }
-
-  onRequestSent () {
-    this.handler.onRequestSent?.()
-  }
-
   onRequestUpgrade (_controller, statusCode, headers, socket) {
     this.handler.onRequestUpgrade?.(this.controllerProxy, statusCode, headers, socket)
   }
@@ -271,8 +190,7 @@ class RetryHandler {
       timeoutFactor,
       statusCodes,
       errorCodes,
-      methods,
-      retryAfter
+      methods
     } = retryOptions
     const { counter } = state
 
@@ -304,7 +222,7 @@ class RetryHandler {
       return
     }
 
-    let retryAfterHeader = retryAfter === false ? undefined : headers?.['retry-after']
+    let retryAfterHeader = headers?.['retry-after']
     if (retryAfterHeader) {
       retryAfterHeader = Number(retryAfterHeader)
       retryAfterHeader = Number.isNaN(retryAfterHeader)
@@ -319,9 +237,7 @@ class RetryHandler {
           ? Math.min(retryAfterHeader, maxTimeout)
           : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout)
 
-    // Return the backoff timer so the handler can cancel it when the
-    // consumer aborts while the retry decision is pending.
-    return setTimeout(() => cb(null), retryTimeout)
+    setTimeout(() => cb(null), retryTimeout)
   }
 
   onResponseStart (controller, statusCode, headers, statusMessage) {
@@ -335,6 +251,18 @@ class RetryHandler {
     this.statusCode = statusCode
     this.headers = headers
 
+    if (statusCode >= 300) {
+      const err = new RequestRetryError('Request failed', statusCode, {
+        headers,
+        data: {
+          count: this.retryCount
+        }
+      })
+
+      this.onResponseStartWithRetry(controller, statusCode, headers, statusMessage, err)
+      return
+    }
+
     // Checkpoint for resume from where we left it
     if (this.headersSent) {
       // Only Partial Content 206 supposed to provide Content-Range,
@@ -371,28 +299,12 @@ class RetryHandler {
 
       const { start, size, end = size ? size - 1 : null } = contentRange
 
-      if (this.start !== start || (this.end != null && this.end !== end)) {
-        throw new RequestRetryError('Content-Range mismatch', statusCode, {
-          headers,
-          data: { count: this.retryCount }
-        })
-      }
+      assert(this.start === start, 'content-range mismatch')
+      assert(this.end == null || this.end === end, 'content-range mismatch')
 
       return
     }
 
-    if (statusCode >= 300) {
-      const err = new RequestRetryError('Request failed', statusCode, {
-        headers,
-        data: {
-          count: this.retryCount
-        }
-      })
-
-      this.onResponseStartWithRetry(controller, statusCode, headers, statusMessage, err)
-      return
-    }
-
     if (this.end == null) {
       if (statusCode === 206) {
         // First time we receive 206
@@ -523,27 +435,14 @@ class RetryHandler {
   }
 
   onResponseError (controller, err) {
-    if (this.aborted) {
-      // #onAbort already delivered the terminal error downstream; the late
-      // error of the torn-down connection must not be forwarded twice.
-      return
-    }
-
     // controller is THIS failed connection (not the proxy): we inspect whether
     // the consumer aborted it to decide retry-vs-propagate.
-    if (controller?.aborted || isDisturbed(this.opts.body) || (this.headersSent && !this.resume)) {
+    if (controller?.aborted || isDisturbed(this.opts.body)) {
       this.handler.onResponseError?.(this.controllerProxy, err)
       return
     }
 
     function shouldRetry (returnedErr) {
-      if (this.aborted) {
-        // Aborted while the policy was deciding; the decision is moot.
-        return
-      }
-      this.retryPending = false
-      this.retryTimer = null
-
       if (!returnedErr) {
         this.retry()
         return
@@ -563,31 +462,14 @@ class RetryHandler {
       this.retryCount += 1
     }
 
-    this.retryPending = true
-    this.retryTimer = this.retryOpts.retry(
+    this.retryOpts.retry(
       err,
       {
         state: { counter: this.retryCount },
         opts: { retryOptions: this.retryOpts, ...this.opts }
       },
       shouldRetry.bind(this)
-    ) ?? null
-  }
-
-  #onAbort (reason) {
-    // A consumer abort lands on the controller proxy. If the retry policy is
-    // still deciding (typically holding a backoff timer), cancel the wait and
-    // surface the abort immediately instead of letting the request hang until
-    // the backoff elapses.
-    if (!this.retryPending) {
-      return
-    }
-
-    this.aborted = true
-    this.retryPending = false
-    clearTimeout(this.retryTimer)
-    this.retryTimer = null
-    this.handler.onResponseError?.(this.controllerProxy, reason ?? new RequestAbortedError())
+    )
   }
 }
 

package/node_modules/undici/lib/interceptor/cache.js

@@ -6,16 +6,7 @@ const util = require('../core/util')
 const CacheHandler = require('../handler/cache-handler')
 const MemoryCacheStore = require('../cache/memory-cache-store')
 const CacheRevalidationHandler = require('../handler/cache-revalidation-handler')
-const {
-  assertCacheStore,
-  assertCacheMethods,
-  getInterceptorOrigin,
-  makeCacheKey,
-  normalizeHeaders,
-  parseCacheControlHeader,
-  isInvalidOrWildcardVaryHeader,
-  parseVaryHeader
-} = require('../util/cache.js')
+const { assertCacheStore, assertCacheMethods, makeCacheKey, normalizeHeaders, parseCacheControlHeader, isInvalidOrWildcardVaryHeader } = require('../util/cache.js')
 const { AbortError } = require('../core/errors.js')
 const { parseHttpDate } = require('../util/date.js')
 
@@ -126,10 +117,7 @@ function staleResponseRequiresRevalidation (result, cacheType) {
  * @returns {boolean}
  */
 function revalidationResponseDisallowsCachedReuse (cacheType, headers) {
-  if (
-    (headers.vary && isInvalidOrWildcardVaryHeader(headers.vary)) ||
-    (cacheType === 'shared' && Object.hasOwn(headers, 'set-cookie'))
-  ) {
+  if (headers.vary && isInvalidOrWildcardVaryHeader(headers.vary)) {
     return true
   }
 
@@ -147,25 +135,6 @@ function revalidationResponseUpdatesCacheControl (headers) {
   return headers['cache-control'] !== undefined
 }
 
-/**
- * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
- * @param {Record<string, string | string[] | null> | undefined} varyDirectives
- * @returns {boolean}
- */
-function revalidationResponseAddsVary (result, varyDirectives) {
-  if (!varyDirectives) {
-    return false
-  }
-
-  for (const key in varyDirectives) {
-    if (result.vary == null || !Object.hasOwn(result.vary, key)) {
-      return true
-    }
-  }
-
-  return false
-}
-
 function deleteCachedValue (store, cacheKey) {
   try {
     store.delete(cacheKey)?.catch?.(nop)
@@ -420,17 +389,6 @@ function handleResult (
     return handleUncachedResponse(dispatch, globalOpts, cacheKey, handler, opts, reqCacheControl)
   }
 
-  // Shared stores may outlive the Undici version that wrote them. Do not
-  // re-serve a Set-Cookie header from an existing shared-cache entry.
-  if (globalOpts.type === 'shared' && Object.hasOwn(result.headers, 'set-cookie')) {
-    if (util.isStream(result.body)) {
-      result.body.on('error', nop).destroy()
-    }
-
-    deleteCachedValue(globalOpts.store, cacheKey)
-    return handleUncachedResponse(dispatch, globalOpts, cacheKey, handler, opts, reqCacheControl)
-  }
-
   const now = Date.now()
   if (now > result.deleteAt) {
     // Response is expired, cache store shouldn't have given this to us
@@ -513,13 +471,6 @@ function handleResult (
 
               if (revalidationResponseUpdatesCacheControl(headers)) {
                 deleteCachedValue(globalOpts.store, cacheKey)
-              } else if (revalidationResponseAddsVary(result, headers.vary ? parseVaryHeader(headers.vary, opts.headers) : undefined)) {
-                if (util.isStream(result.body)) {
-                  result.body.on('error', nop).destroy()
-                }
-
-                deleteCachedValue(globalOpts.store, cacheKey)
-                return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
               }
             }
 
@@ -587,28 +538,29 @@ module.exports = (opts = {}) => {
     }
   }
 
-  return (dispatch, interceptorOrigin) => {
+  return dispatch => {
     return (opts, handler) => {
-      const requestOrigin = getInterceptorOrigin(opts, interceptorOrigin)
-      if (!requestOrigin || arrayIncludes(safeMethodsToNotCache, opts.method)) {
-        // We cannot safely cache without an authoritative origin, or this is
-        // not a method we want to cache.
+      if (arrayIncludes(safeMethodsToNotCache, opts.method)) {
+        // Not a method we want to cache, skip
         return dispatch(opts, handler)
       }
 
       // Check if origin is in whitelist
       if (origins !== undefined) {
-        const normalizedRequestOrigin = requestOrigin.toString().toLowerCase()
+        if (!opts.origin) {
+          return dispatch(opts, handler)
+        }
+        const requestOrigin = opts.origin.toString().toLowerCase()
         let isAllowed = false
 
         for (let i = 0; i < origins.length; i++) {
           const allowed = origins[i]
           if (typeof allowed === 'string') {
-            if (allowed.toLowerCase() === normalizedRequestOrigin) {
+            if (allowed.toLowerCase() === requestOrigin) {
               isAllowed = true
               break
             }
-          } else if (allowed.test(normalizedRequestOrigin)) {
+          } else if (allowed.test(requestOrigin)) {
             isAllowed = true
             break
           }
@@ -637,12 +589,7 @@ module.exports = (opts = {}) => {
       /**
        * @type {import('../../types/cache-interceptor.d.ts').default.CacheKey}
        */
-      const cacheKey = makeCacheKey(opts, requestOrigin)
-
-      if (!arrayIncludes(util.safeHTTPMethods, opts.method)) {
-        return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
-      }
-
+      const cacheKey = makeCacheKey(opts)
       const result = store.get(cacheKey)
 
       if (result && typeof result.then === 'function') {