{"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_SECONDS,\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  signal: AbortSignal | null\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) => {\n      // Don't warn if the request was aborted intentionally.\n      if (!signal?.aborted) {\n        console.warn(`Failed to set fetch cache`, input, error)\n      }\n    })\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 'validation-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            case 'generate-static-params':\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 'validation-client':\n            case 'prerender-runtime':\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'request':\n            case 'cache':\n            case 'private-cache':\n            case 'generate-static-params':\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 'validation-client':\n              break\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            case 'generate-static-params':\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 we're in an instant validation, a dynamic fetch won't\n                // have time to resolve during the validation prerender anyway,\n                // so we leave it hanging. This can cause false negatives in shared parents,\n                // but we accept that for now, because client data fetching is non-idiomatic.\n                // eslint-disable-next-line no-fallthrough\n                case 'validation-client':\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                case 'generate-static-params':\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 'validation-client':\n            case 'prerender-runtime':\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'unstable-cache':\n            case 'generate-static-params':\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_SECONDS\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 'validation-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                      isCacheableRevalidate\n                    ) {\n                      // We're filling caches for a staged render with an\n                      // explicit cache config, so we need to wait for the\n                      // response to finish instead of streaming. For HMR-only\n                      // caching (no explicit revalidate), we fall through to\n                      // createCachedDynamicResponse which handles streaming\n                      // and abort gracefully.\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 'generate-static-params':\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                      getRequestMeta('signal')\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 'validation-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                case 'generate-static-params':\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                case 'validation-client':\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                case 'generate-static-params':\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                  case 'validation-client':\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                  case 'generate-static-params':\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":["AppRenderSpan","NextNodeServerSpan","getTracer","SpanKind","CACHE_ONE_YEAR_SECONDS","INFINITE_CACHE","NEXT_CACHE_TAG_MAX_ITEMS","NEXT_CACHE_TAG_MAX_LENGTH","markCurrentScopeAsDynamic","makeHangingPromise","createDedupeFetch","getCacheSignal","CachedRouteKind","IncrementalCacheKind","cloneResponse","RenderStage","isEdgeRuntime","process","env","NEXT_RUNTIME","NEXT_PATCH_SYMBOL","Symbol","for","isFetchPatched","globalThis","validateRevalidate","revalidateVal","route","normalizedRevalidate","undefined","isNaN","Error","err","message","includes","validateTags","tags","description","validTags","invalidTags","i","length","tag","push","reason","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","FETCH","data","Response","statusText","createCachedDynamicResponse","serverComponentsHmrCache","input","signal","cloned1","cloned2","cacheSetPromise","then","catch","error","aborted","finally","pendingRevalidateKey","pendingRevalidates","pendingRevalidatePromise","Promise","resolve","createPatchedFetcher","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","beginRead","result","trace","internalFetch","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","renderSignal","NODE_ENV","stagedRendering","waitForStage","Dynamic","forceStatic","isCacheableRevalidate","isHmrRefresh","generateCacheKey","fetchIdx","doOriginalFetch","isStale","cacheReasonOverride","requestInputFields","reqInput","reqOptions","_ogBody","otherInput","clonedInit","fetchType","start","cacheStatus","incrementalCacheConfig","isForegroundRevalidate","isHmrRefreshCache","cachedFetchData","lock","entry","isOnDemandRevalidate","softTags","getTimeoutBoundary","isStaticGeneration","pendingRevalidate","response","defineProperty","__NEXT_CACHE_COMPONENTS","cache","hasNextConfig","revalidatedResult","pendingResponse","responses","__nextPatched","__nextGetStaticStore","_nextOriginalFetch","writable","patchFetch","options","original","currentTimeoutBoundary","r","setTimeout"],"mappings":"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","ignoreList":[0]}