{"version":3,"sources":["../../../../src/client/components/router-reducer/fetch-server-response.ts"],"sourcesContent":["'use client'\n\n// TODO: Explicitly import from client.browser\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n createFromReadableStream as createFromReadableStreamBrowser,\n createFromFetch as createFromFetchBrowser,\n} from 'react-server-dom-webpack/client'\n\nimport { InvariantError } from '../../../shared/lib/invariant-error'\nimport type {\n FlightRouterState,\n InitialRSCPayload,\n NavigationFlightResponse,\n} from '../../../shared/lib/app-router-types'\n\nimport {\n type NEXT_ROUTER_PREFETCH_HEADER,\n type NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,\n type NEXT_INSTANT_PREFETCH_HEADER,\n NEXT_ROUTER_STATE_TREE_HEADER,\n NEXT_RSC_UNION_QUERY,\n NEXT_URL,\n RSC_HEADER,\n RSC_CONTENT_TYPE_HEADER,\n NEXT_HMR_REFRESH_HEADER,\n NEXT_DID_POSTPONE_HEADER,\n NEXT_HTML_REQUEST_ID_HEADER,\n NEXT_REQUEST_ID_HEADER,\n} from '../app-router-headers'\nimport { callServer } from '../../app-call-server'\nimport { findSourceMapURL } from '../../app-find-source-map-url'\nimport {\n normalizeFlightData,\n prepareFlightRouterStateForRequest,\n type NormalizedFlightData,\n} from '../../flight-data-helpers'\nimport { setCacheBustingSearchParam } from './set-cache-busting-search-param'\nimport { urlToUrlWithoutFlightMarker } from '../../route-params'\nimport type { NormalizedSearch } from '../segment-cache/cache-key'\nimport { getDeploymentId } from '../../../shared/lib/deployment-id'\nimport { getNavigationBuildId } from '../../navigation-build-id'\nimport { NEXT_NAV_DEPLOYMENT_ID_HEADER } from '../../../lib/constants'\nimport { stripIsPartialByte } from '../segment-cache/cache'\nimport { UnknownDynamicStaleTime } from '../segment-cache/bfcache'\n\nconst createFromReadableStream =\n createFromReadableStreamBrowser as (typeof import('react-server-dom-webpack/client.browser'))['createFromReadableStream']\nconst createFromFetch =\n createFromFetchBrowser as (typeof import('react-server-dom-webpack/client.browser'))['createFromFetch']\n\nlet createDebugChannel:\n | typeof import('../../dev/debug-channel').createDebugChannel\n | undefined\n\nif (process.env.__NEXT_DEV_SERVER && process.env.__NEXT_REACT_DEBUG_CHANNEL) {\n createDebugChannel = (\n require('../../dev/debug-channel') as typeof import('../../dev/debug-channel')\n ).createDebugChannel\n}\n\nexport interface FetchServerResponseOptions {\n readonly flightRouterState: FlightRouterState\n readonly nextUrl: string | null\n readonly isHmrRefresh?: boolean\n}\n\nexport type StaticStageData<\n T extends\n | NavigationFlightResponse\n | InitialRSCPayload = NavigationFlightResponse,\n> = {\n readonly response: T\n readonly isResponsePartial: boolean\n}\n\ntype SpaFetchServerResponseResult = {\n flightData: NormalizedFlightData[]\n canonicalUrl: URL\n renderedSearch: NormalizedSearch\n couldBeIntercepted: boolean\n supportsPerSegmentPrefetching: boolean\n postponed: boolean\n dynamicStaleTime: number\n staticStageData: StaticStageData | null\n runtimePrefetchStream: ReadableStream | null\n responseHeaders: Headers\n debugInfo: Array | null\n}\n\ntype MpaFetchServerResponseResult = string\n\nexport type FetchServerResponseResult =\n | MpaFetchServerResponseResult\n | SpaFetchServerResponseResult\n\nexport type RequestHeaders = {\n [RSC_HEADER]?: '1'\n [NEXT_ROUTER_STATE_TREE_HEADER]?: string\n [NEXT_URL]?: string\n [NEXT_ROUTER_PREFETCH_HEADER]?: '1' | '2'\n [NEXT_ROUTER_SEGMENT_PREFETCH_HEADER]?: string\n 'x-deployment-id'?: string\n [NEXT_HMR_REFRESH_HEADER]?: '1'\n // A header that is only added in test mode to assert on fetch priority\n 'Next-Test-Fetch-Priority'?: RequestInit['priority']\n [NEXT_HTML_REQUEST_ID_HEADER]?: string // dev-only\n [NEXT_REQUEST_ID_HEADER]?: string // dev-only\n [NEXT_INSTANT_PREFETCH_HEADER]?: '1' // testing API only\n}\n\nfunction doMpaNavigation(url: string): FetchServerResponseResult {\n return urlToUrlWithoutFlightMarker(new URL(url, location.origin)).toString()\n}\n\nlet isPageUnloading = false\n\nif (typeof window !== 'undefined') {\n // Track when the page is unloading, e.g. due to reloading the page or\n // performing hard navigations. This allows us to suppress error logging when\n // the browser cancels in-flight requests during page unload.\n window.addEventListener('pagehide', () => {\n isPageUnloading = true\n })\n\n // Reset the flag on pageshow, e.g. when navigating back and the JavaScript\n // execution context is restored by the browser.\n window.addEventListener('pageshow', () => {\n isPageUnloading = false\n })\n}\n\n/**\n * Fetch the flight data for the provided url. Takes in the current router state\n * to decide what to render server-side.\n */\nexport async function fetchServerResponse(\n url: URL,\n options: FetchServerResponseOptions\n): Promise {\n const { flightRouterState, nextUrl } = options\n\n const headers: RequestHeaders = {\n // Enable flight response\n [RSC_HEADER]: '1',\n // Provide the current router state\n [NEXT_ROUTER_STATE_TREE_HEADER]: prepareFlightRouterStateForRequest(\n flightRouterState,\n options.isHmrRefresh\n ),\n }\n\n if (process.env.NODE_ENV === 'development' && options.isHmrRefresh) {\n headers[NEXT_HMR_REFRESH_HEADER] = '1'\n }\n\n if (nextUrl) {\n headers[NEXT_URL] = nextUrl\n }\n\n // In static export mode, we need to modify the URL to request the .txt file,\n // but we should preserve the original URL for the canonical URL and error handling.\n const originalUrl = url\n\n try {\n if (process.env.NODE_ENV === 'production') {\n if (process.env.__NEXT_CONFIG_OUTPUT === 'export') {\n // In \"output: export\" mode, we can't rely on headers to distinguish\n // between HTML and RSC requests. Instead, we append an extra prefix\n // to the request.\n url = new URL(url)\n if (url.pathname.endsWith('/')) {\n url.pathname += 'index.txt'\n } else {\n url.pathname += '.txt'\n }\n }\n }\n\n // Typically, during a navigation, we decode the response using Flight's\n // `createFromFetch` API, which accepts a `fetch` promise.\n // TODO: Remove this check once the old PPR flag is removed\n const isLegacyPPR =\n process.env.__NEXT_PPR && !process.env.__NEXT_CACHE_COMPONENTS\n const shouldImmediatelyDecode = !isLegacyPPR\n const res = await createFetch(\n url,\n headers,\n 'auto',\n shouldImmediatelyDecode\n )\n\n const responseUrl = urlToUrlWithoutFlightMarker(new URL(res.url))\n const canonicalUrl = res.redirected ? responseUrl : originalUrl\n\n const contentType = res.headers.get('content-type') || ''\n const interception = !!res.headers.get('vary')?.includes(NEXT_URL)\n const postponed = !!res.headers.get(NEXT_DID_POSTPONE_HEADER)\n let isFlightResponse = contentType.startsWith(RSC_CONTENT_TYPE_HEADER)\n\n if (process.env.NODE_ENV === 'production') {\n if (process.env.__NEXT_CONFIG_OUTPUT === 'export') {\n if (!isFlightResponse) {\n isFlightResponse = contentType.startsWith('text/plain')\n }\n }\n }\n\n // If fetch returns something different than flight response handle it like a mpa navigation\n // If the fetch was not 200, we also handle it like a mpa navigation\n if (!isFlightResponse || !res.ok || !res.body) {\n // in case the original URL came with a hash, preserve it before redirecting to the new URL\n if (url.hash) {\n responseUrl.hash = url.hash\n }\n\n return doMpaNavigation(responseUrl.toString())\n }\n\n // We may navigate to a page that requires a different Webpack runtime.\n // In prod, every page will have the same Webpack runtime.\n // In dev, the Webpack runtime is minimal for each page.\n // We need to ensure the Webpack runtime is updated before executing client-side JS of the new page.\n // TODO: This needs to happen in the Flight Client.\n // Or Webpack needs to include the runtime update in the Flight response as\n // a blocking script.\n if (process.env.NODE_ENV !== 'production' && !process.env.TURBOPACK) {\n await (\n require('../../dev/hot-reloader/app/hot-reloader-app') as typeof import('../../dev/hot-reloader/app/hot-reloader-app')\n ).waitForWebpackRuntimeHotUpdate()\n }\n\n let flightResponsePromise = res.flightResponsePromise\n if (flightResponsePromise === null) {\n // Typically, `createFetch` would have already started decoding the\n // Flight response. If it hasn't, though, we need to decode it now.\n // TODO: This should only be reachable if legacy PPR is enabled (i.e. PPR\n // without Cache Components). Remove this branch once legacy PPR\n // is deleted.\n flightResponsePromise =\n createFromNextReadableStream(\n res.body,\n headers,\n { allowPartialStream: postponed }\n )\n }\n\n const [flightResponse, cacheData] = await Promise.all([\n flightResponsePromise,\n res.cacheData,\n ])\n\n if (\n (res.headers.get(NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? flightResponse.b) !==\n getNavigationBuildId()\n ) {\n // The server build does not match the client build.\n return doMpaNavigation(res.url)\n }\n\n const normalizedFlightData = normalizeFlightData(flightResponse.f)\n if (typeof normalizedFlightData === 'string') {\n return doMpaNavigation(normalizedFlightData)\n }\n\n const staticStageData =\n cacheData !== null\n ? await resolveStaticStageData(cacheData, flightResponse, headers)\n : null\n\n return {\n flightData: normalizedFlightData,\n canonicalUrl: canonicalUrl,\n // TODO: We should be able to read this from the rewrite header, not the\n // Flight response. Theoretically they should always agree, but there are\n // currently some cases where it's incorrect for interception routes. We\n // can always trust the value in the response body. However, per-segment\n // prefetch responses don't embed the value in the body; they rely on the\n // header alone. So we need to investigate why the header is sometimes\n // wrong for interception routes.\n renderedSearch: flightResponse.q as NormalizedSearch,\n couldBeIntercepted: interception,\n supportsPerSegmentPrefetching: flightResponse.S,\n postponed,\n // The dynamicStaleTime is only present in the response body when\n // a page exports unstable_dynamicStaleTime and this is a dynamic render.\n // When absent (UnknownDynamicStaleTime), the client falls back to the\n // global DYNAMIC_STALETIME_MS. The value is in seconds.\n dynamicStaleTime: flightResponse.d ?? UnknownDynamicStaleTime,\n staticStageData,\n runtimePrefetchStream: flightResponse.p ?? null,\n responseHeaders: res.headers,\n debugInfo: flightResponsePromise._debugInfo ?? null,\n }\n } catch (err) {\n if (!isPageUnloading) {\n console.error(\n `Failed to fetch RSC payload for ${originalUrl}. Falling back to browser navigation.`,\n err\n )\n }\n\n // If fetch fails handle it like a mpa navigation\n // TODO-APP: Add a test for the case where a CORS request fails, e.g. external url redirect coming from the response.\n // See https://github.com/vercel/next.js/issues/43605#issuecomment-1451617521 for a reproduction.\n return originalUrl.toString()\n }\n}\n\n// This is a subset of the standard Response type. We use a custom type for\n// this so we can limit which details about the response leak into the rest of\n// the codebase. For example, there's some custom logic for manually following\n// redirects, so \"redirected\" in this type could be a composite of multiple\n// browser fetch calls; however, this fact should not leak to the caller.\nexport type RSCResponse = {\n ok: boolean\n redirected: boolean\n headers: Headers\n body: ReadableStream | null\n status: number\n url: string\n flightResponsePromise: (Promise & { _debugInfo?: Array }) | null\n cacheData: Promise\n}\n\ntype FetchResponseCacheData = {\n isResponsePartial: boolean\n responseBodyClone?: ReadableStream\n}\n\n/**\n * Strips the leading isPartial byte from an RSC navigation response and\n * clones the body for segment cache extraction.\n *\n * When cache components is enabled, the server prepends a single byte:\n * '~' (0x7e) for partial, '#' (0x23) for complete. This must be stripped\n * before Flight decoding because it's not valid RSC data. The body is\n * cloned before Flight can consume it so the clone is available for later use.\n *\n * When cache components is disabled, returns the original response with\n * cacheData: null.\n */\nexport async function processFetch(response: Response): Promise<{\n response: Response\n cacheData: FetchResponseCacheData | null\n}> {\n if (process.env.__NEXT_CACHE_COMPONENTS) {\n if (!response.body) {\n throw new InvariantError(\n 'Expected RSC navigation response to have a body'\n )\n }\n\n const { stream, isPartial } = await stripIsPartialByte(response.body)\n\n let responseStream: ReadableStream\n let cacheData: FetchResponseCacheData\n\n if (process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS) {\n const [stream1, stream2] = stream.tee()\n responseStream = stream1\n cacheData = { isResponsePartial: isPartial, responseBodyClone: stream2 }\n } else {\n responseStream = stream\n cacheData = { isResponsePartial: isPartial }\n }\n\n const strippedResponse = new Response(responseStream, {\n headers: response.headers,\n status: response.status,\n statusText: response.statusText,\n })\n\n // The Response constructor doesn't preserve `url` or `redirected` from\n // the original. We need both: `url` for React DevTools and `redirected`\n // for the redirect replay logic below.\n Object.defineProperty(strippedResponse, 'url', { value: response.url })\n Object.defineProperty(strippedResponse, 'redirected', {\n value: response.redirected,\n })\n\n return { response: strippedResponse, cacheData }\n }\n\n return { response, cacheData: null }\n}\n\n/**\n * Resolves the static stage response from the raw `processFetch` outputs and\n * the decoded flight response, for writing into the segment cache.\n *\n * - Fully static: use the decoded flight response as-is, no truncation needed.\n * - Not fully static + `l` field: truncate the body clone at the static stage\n * byte boundary and decode.\n * - Otherwise: no cache-worthy data.\n */\nexport async function resolveStaticStageData<\n T extends NavigationFlightResponse | InitialRSCPayload,\n>(\n cacheData: FetchResponseCacheData,\n flightResponse: T,\n headers: RequestHeaders | undefined\n): Promise | null> {\n const { isResponsePartial, responseBodyClone } = cacheData\n\n if (responseBodyClone) {\n if (!isResponsePartial) {\n // Fully static — cache the entire decoded response as-is.\n responseBodyClone.cancel()\n\n return { response: flightResponse, isResponsePartial: false }\n }\n\n if (flightResponse.l !== undefined) {\n // Partially static — truncate the body clone at the byte boundary and\n // decode it.\n const response = await decodeStaticStage(\n responseBodyClone,\n flightResponse.l,\n headers\n )\n\n return { response, isResponsePartial: true }\n }\n\n // No caching — cancel the unused clone.\n responseBodyClone.cancel()\n }\n\n return null\n}\n\n/**\n * Truncates a Flight stream clone at the given byte boundary and decodes the\n * static stage prefix. Used by both the navigation path and the initial HTML\n * hydration path.\n */\nexport async function decodeStaticStage(\n responseBodyClone: ReadableStream,\n staticStageByteLengthPromise: Promise,\n headers: RequestHeaders | undefined\n): Promise {\n const staticStageByteLength = await staticStageByteLengthPromise\n\n const truncatedStream = truncateStream(\n responseBodyClone,\n staticStageByteLength\n )\n\n return createFromNextReadableStream(truncatedStream, headers, {\n allowPartialStream: true,\n })\n}\n\nexport async function createFetch(\n url: URL,\n headers: RequestHeaders,\n fetchPriority: 'auto' | 'high' | 'low' | null,\n shouldImmediatelyDecode: boolean,\n signal?: AbortSignal\n): Promise> {\n // TODO: In output: \"export\" mode, the headers do nothing. Omit them (and the\n // cache busting search param) from the request so they're\n // maximally cacheable.\n\n if (process.env.__NEXT_TEST_MODE && fetchPriority !== null) {\n headers['Next-Test-Fetch-Priority'] = fetchPriority\n }\n\n const deploymentId = getDeploymentId()\n if (deploymentId) {\n headers['x-deployment-id'] = deploymentId\n }\n\n if (process.env.__NEXT_DEV_SERVER) {\n if (self.__next_r) {\n headers[NEXT_HTML_REQUEST_ID_HEADER] = self.__next_r\n }\n\n // Create a new request ID for the server action request. The server uses\n // this to tag debug information sent via WebSocket to the client, which\n // then routes those chunks to the debug channel associated with this ID.\n headers[NEXT_REQUEST_ID_HEADER] = crypto\n .getRandomValues(new Uint32Array(1))[0]\n .toString(16)\n }\n\n const fetchOptions: RequestInit = {\n // Backwards compat for older browsers. `same-origin` is the default in modern browsers.\n credentials: 'same-origin',\n headers,\n priority: fetchPriority || undefined,\n signal,\n }\n // `fetchUrl` is slightly different from `url` because we add a cache-busting\n // search param to it. This should not leak outside of this function, so we\n // track them separately.\n let fetchUrl = new URL(url)\n await setCacheBustingSearchParam(fetchUrl, headers)\n let processed = fetch(fetchUrl, fetchOptions).then(processFetch)\n let fetchPromise = processed.then(({ response }) => response)\n\n // Immediately pass the fetch promise to the Flight client so that the debug\n // info includes the latency from the client to the server. The internal timer\n // in React starts as soon as `createFromFetch` is called.\n //\n // The only case where we don't do this is during a prefetch, because a\n // top-level prefetch response never blocks a navigation; if it hasn't already\n // been written into the cache by the time the navigation happens, the router\n // will go straight to a dynamic request.\n let flightResponsePromise = shouldImmediatelyDecode\n ? createFromNextFetch(fetchPromise, headers)\n : null\n let browserResponse = await fetchPromise\n\n // If the server responds with a redirect (e.g. 307), and the redirected\n // location does not contain the cache busting search param set in the\n // original request, the response is likely invalid — when following the\n // redirect, the browser forwards the request headers, but since the cache\n // busting search param is missing, the server will reject the request due to\n // a mismatch.\n //\n // Ideally, we would be able to intercept the redirect response and perform it\n // manually, instead of letting the browser automatically follow it, but this\n // is not allowed by the fetch API.\n //\n // So instead, we must \"replay\" the redirect by fetching the new location\n // again, but this time we'll append the cache busting search param to prevent\n // a mismatch.\n //\n // TODO: We can optimize Next.js's built-in middleware APIs by returning a\n // custom status code, to prevent the browser from automatically following it.\n //\n // This does not affect Server Action-based redirects; those are encoded\n // differently, as part of the Flight body. It only affects redirects that\n // occur in a middleware or a third-party proxy.\n\n let redirected = browserResponse.redirected\n if (process.env.__NEXT_CLIENT_VALIDATE_RSC_REQUEST_HEADERS) {\n // This is to prevent a redirect loop. Same limit used by Chrome.\n const MAX_REDIRECTS = 20\n for (let n = 0; n < MAX_REDIRECTS; n++) {\n if (!browserResponse.redirected) {\n // The server did not perform a redirect.\n break\n }\n const responseUrl = new URL(browserResponse.url, fetchUrl)\n if (responseUrl.origin !== fetchUrl.origin) {\n // The server redirected to an external URL. The rest of the logic below\n // is not relevant, because it only applies to internal redirects.\n break\n }\n if (\n responseUrl.searchParams.get(NEXT_RSC_UNION_QUERY) ===\n fetchUrl.searchParams.get(NEXT_RSC_UNION_QUERY)\n ) {\n // The redirected URL already includes the cache busting search param.\n // This was probably intentional. Regardless, there's no reason to\n // issue another request to this URL because it already has the param\n // value that we would have added below.\n break\n }\n // The RSC request was redirected. Assume the response is invalid.\n //\n // Append the cache busting search param to the redirected URL and\n // fetch again.\n // TODO: We should abort the previous request.\n fetchUrl = new URL(responseUrl)\n await setCacheBustingSearchParam(fetchUrl, headers)\n processed = fetch(fetchUrl, fetchOptions).then(processFetch)\n fetchPromise = processed.then(({ response }) => response)\n flightResponsePromise = shouldImmediatelyDecode\n ? createFromNextFetch(fetchPromise, headers)\n : null\n browserResponse = await fetchPromise\n // We just performed a manual redirect, so this is now true.\n redirected = true\n }\n }\n\n // Remove the cache busting search param from the response URL, to prevent it\n // from leaking outside of this function.\n const responseUrl = new URL(browserResponse.url, fetchUrl)\n responseUrl.searchParams.delete(NEXT_RSC_UNION_QUERY)\n\n const rscResponse: RSCResponse = {\n url: responseUrl.href,\n\n // This is true if any redirects occurred, either automatically by the\n // browser, or manually by us. So it's different from\n // `browserResponse.redirected`, which only tells us whether the browser\n // followed a redirect, and only for the last response in the chain.\n redirected,\n\n // These can be copied from the last browser response we received. We\n // intentionally only expose the subset of fields that are actually used\n // elsewhere in the codebase.\n ok: browserResponse.ok,\n headers: browserResponse.headers,\n body: browserResponse.body,\n status: browserResponse.status,\n\n // This is the exact promise returned by `createFromFetch`. It contains\n // debug information that we need to transfer to any derived promises that\n // are later rendered by React.\n flightResponsePromise: flightResponsePromise,\n\n cacheData: processed.then(({ cacheData }) => cacheData),\n }\n\n return rscResponse\n}\n\nexport function createFromNextReadableStream(\n flightStream: ReadableStream,\n requestHeaders: RequestHeaders | undefined,\n options?: { allowPartialStream?: boolean }\n): Promise {\n return createFromReadableStream(flightStream, {\n callServer,\n findSourceMapURL,\n debugChannel: createDebugChannel && createDebugChannel(requestHeaders),\n unstable_allowPartialStream: options?.allowPartialStream,\n })\n}\n\nfunction createFromNextFetch(\n promiseForResponse: Promise,\n requestHeaders: RequestHeaders\n): Promise & { _debugInfo?: Array } {\n return createFromFetch(promiseForResponse, {\n callServer,\n findSourceMapURL,\n debugChannel: createDebugChannel && createDebugChannel(requestHeaders),\n })\n}\n\nfunction truncateStream(\n stream: ReadableStream,\n byteLength: number\n): ReadableStream {\n const reader = stream.getReader()\n let remaining = byteLength\n\n return new ReadableStream({\n async pull(controller) {\n if (remaining <= 0) {\n reader.cancel()\n controller.close()\n return\n }\n\n const { done, value } = await reader.read()\n\n if (done) {\n controller.close()\n return\n }\n\n if (value.byteLength <= remaining) {\n controller.enqueue(value)\n remaining -= value.byteLength\n } else {\n controller.enqueue(value.subarray(0, remaining))\n remaining = 0\n reader.cancel()\n controller.close()\n }\n },\n cancel() {\n reader.cancel()\n },\n })\n}\n"],"names":["createFetch","createFromNextReadableStream","decodeStaticStage","fetchServerResponse","processFetch","resolveStaticStageData","createFromReadableStream","createFromReadableStreamBrowser","createFromFetch","createFromFetchBrowser","createDebugChannel","process","env","__NEXT_DEV_SERVER","__NEXT_REACT_DEBUG_CHANNEL","require","doMpaNavigation","url","urlToUrlWithoutFlightMarker","URL","location","origin","toString","isPageUnloading","window","addEventListener","options","flightRouterState","nextUrl","headers","RSC_HEADER","NEXT_ROUTER_STATE_TREE_HEADER","prepareFlightRouterStateForRequest","isHmrRefresh","NODE_ENV","NEXT_HMR_REFRESH_HEADER","NEXT_URL","originalUrl","__NEXT_CONFIG_OUTPUT","pathname","endsWith","isLegacyPPR","__NEXT_PPR","__NEXT_CACHE_COMPONENTS","shouldImmediatelyDecode","res","responseUrl","canonicalUrl","redirected","contentType","get","interception","includes","postponed","NEXT_DID_POSTPONE_HEADER","isFlightResponse","startsWith","RSC_CONTENT_TYPE_HEADER","ok","body","hash","TURBOPACK","waitForWebpackRuntimeHotUpdate","flightResponsePromise","allowPartialStream","flightResponse","cacheData","Promise","all","NEXT_NAV_DEPLOYMENT_ID_HEADER","b","getNavigationBuildId","normalizedFlightData","normalizeFlightData","f","staticStageData","flightData","renderedSearch","q","couldBeIntercepted","supportsPerSegmentPrefetching","S","dynamicStaleTime","d","UnknownDynamicStaleTime","runtimePrefetchStream","p","responseHeaders","debugInfo","_debugInfo","err","console","error","response","InvariantError","stream","isPartial","stripIsPartialByte","responseStream","__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS","stream1","stream2","tee","isResponsePartial","responseBodyClone","strippedResponse","Response","status","statusText","Object","defineProperty","value","cancel","l","undefined","staticStageByteLengthPromise","staticStageByteLength","truncatedStream","truncateStream","fetchPriority","signal","__NEXT_TEST_MODE","deploymentId","getDeploymentId","self","__next_r","NEXT_HTML_REQUEST_ID_HEADER","NEXT_REQUEST_ID_HEADER","crypto","getRandomValues","Uint32Array","fetchOptions","credentials","priority","fetchUrl","setCacheBustingSearchParam","processed","fetch","then","fetchPromise","createFromNextFetch","browserResponse","__NEXT_CLIENT_VALIDATE_RSC_REQUEST_HEADERS","MAX_REDIRECTS","n","searchParams","NEXT_RSC_UNION_QUERY","delete","rscResponse","href","flightStream","requestHeaders","callServer","findSourceMapURL","debugChannel","unstable_allowPartialStream","promiseForResponse","byteLength","reader","getReader","remaining","ReadableStream","pull","controller","close","done","read","enqueue","subarray"],"mappings":"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","ignoreList":[0]}