{"version":3,"sources":["../../../src/server/lib/patch-fetch.ts"],"sourcesContent":["import type {\n  WorkAsyncStorage,\n  WorkStore,\n} from '../app-render/work-async-storage.external'\n\nimport { AppRenderSpan, NextNodeServerSpan } from './trace/constants'\nimport { getTracer, SpanKind } from './trace/tracer'\nimport {\n  CACHE_ONE_YEAR,\n  INFINITE_CACHE,\n  NEXT_CACHE_TAG_MAX_ITEMS,\n  NEXT_CACHE_TAG_MAX_LENGTH,\n} from '../../lib/constants'\nimport { markCurrentScopeAsDynamic } from '../app-render/dynamic-rendering'\nimport { makeHangingPromise } from '../dynamic-rendering-utils'\nimport type { FetchMetric } from '../base-http'\nimport { createDedupeFetch } from './dedupe-fetch'\nimport {\n  getCacheSignal,\n  type RevalidateStore,\n  type WorkUnitAsyncStorage,\n} from '../app-render/work-unit-async-storage.external'\nimport {\n  CachedRouteKind,\n  IncrementalCacheKind,\n  type CachedFetchData,\n  type ServerComponentsHmrCache,\n  type SetIncrementalFetchCacheContext,\n} from '../response-cache'\nimport { cloneResponse } from './clone-response'\nimport type { IncrementalCache } from './incremental-cache'\nimport { RenderStage } from '../app-render/staged-rendering'\n\nconst isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge'\n\ntype Fetcher = typeof fetch\n\ntype PatchedFetcher = Fetcher & {\n  readonly __nextPatched: true\n  readonly __nextGetStaticStore: () => WorkAsyncStorage\n  readonly _nextOriginalFetch: Fetcher\n}\n\nexport const NEXT_PATCH_SYMBOL = Symbol.for('next-patch')\n\nfunction isFetchPatched() {\n  return (globalThis as Record<symbol, unknown>)[NEXT_PATCH_SYMBOL] === true\n}\n\nexport function validateRevalidate(\n  revalidateVal: unknown,\n  route: string\n): undefined | number {\n  try {\n    let normalizedRevalidate: number | undefined = undefined\n\n    if (revalidateVal === false) {\n      normalizedRevalidate = INFINITE_CACHE\n    } else if (\n      typeof revalidateVal === 'number' &&\n      !isNaN(revalidateVal) &&\n      revalidateVal > -1\n    ) {\n      normalizedRevalidate = revalidateVal\n    } else if (typeof revalidateVal !== 'undefined') {\n      throw new Error(\n        `Invalid revalidate value \"${revalidateVal}\" on \"${route}\", must be a non-negative number or false`\n      )\n    }\n    return normalizedRevalidate\n  } catch (err: any) {\n    // handle client component error from attempting to check revalidate value\n    if (err instanceof Error && err.message.includes('Invalid revalidate')) {\n      throw err\n    }\n    return undefined\n  }\n}\n\nexport function validateTags(tags: any[], description: string) {\n  const validTags: string[] = []\n  const invalidTags: Array<{\n    tag: any\n    reason: string\n  }> = []\n\n  for (let i = 0; i < tags.length; i++) {\n    const tag = tags[i]\n\n    if (typeof tag !== 'string') {\n      invalidTags.push({ tag, reason: 'invalid type, must be a string' })\n    } else if (tag.length > NEXT_CACHE_TAG_MAX_LENGTH) {\n      invalidTags.push({\n        tag,\n        reason: `exceeded max length of ${NEXT_CACHE_TAG_MAX_LENGTH}`,\n      })\n    } else {\n      validTags.push(tag)\n    }\n\n    if (validTags.length > NEXT_CACHE_TAG_MAX_ITEMS) {\n      console.warn(\n        `Warning: exceeded max tag count for ${description}, dropped tags:`,\n        tags.slice(i).join(', ')\n      )\n      break\n    }\n  }\n\n  if (invalidTags.length > 0) {\n    console.warn(`Warning: invalid tags passed to ${description}: `)\n\n    for (const { tag, reason } of invalidTags) {\n      console.log(`tag: \"${tag}\" ${reason}`)\n    }\n  }\n  return validTags\n}\n\nfunction trackFetchMetric(\n  workStore: WorkStore,\n  ctx: Omit<FetchMetric, 'end' | 'idx'>\n) {\n  if (!workStore.shouldTrackFetchMetrics) {\n    return\n  }\n\n  workStore.fetchMetrics ??= []\n\n  workStore.fetchMetrics.push({\n    ...ctx,\n    end: performance.timeOrigin + performance.now(),\n    idx: workStore.nextFetchId || 0,\n  })\n}\n\nasync function createCachedPrerenderResponse(\n  res: Response,\n  cacheKey: string,\n  incrementalCacheContext: SetIncrementalFetchCacheContext | undefined,\n  incrementalCache: IncrementalCache,\n  revalidate: number,\n  handleUnlock: () => Promise<void> | void\n): Promise<Response> {\n  // We are prerendering at build time or revalidate time with cacheComponents so we\n  // need to buffer the response so we can guarantee it can be read in a\n  // microtask.\n  const bodyBuffer = await res.arrayBuffer()\n\n  const fetchedData = {\n    headers: Object.fromEntries(res.headers.entries()),\n    body: Buffer.from(bodyBuffer).toString('base64'),\n    status: res.status,\n    url: res.url,\n  }\n\n  // We can skip setting the serverComponentsHmrCache because we aren't in dev\n  // mode.\n\n  if (incrementalCacheContext) {\n    await incrementalCache.set(\n      cacheKey,\n      { kind: CachedRouteKind.FETCH, data: fetchedData, revalidate },\n      incrementalCacheContext\n    )\n  }\n\n  await handleUnlock()\n\n  // We return a new Response to the caller.\n  return new Response(bodyBuffer, {\n    headers: res.headers,\n    status: res.status,\n    statusText: res.statusText,\n  })\n}\n\nasync function createCachedDynamicResponse(\n  workStore: WorkStore,\n  res: Response,\n  cacheKey: string,\n  incrementalCacheContext: SetIncrementalFetchCacheContext | undefined,\n  incrementalCache: IncrementalCache,\n  serverComponentsHmrCache: ServerComponentsHmrCache | undefined,\n  revalidate: number,\n  input: RequestInfo | URL,\n  handleUnlock: () => Promise<void> | void\n): Promise<Response> {\n  // We're cloning the response using this utility because there exists a bug in\n  // the undici library around response cloning. See the following pull request\n  // for more details: https://github.com/vercel/next.js/pull/73274\n  const [cloned1, cloned2] = cloneResponse(res)\n\n  // We are dynamically rendering including dev mode. We want to return the\n  // response to the caller as soon as possible because it might stream over a\n  // very long time.\n  const cacheSetPromise = cloned1\n    .arrayBuffer()\n    .then(async (arrayBuffer) => {\n      const bodyBuffer = Buffer.from(arrayBuffer)\n\n      const fetchedData = {\n        headers: Object.fromEntries(cloned1.headers.entries()),\n        body: bodyBuffer.toString('base64'),\n        status: cloned1.status,\n        url: cloned1.url,\n      }\n\n      serverComponentsHmrCache?.set(cacheKey, fetchedData)\n\n      if (incrementalCacheContext) {\n        await incrementalCache.set(\n          cacheKey,\n          { kind: CachedRouteKind.FETCH, data: fetchedData, revalidate },\n          incrementalCacheContext\n        )\n      }\n    })\n    .catch((error) => console.warn(`Failed to set fetch cache`, input, error))\n    .finally(handleUnlock)\n\n  const pendingRevalidateKey = `cache-set-${cacheKey}`\n  const pendingRevalidates = (workStore.pendingRevalidates ??= {})\n\n  let pendingRevalidatePromise = Promise.resolve()\n  if (pendingRevalidateKey in pendingRevalidates) {\n    // There is already a pending revalidate entry that we need to await to\n    // avoid race conditions.\n    pendingRevalidatePromise = pendingRevalidates[pendingRevalidateKey]\n  }\n\n  pendingRevalidates[pendingRevalidateKey] = pendingRevalidatePromise\n    .then(() => cacheSetPromise)\n    .finally(() => {\n      // If the pending revalidate is not present in the store, then we have\n      // nothing to delete.\n      if (!pendingRevalidates?.[pendingRevalidateKey]) {\n        return\n      }\n\n      delete pendingRevalidates[pendingRevalidateKey]\n    })\n\n  return cloned2\n}\n\ninterface PatchableModule {\n  workAsyncStorage: WorkAsyncStorage\n  workUnitAsyncStorage: WorkUnitAsyncStorage\n}\n\nexport function createPatchedFetcher(\n  originFetch: Fetcher,\n  { workAsyncStorage, workUnitAsyncStorage }: PatchableModule\n): PatchedFetcher {\n  // Create the patched fetch function.\n  const patched = async function fetch(\n    input: RequestInfo | URL,\n    init: RequestInit | undefined\n  ): Promise<Response> {\n    let url: URL | undefined\n    try {\n      url = new URL(input instanceof Request ? input.url : input)\n      url.username = ''\n      url.password = ''\n    } catch {\n      // Error caused by malformed URL should be handled by native fetch\n      url = undefined\n    }\n    const fetchUrl = url?.href ?? ''\n    const method = init?.method?.toUpperCase() || 'GET'\n\n    // Do create a new span trace for internal fetches in the\n    // non-verbose mode.\n    const isInternal = (init?.next as any)?.internal === true\n    const hideSpan = process.env.NEXT_OTEL_FETCH_DISABLED === '1'\n    // We don't track fetch metrics for internal fetches\n    // so it's not critical that we have a start time, as it won't be recorded.\n    // This is to workaround a flaky issue where performance APIs might\n    // not be available and will require follow-up investigation.\n    const fetchStart: number | undefined = isInternal\n      ? undefined\n      : performance.timeOrigin + performance.now()\n\n    const workStore = workAsyncStorage.getStore()\n    const workUnitStore = workUnitAsyncStorage.getStore()\n\n    let cacheSignal = workUnitStore ? getCacheSignal(workUnitStore) : null\n    if (cacheSignal) {\n      cacheSignal.beginRead()\n    }\n\n    const result = getTracer().trace(\n      isInternal ? NextNodeServerSpan.internalFetch : AppRenderSpan.fetch,\n      {\n        hideSpan,\n        kind: SpanKind.CLIENT,\n        spanName: ['fetch', method, fetchUrl].filter(Boolean).join(' '),\n        attributes: {\n          'http.url': fetchUrl,\n          'http.method': method,\n          'net.peer.name': url?.hostname,\n          'net.peer.port': url?.port || undefined,\n        },\n      },\n      async () => {\n        // If this is an internal fetch, we should not do any special treatment.\n        if (isInternal) {\n          return originFetch(input, init)\n        }\n\n        // If the workStore is not available, we can't do any\n        // special treatment of fetch, therefore fallback to the original\n        // fetch implementation.\n        if (!workStore) {\n          return originFetch(input, init)\n        }\n\n        // We should also fallback to the original fetch implementation if we\n        // are in draft mode, it does not constitute a static generation.\n        if (workStore.isDraftMode) {\n          return originFetch(input, init)\n        }\n\n        const isRequestInput =\n          input &&\n          typeof input === 'object' &&\n          typeof (input as Request).method === 'string'\n\n        const getRequestMeta = (field: string) => {\n          // If request input is present but init is not, retrieve from input first.\n          const value = (init as any)?.[field]\n          return value || (isRequestInput ? (input as any)[field] : null)\n        }\n\n        let finalRevalidate: number | undefined = undefined\n        const getNextField = (field: 'revalidate' | 'tags') => {\n          return typeof init?.next?.[field] !== 'undefined'\n            ? init?.next?.[field]\n            : isRequestInput\n              ? (input as any).next?.[field]\n              : undefined\n        }\n        // RequestInit doesn't keep extra fields e.g. next so it's\n        // only available if init is used separate\n        const originalFetchRevalidate = getNextField('revalidate')\n        let currentFetchRevalidate = originalFetchRevalidate\n        const tags: string[] = validateTags(\n          getNextField('tags') || [],\n          `fetch ${input.toString()}`\n        )\n\n        let revalidateStore: RevalidateStore | undefined\n\n        if (workUnitStore) {\n          switch (workUnitStore.type) {\n            case 'prerender':\n            case 'prerender-runtime':\n            // TODO: Stop accumulating tags in client prerender. (fallthrough)\n            case 'prerender-client':\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'cache':\n            case 'private-cache':\n              revalidateStore = workUnitStore\n              break\n            case 'request':\n            case 'unstable-cache':\n              break\n            default:\n              workUnitStore satisfies never\n          }\n        }\n\n        if (revalidateStore) {\n          if (Array.isArray(tags)) {\n            // Collect tags onto parent caches or parent prerenders.\n            const collectedTags =\n              revalidateStore.tags ?? (revalidateStore.tags = [])\n            for (const tag of tags) {\n              if (!collectedTags.includes(tag)) {\n                collectedTags.push(tag)\n              }\n            }\n          }\n        }\n\n        const implicitTags = workUnitStore?.implicitTags\n\n        let pageFetchCacheMode = workStore.fetchCache\n\n        if (workUnitStore) {\n          switch (workUnitStore.type) {\n            case 'unstable-cache':\n              // Inside unstable-cache we treat it the same as force-no-store on\n              // the page.\n              pageFetchCacheMode = 'force-no-store'\n              break\n            case 'prerender':\n            case 'prerender-client':\n            case 'prerender-runtime':\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'request':\n            case 'cache':\n            case 'private-cache':\n              break\n            default:\n              workUnitStore satisfies never\n          }\n        }\n\n        const isUsingNoStore = !!workStore.isUnstableNoStore\n\n        let currentFetchCacheConfig = getRequestMeta('cache')\n        let cacheReason = ''\n        let cacheWarning: string | undefined\n\n        if (\n          typeof currentFetchCacheConfig === 'string' &&\n          typeof currentFetchRevalidate !== 'undefined'\n        ) {\n          // If the revalidate value conflicts with the cache value, we should warn the user and unset the conflicting values.\n          const isConflictingRevalidate =\n            // revalidate: 0 and cache: force-cache\n            (currentFetchCacheConfig === 'force-cache' &&\n              currentFetchRevalidate === 0) ||\n            // revalidate: >0 or revalidate: false and cache: no-store\n            (currentFetchCacheConfig === 'no-store' &&\n              (currentFetchRevalidate > 0 || currentFetchRevalidate === false))\n\n          if (isConflictingRevalidate) {\n            cacheWarning = `Specified \"cache: ${currentFetchCacheConfig}\" and \"revalidate: ${currentFetchRevalidate}\", only one should be specified.`\n            currentFetchCacheConfig = undefined\n            currentFetchRevalidate = undefined\n          }\n        }\n\n        const hasExplicitFetchCacheOptOut =\n          // fetch config itself signals not to cache\n          currentFetchCacheConfig === 'no-cache' ||\n          currentFetchCacheConfig === 'no-store' ||\n          // the fetch isn't explicitly caching and the segment level cache config signals not to cache\n          // note: `pageFetchCacheMode` is also set by being in an unstable_cache context.\n          pageFetchCacheMode === 'force-no-store' ||\n          pageFetchCacheMode === 'only-no-store'\n\n        // If no explicit fetch cache mode is set, but dynamic = `force-dynamic` is set,\n        // we shouldn't consider caching the fetch. This is because the `dynamic` cache\n        // is considered a \"top-level\" cache mode, whereas something like `fetchCache` is more\n        // fine-grained. Top-level modes are responsible for setting reasonable defaults for the\n        // other configurations.\n        const noFetchConfigAndForceDynamic =\n          !pageFetchCacheMode &&\n          !currentFetchCacheConfig &&\n          !currentFetchRevalidate &&\n          workStore.forceDynamic\n\n        if (\n          // force-cache was specified without a revalidate value. We set the revalidate value to false\n          // which will signal the cache to not revalidate\n          currentFetchCacheConfig === 'force-cache' &&\n          typeof currentFetchRevalidate === 'undefined'\n        ) {\n          currentFetchRevalidate = false\n        } else if (\n          hasExplicitFetchCacheOptOut ||\n          noFetchConfigAndForceDynamic\n        ) {\n          currentFetchRevalidate = 0\n        }\n\n        if (\n          currentFetchCacheConfig === 'no-cache' ||\n          currentFetchCacheConfig === 'no-store'\n        ) {\n          cacheReason = `cache: ${currentFetchCacheConfig}`\n        }\n\n        finalRevalidate = validateRevalidate(\n          currentFetchRevalidate,\n          workStore.route\n        )\n\n        const _headers = getRequestMeta('headers')\n        const initHeaders: Headers =\n          typeof _headers?.get === 'function'\n            ? _headers\n            : new Headers(_headers || {})\n\n        const hasUnCacheableHeader =\n          initHeaders.get('authorization') || initHeaders.get('cookie')\n\n        const isUnCacheableMethod = !['get', 'head'].includes(\n          getRequestMeta('method')?.toLowerCase() || 'get'\n        )\n\n        /**\n         * We automatically disable fetch caching under the following conditions:\n         * - Fetch cache configs are not set. Specifically:\n         *    - A page fetch cache mode is not set (export const fetchCache=...)\n         *    - A fetch cache mode is not set in the fetch call (fetch(url, { cache: ... }))\n         *      or the fetch cache mode is set to 'default'\n         *    - A fetch revalidate value is not set in the fetch call (fetch(url, { revalidate: ... }))\n         * - OR the fetch comes after a configuration that triggered dynamic rendering (e.g., reading cookies())\n         *   and the fetch was considered uncacheable (e.g., POST method or has authorization headers)\n         */\n        const hasNoExplicitCacheConfig =\n          // eslint-disable-next-line eqeqeq\n          pageFetchCacheMode == undefined &&\n          // eslint-disable-next-line eqeqeq\n          (currentFetchCacheConfig == undefined ||\n            // when considering whether to opt into the default \"no-cache\" fetch semantics,\n            // a \"default\" cache config should be treated the same as no cache config\n            currentFetchCacheConfig === 'default') &&\n          // eslint-disable-next-line eqeqeq\n          currentFetchRevalidate == undefined\n\n        let autoNoCache = Boolean(\n          (hasUnCacheableHeader || isUnCacheableMethod) &&\n            revalidateStore?.revalidate === 0\n        )\n\n        let isImplicitBuildTimeCache = false\n\n        if (!autoNoCache && hasNoExplicitCacheConfig) {\n          // We don't enable automatic no-cache behavior during build-time\n          // prerendering so that we can still leverage the fetch cache between\n          // export workers.\n          if (workStore.isBuildTimePrerendering) {\n            isImplicitBuildTimeCache = true\n          } else {\n            autoNoCache = true\n          }\n        }\n\n        // If we have no cache config, and we're in Dynamic I/O prerendering,\n        // it'll be a dynamic call. We don't have to issue that dynamic call.\n        if (hasNoExplicitCacheConfig && workUnitStore !== undefined) {\n          switch (workUnitStore.type) {\n            case 'prerender':\n            case 'prerender-runtime':\n            // While we don't want to do caching in the client scope we know the\n            // fetch will be dynamic for cacheComponents so we may as well avoid the\n            // call here. (fallthrough)\n            case 'prerender-client':\n              if (cacheSignal) {\n                cacheSignal.endRead()\n                cacheSignal = null\n              }\n\n              return makeHangingPromise<Response>(\n                workUnitStore.renderSignal,\n                workStore.route,\n                'fetch()'\n              )\n            case 'request':\n              if (\n                process.env.NODE_ENV === 'development' &&\n                workUnitStore.stagedRendering\n              ) {\n                if (cacheSignal) {\n                  cacheSignal.endRead()\n                  cacheSignal = null\n                }\n                await workUnitStore.stagedRendering.waitForStage(\n                  RenderStage.Dynamic\n                )\n              }\n              break\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'cache':\n            case 'private-cache':\n            case 'unstable-cache':\n              break\n            default:\n              workUnitStore satisfies never\n          }\n        }\n\n        switch (pageFetchCacheMode) {\n          case 'force-no-store': {\n            cacheReason = 'fetchCache = force-no-store'\n            break\n          }\n          case 'only-no-store': {\n            if (\n              currentFetchCacheConfig === 'force-cache' ||\n              (typeof finalRevalidate !== 'undefined' && finalRevalidate > 0)\n            ) {\n              throw new Error(\n                `cache: 'force-cache' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-no-store'`\n              )\n            }\n            cacheReason = 'fetchCache = only-no-store'\n            break\n          }\n          case 'only-cache': {\n            if (currentFetchCacheConfig === 'no-store') {\n              throw new Error(\n                `cache: 'no-store' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-cache'`\n              )\n            }\n            break\n          }\n          case 'force-cache': {\n            if (\n              typeof currentFetchRevalidate === 'undefined' ||\n              currentFetchRevalidate === 0\n            ) {\n              cacheReason = 'fetchCache = force-cache'\n              finalRevalidate = INFINITE_CACHE\n            }\n            break\n          }\n          case 'default-cache':\n          case 'default-no-store':\n          case 'auto':\n          case undefined:\n            // sometimes we won't match the above cases. the reason we don't move\n            // everything to this switch is the use of autoNoCache which is not a fetchCacheMode\n            // I suspect this could be unified with fetchCacheMode however in which case we could\n            // simplify the switch case and ensure we have an exhaustive switch handling all modes\n            break\n          default:\n            pageFetchCacheMode satisfies never\n        }\n\n        if (typeof finalRevalidate === 'undefined') {\n          if (pageFetchCacheMode === 'default-cache' && !isUsingNoStore) {\n            finalRevalidate = INFINITE_CACHE\n            cacheReason = 'fetchCache = default-cache'\n          } else if (pageFetchCacheMode === 'default-no-store') {\n            finalRevalidate = 0\n            cacheReason = 'fetchCache = default-no-store'\n          } else if (isUsingNoStore) {\n            finalRevalidate = 0\n            cacheReason = 'noStore call'\n          } else if (autoNoCache) {\n            finalRevalidate = 0\n            cacheReason = 'auto no cache'\n          } else {\n            // TODO: should we consider this case an invariant?\n            cacheReason = 'auto cache'\n            finalRevalidate = revalidateStore\n              ? revalidateStore.revalidate\n              : INFINITE_CACHE\n          }\n        } else if (!cacheReason) {\n          cacheReason = `revalidate: ${finalRevalidate}`\n        }\n\n        if (\n          // when force static is configured we don't bail from\n          // `revalidate: 0` values\n          !(workStore.forceStatic && finalRevalidate === 0) &&\n          // we don't consider autoNoCache to switch to dynamic for ISR\n          !autoNoCache &&\n          // If the revalidate value isn't currently set or the value is less\n          // than the current revalidate value, we should update the revalidate\n          // value.\n          revalidateStore &&\n          finalRevalidate < revalidateStore.revalidate\n        ) {\n          // If we were setting the revalidate value to 0, we should try to\n          // postpone instead first.\n          if (finalRevalidate === 0) {\n            if (workUnitStore) {\n              switch (workUnitStore.type) {\n                case 'prerender':\n                case 'prerender-client':\n                case 'prerender-runtime':\n                  if (cacheSignal) {\n                    cacheSignal.endRead()\n                    cacheSignal = null\n                  }\n                  return makeHangingPromise<Response>(\n                    workUnitStore.renderSignal,\n                    workStore.route,\n                    'fetch()'\n                  )\n                case 'request':\n                  if (\n                    process.env.NODE_ENV === 'development' &&\n                    workUnitStore.stagedRendering\n                  ) {\n                    if (cacheSignal) {\n                      cacheSignal.endRead()\n                      cacheSignal = null\n                    }\n                    await workUnitStore.stagedRendering.waitForStage(\n                      RenderStage.Dynamic\n                    )\n                  }\n                  break\n                case 'prerender-ppr':\n                case 'prerender-legacy':\n                case 'cache':\n                case 'private-cache':\n                case 'unstable-cache':\n                  break\n                default:\n                  workUnitStore satisfies never\n              }\n            }\n\n            markCurrentScopeAsDynamic(\n              workStore,\n              workUnitStore,\n              `revalidate: 0 fetch ${input} ${workStore.route}`\n            )\n          }\n\n          // We only want to set the revalidate store's revalidate time if it\n          // was explicitly set for the fetch call, i.e.\n          // originalFetchRevalidate.\n          if (revalidateStore && originalFetchRevalidate === finalRevalidate) {\n            revalidateStore.revalidate = finalRevalidate\n          }\n        }\n\n        const isCacheableRevalidate =\n          typeof finalRevalidate === 'number' && finalRevalidate > 0\n\n        let cacheKey: string | undefined\n        const { incrementalCache } = workStore\n        let isHmrRefresh = false\n        let serverComponentsHmrCache: ServerComponentsHmrCache | undefined\n\n        if (workUnitStore) {\n          switch (workUnitStore.type) {\n            case 'request':\n            case 'cache':\n            case 'private-cache':\n              isHmrRefresh = workUnitStore.isHmrRefresh ?? false\n              serverComponentsHmrCache = workUnitStore.serverComponentsHmrCache\n              break\n            case 'prerender':\n            case 'prerender-client':\n            case 'prerender-runtime':\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'unstable-cache':\n              break\n            default:\n              workUnitStore satisfies never\n          }\n        }\n\n        if (\n          incrementalCache &&\n          (isCacheableRevalidate || serverComponentsHmrCache)\n        ) {\n          try {\n            cacheKey = await incrementalCache.generateCacheKey(\n              fetchUrl,\n              isRequestInput ? (input as RequestInit) : init\n            )\n          } catch (err) {\n            console.error(`Failed to generate cache key for`, input)\n          }\n        }\n\n        const fetchIdx = workStore.nextFetchId ?? 1\n        workStore.nextFetchId = fetchIdx + 1\n\n        let handleUnlock: () => Promise<void> | void = () => {}\n\n        const doOriginalFetch = async (\n          isStale?: boolean,\n          cacheReasonOverride?: string\n        ) => {\n          const requestInputFields = [\n            'cache',\n            'credentials',\n            'headers',\n            'integrity',\n            'keepalive',\n            'method',\n            'mode',\n            'redirect',\n            'referrer',\n            'referrerPolicy',\n            'window',\n            'duplex',\n\n            // don't pass through signal when revalidating\n            ...(isStale ? [] : ['signal']),\n          ]\n\n          if (isRequestInput) {\n            const reqInput: Request = input as any\n            const reqOptions: RequestInit = {\n              body: (reqInput as any)._ogBody || reqInput.body,\n            }\n\n            for (const field of requestInputFields) {\n              // @ts-expect-error custom fields\n              reqOptions[field] = reqInput[field]\n            }\n            input = new Request(reqInput.url, reqOptions)\n          } else if (init) {\n            const { _ogBody, body, signal, ...otherInput } =\n              init as RequestInit & { _ogBody?: any }\n            init = {\n              ...otherInput,\n              body: _ogBody || body,\n              signal: isStale ? undefined : signal,\n            }\n          }\n\n          // add metadata to init without editing the original\n          const clonedInit = {\n            ...init,\n            next: { ...init?.next, fetchType: 'origin', fetchIdx },\n          }\n\n          return originFetch(input, clonedInit)\n            .then(async (res) => {\n              if (!isStale && fetchStart) {\n                trackFetchMetric(workStore, {\n                  start: fetchStart,\n                  url: fetchUrl,\n                  cacheReason: cacheReasonOverride || cacheReason,\n                  cacheStatus:\n                    finalRevalidate === 0 || cacheReasonOverride\n                      ? 'skip'\n                      : 'miss',\n                  cacheWarning,\n                  status: res.status,\n                  method: clonedInit.method || 'GET',\n                })\n              }\n              if (\n                res.status === 200 &&\n                incrementalCache &&\n                cacheKey &&\n                (isCacheableRevalidate || serverComponentsHmrCache)\n              ) {\n                const normalizedRevalidate =\n                  finalRevalidate >= INFINITE_CACHE\n                    ? CACHE_ONE_YEAR\n                    : finalRevalidate\n\n                const incrementalCacheConfig:\n                  | SetIncrementalFetchCacheContext\n                  | undefined = isCacheableRevalidate\n                  ? {\n                      fetchCache: true,\n                      fetchUrl,\n                      fetchIdx,\n                      tags,\n                      isImplicitBuildTimeCache,\n                    }\n                  : undefined\n\n                switch (workUnitStore?.type) {\n                  case 'prerender':\n                  case 'prerender-client':\n                  case 'prerender-runtime':\n                    return createCachedPrerenderResponse(\n                      res,\n                      cacheKey,\n                      incrementalCacheConfig,\n                      incrementalCache,\n                      normalizedRevalidate,\n                      handleUnlock\n                    )\n                  case 'request':\n                    if (\n                      process.env.NODE_ENV === 'development' &&\n                      workUnitStore.stagedRendering &&\n                      workUnitStore.cacheSignal\n                    ) {\n                      // We're filling caches for a staged render,\n                      // so we need to wait for the response to finish instead of streaming.\n                      return createCachedPrerenderResponse(\n                        res,\n                        cacheKey,\n                        incrementalCacheConfig,\n                        incrementalCache,\n                        normalizedRevalidate,\n                        handleUnlock\n                      )\n                    }\n                  // fallthrough\n                  case 'prerender-ppr':\n                  case 'prerender-legacy':\n                  case 'cache':\n                  case 'private-cache':\n                  case 'unstable-cache':\n                  case undefined:\n                    return createCachedDynamicResponse(\n                      workStore,\n                      res,\n                      cacheKey,\n                      incrementalCacheConfig,\n                      incrementalCache,\n                      serverComponentsHmrCache,\n                      normalizedRevalidate,\n                      input,\n                      handleUnlock\n                    )\n                  default:\n                    workUnitStore satisfies never\n                }\n              }\n\n              // we had response that we determined shouldn't be cached so we return it\n              // and don't cache it. This also needs to unlock the cache lock we acquired.\n              await handleUnlock()\n\n              return res\n            })\n            .catch((error) => {\n              handleUnlock()\n              throw error\n            })\n        }\n\n        let cacheReasonOverride\n        let isForegroundRevalidate = false\n        let isHmrRefreshCache = false\n\n        if (cacheKey && incrementalCache) {\n          let cachedFetchData: CachedFetchData | undefined\n\n          if (isHmrRefresh && serverComponentsHmrCache) {\n            cachedFetchData = serverComponentsHmrCache.get(cacheKey)\n            isHmrRefreshCache = true\n          }\n\n          if (isCacheableRevalidate && !cachedFetchData) {\n            handleUnlock = await incrementalCache.lock(cacheKey)\n            const entry = workStore.isOnDemandRevalidate\n              ? null\n              : await incrementalCache.get(cacheKey, {\n                  kind: IncrementalCacheKind.FETCH,\n                  revalidate: finalRevalidate,\n                  fetchUrl,\n                  fetchIdx,\n                  tags,\n                  softTags: implicitTags?.tags,\n                })\n\n            if (hasNoExplicitCacheConfig && workUnitStore) {\n              switch (workUnitStore.type) {\n                case 'prerender':\n                case 'prerender-client':\n                case 'prerender-runtime':\n                  // We sometimes use the cache to dedupe fetches that do not\n                  // specify a cache configuration. In these cases we want to\n                  // make sure we still exclude them from prerenders if\n                  // cacheComponents is on so we introduce an artificial task boundary\n                  // here.\n                  await getTimeoutBoundary()\n                  break\n                case 'request':\n                  if (\n                    process.env.NODE_ENV === 'development' &&\n                    workUnitStore.stagedRendering\n                  ) {\n                    await workUnitStore.stagedRendering.waitForStage(\n                      RenderStage.Dynamic\n                    )\n                  }\n                  break\n                case 'prerender-ppr':\n                case 'prerender-legacy':\n                case 'cache':\n                case 'private-cache':\n                case 'unstable-cache':\n                  break\n                default:\n                  workUnitStore satisfies never\n              }\n            }\n\n            if (entry) {\n              await handleUnlock()\n            } else {\n              // in dev, incremental cache response will be null in case the browser adds `cache-control: no-cache` in the request headers\n              // TODO: it seems like we also hit this after revalidates in dev?\n              cacheReasonOverride = 'cache-control: no-cache (hard refresh)'\n            }\n\n            if (entry?.value && entry.value.kind === CachedRouteKind.FETCH) {\n              // when stale and is revalidating we wait for fresh data\n              // so the revalidated entry has the updated data\n              if (workStore.isStaticGeneration && entry.isStale) {\n                isForegroundRevalidate = true\n              } else {\n                if (entry.isStale) {\n                  workStore.pendingRevalidates ??= {}\n                  if (!workStore.pendingRevalidates[cacheKey]) {\n                    const pendingRevalidate = doOriginalFetch(true)\n                      .then(async (response) => ({\n                        body: await response.arrayBuffer(),\n                        headers: response.headers,\n                        status: response.status,\n                        statusText: response.statusText,\n                      }))\n                      .finally(() => {\n                        workStore.pendingRevalidates ??= {}\n                        delete workStore.pendingRevalidates[cacheKey || '']\n                      })\n\n                    // Attach the empty catch here so we don't get a \"unhandled\n                    // promise rejection\" warning.\n                    pendingRevalidate.catch(console.error)\n\n                    workStore.pendingRevalidates[cacheKey] = pendingRevalidate\n                  }\n                }\n\n                cachedFetchData = entry.value.data\n              }\n            }\n          }\n\n          if (cachedFetchData) {\n            if (fetchStart) {\n              trackFetchMetric(workStore, {\n                start: fetchStart,\n                url: fetchUrl,\n                cacheReason,\n                cacheStatus: isHmrRefreshCache ? 'hmr' : 'hit',\n                cacheWarning,\n                status: cachedFetchData.status || 200,\n                method: init?.method || 'GET',\n              })\n            }\n\n            const response = new Response(\n              Buffer.from(cachedFetchData.body, 'base64'),\n              {\n                headers: cachedFetchData.headers,\n                status: cachedFetchData.status,\n              }\n            )\n\n            Object.defineProperty(response, 'url', {\n              value: cachedFetchData.url,\n            })\n\n            return response\n          }\n        }\n\n        if (\n          (workStore.isStaticGeneration ||\n            (process.env.NODE_ENV === 'development' &&\n              process.env.__NEXT_CACHE_COMPONENTS &&\n              workUnitStore &&\n              // eslint-disable-next-line no-restricted-syntax\n              workUnitStore.type === 'request' &&\n              workUnitStore.stagedRendering)) &&\n          init &&\n          typeof init === 'object'\n        ) {\n          const { cache } = init\n\n          // Delete `cache` property as Cloudflare Workers will throw an error\n          if (isEdgeRuntime) delete init.cache\n\n          if (cache === 'no-store') {\n            // If enabled, we should bail out of static generation.\n            if (workUnitStore) {\n              switch (workUnitStore.type) {\n                case 'prerender':\n                case 'prerender-client':\n                case 'prerender-runtime':\n                  if (cacheSignal) {\n                    cacheSignal.endRead()\n                    cacheSignal = null\n                  }\n                  return makeHangingPromise<Response>(\n                    workUnitStore.renderSignal,\n                    workStore.route,\n                    'fetch()'\n                  )\n                case 'request':\n                  if (\n                    process.env.NODE_ENV === 'development' &&\n                    workUnitStore.stagedRendering\n                  ) {\n                    if (cacheSignal) {\n                      cacheSignal.endRead()\n                      cacheSignal = null\n                    }\n                    await workUnitStore.stagedRendering.waitForStage(\n                      RenderStage.Dynamic\n                    )\n                  }\n                  break\n                case 'prerender-ppr':\n                case 'prerender-legacy':\n                case 'cache':\n                case 'private-cache':\n                case 'unstable-cache':\n                  break\n                default:\n                  workUnitStore satisfies never\n              }\n            }\n            markCurrentScopeAsDynamic(\n              workStore,\n              workUnitStore,\n              `no-store fetch ${input} ${workStore.route}`\n            )\n          }\n\n          const hasNextConfig = 'next' in init\n          const { next = {} } = init\n          if (\n            typeof next.revalidate === 'number' &&\n            revalidateStore &&\n            next.revalidate < revalidateStore.revalidate\n          ) {\n            if (next.revalidate === 0) {\n              // If enabled, we should bail out of static generation.\n              if (workUnitStore) {\n                switch (workUnitStore.type) {\n                  case 'prerender':\n                  case 'prerender-client':\n                  case 'prerender-runtime':\n                    return makeHangingPromise<Response>(\n                      workUnitStore.renderSignal,\n                      workStore.route,\n                      'fetch()'\n                    )\n                  case 'request':\n                    if (\n                      process.env.NODE_ENV === 'development' &&\n                      workUnitStore.stagedRendering\n                    ) {\n                      await workUnitStore.stagedRendering.waitForStage(\n                        RenderStage.Dynamic\n                      )\n                    }\n                    break\n                  case 'cache':\n                  case 'private-cache':\n                  case 'unstable-cache':\n                  case 'prerender-legacy':\n                  case 'prerender-ppr':\n                    break\n                  default:\n                    workUnitStore satisfies never\n                }\n              }\n              markCurrentScopeAsDynamic(\n                workStore,\n                workUnitStore,\n                `revalidate: 0 fetch ${input} ${workStore.route}`\n              )\n            }\n\n            if (!workStore.forceStatic || next.revalidate !== 0) {\n              revalidateStore.revalidate = next.revalidate\n            }\n          }\n          if (hasNextConfig) delete init.next\n        }\n\n        // if we are revalidating the whole page via time or on-demand and\n        // the fetch cache entry is stale we should still de-dupe the\n        // origin hit if it's a cache-able entry\n        if (cacheKey && isForegroundRevalidate) {\n          const pendingRevalidateKey = cacheKey\n          workStore.pendingRevalidates ??= {}\n          let pendingRevalidate =\n            workStore.pendingRevalidates[pendingRevalidateKey]\n\n          if (pendingRevalidate) {\n            const revalidatedResult: {\n              body: ArrayBuffer\n              headers: Headers\n              status: number\n              statusText: string\n            } = await pendingRevalidate\n            return new Response(revalidatedResult.body, {\n              headers: revalidatedResult.headers,\n              status: revalidatedResult.status,\n              statusText: revalidatedResult.statusText,\n            })\n          }\n\n          // We used to just resolve the Response and clone it however for\n          // static generation with cacheComponents we need the response to be able to\n          // be resolved in a microtask and cloning the response will never have\n          // a body that can resolve in a microtask in node (as observed through\n          // experimentation) So instead we await the body and then when it is\n          // available we construct manually cloned Response objects with the\n          // body as an ArrayBuffer. This will be resolvable in a microtask\n          // making it compatible with cacheComponents.\n          const pendingResponse = doOriginalFetch(true, cacheReasonOverride)\n            // We're cloning the response using this utility because there\n            // exists a bug in the undici library around response cloning.\n            // See the following pull request for more details:\n            // https://github.com/vercel/next.js/pull/73274\n            .then(cloneResponse)\n\n          pendingRevalidate = pendingResponse\n            .then(async (responses) => {\n              const response = responses[0]\n              return {\n                body: await response.arrayBuffer(),\n                headers: response.headers,\n                status: response.status,\n                statusText: response.statusText,\n              }\n            })\n            .finally(() => {\n              // If the pending revalidate is not present in the store, then\n              // we have nothing to delete.\n              if (!workStore.pendingRevalidates?.[pendingRevalidateKey]) {\n                return\n              }\n\n              delete workStore.pendingRevalidates[pendingRevalidateKey]\n            })\n\n          // Attach the empty catch here so we don't get a \"unhandled promise\n          // rejection\" warning\n          pendingRevalidate.catch(() => {})\n\n          workStore.pendingRevalidates[pendingRevalidateKey] = pendingRevalidate\n\n          return pendingResponse.then((responses) => responses[1])\n        } else {\n          return doOriginalFetch(false, cacheReasonOverride)\n        }\n      }\n    )\n\n    if (cacheSignal) {\n      try {\n        return await result\n      } finally {\n        if (cacheSignal) {\n          cacheSignal.endRead()\n        }\n      }\n    }\n    return result\n  }\n\n  // Attach the necessary properties to the patched fetch function.\n  // We don't use this to determine if the fetch function has been patched,\n  // but for external consumers to determine if the fetch function has been\n  // patched.\n  patched.__nextPatched = true as const\n  patched.__nextGetStaticStore = () => workAsyncStorage\n  patched._nextOriginalFetch = originFetch\n  ;(globalThis as Record<symbol, unknown>)[NEXT_PATCH_SYMBOL] = true\n\n  // Assign the function name also as a name property, so that it's preserved\n  // even when mangling is enabled.\n  Object.defineProperty(patched, 'name', { value: 'fetch', writable: false })\n\n  return patched\n}\n\n// we patch fetch to collect cache information used for\n// determining if a page is static or not\nexport function patchFetch(options: PatchableModule) {\n  // If we've already patched fetch, we should not patch it again.\n  if (isFetchPatched()) return\n\n  // Grab the original fetch function. We'll attach this so we can use it in\n  // the patched fetch function.\n  const original = createDedupeFetch(globalThis.fetch)\n\n  // Set the global fetch to the patched fetch.\n  globalThis.fetch = createPatchedFetcher(original, options)\n}\n\nlet currentTimeoutBoundary: null | Promise<void> = null\nfunction getTimeoutBoundary() {\n  if (!currentTimeoutBoundary) {\n    currentTimeoutBoundary = new Promise((r) => {\n      setTimeout(() => {\n        currentTimeoutBoundary = null\n        r()\n      }, 0)\n    })\n  }\n  return currentTimeoutBoundary\n}\n"],"names":["NEXT_PATCH_SYMBOL","createPatchedFetcher","patchFetch","validateRevalidate","validateTags","isEdgeRuntime","process","env","NEXT_RUNTIME","Symbol","for","isFetchPatched","globalThis","revalidateVal","route","normalizedRevalidate","undefined","INFINITE_CACHE","isNaN","Error","err","message","includes","tags","description","validTags","invalidTags","i","length","tag","push","reason","NEXT_CACHE_TAG_MAX_LENGTH","NEXT_CACHE_TAG_MAX_ITEMS","console","warn","slice","join","log","trackFetchMetric","workStore","ctx","shouldTrackFetchMetrics","fetchMetrics","end","performance","timeOrigin","now","idx","nextFetchId","createCachedPrerenderResponse","res","cacheKey","incrementalCacheContext","incrementalCache","revalidate","handleUnlock","bodyBuffer","arrayBuffer","fetchedData","headers","Object","fromEntries","entries","body","Buffer","from","toString","status","url","set","kind","CachedRouteKind","FETCH","data","Response","statusText","createCachedDynamicResponse","serverComponentsHmrCache","input","cloned1","cloned2","cloneResponse","cacheSetPromise","then","catch","error","finally","pendingRevalidateKey","pendingRevalidates","pendingRevalidatePromise","Promise","resolve","originFetch","workAsyncStorage","workUnitAsyncStorage","patched","fetch","init","URL","Request","username","password","fetchUrl","href","method","toUpperCase","isInternal","next","internal","hideSpan","NEXT_OTEL_FETCH_DISABLED","fetchStart","getStore","workUnitStore","cacheSignal","getCacheSignal","beginRead","result","getTracer","trace","NextNodeServerSpan","internalFetch","AppRenderSpan","SpanKind","CLIENT","spanName","filter","Boolean","attributes","hostname","port","getRequestMeta","isDraftMode","isRequestInput","field","value","finalRevalidate","getNextField","originalFetchRevalidate","currentFetchRevalidate","revalidateStore","type","Array","isArray","collectedTags","implicitTags","pageFetchCacheMode","fetchCache","isUsingNoStore","isUnstableNoStore","currentFetchCacheConfig","cacheReason","cacheWarning","isConflictingRevalidate","hasExplicitFetchCacheOptOut","noFetchConfigAndForceDynamic","forceDynamic","_headers","initHeaders","get","Headers","hasUnCacheableHeader","isUnCacheableMethod","toLowerCase","hasNoExplicitCacheConfig","autoNoCache","isImplicitBuildTimeCache","isBuildTimePrerendering","endRead","makeHangingPromise","renderSignal","NODE_ENV","stagedRendering","waitForStage","RenderStage","Dynamic","forceStatic","markCurrentScopeAsDynamic","isCacheableRevalidate","isHmrRefresh","generateCacheKey","fetchIdx","doOriginalFetch","isStale","cacheReasonOverride","requestInputFields","reqInput","reqOptions","_ogBody","signal","otherInput","clonedInit","fetchType","start","cacheStatus","CACHE_ONE_YEAR","incrementalCacheConfig","isForegroundRevalidate","isHmrRefreshCache","cachedFetchData","lock","entry","isOnDemandRevalidate","IncrementalCacheKind","softTags","getTimeoutBoundary","isStaticGeneration","pendingRevalidate","response","defineProperty","__NEXT_CACHE_COMPONENTS","cache","hasNextConfig","revalidatedResult","pendingResponse","responses","__nextPatched","__nextGetStaticStore","_nextOriginalFetch","writable","options","original","createDedupeFetch","currentTimeoutBoundary","r","setTimeout"],"mappings":"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","ignoreList":[0]}