{"version":3,"sources":["../../../../../src/server/lib/incremental-cache/index.ts"],"sourcesContent":["import type { CacheFs } from '../../../shared/lib/utils'\nimport type { PrerenderManifest } from '../../../build'\nimport {\n type IncrementalCacheValue,\n type IncrementalCacheEntry,\n type IncrementalCache as IncrementalCacheType,\n IncrementalCacheKind,\n CachedRouteKind,\n type IncrementalResponseCacheEntry,\n type IncrementalFetchCacheEntry,\n type GetIncrementalFetchCacheContext,\n type GetIncrementalResponseCacheContext,\n type CachedFetchValue,\n type SetIncrementalFetchCacheContext,\n type SetIncrementalResponseCacheContext,\n} from '../../response-cache'\nimport type { DeepReadonly } from '../../../shared/lib/deep-readonly'\nimport FileSystemCache from './file-system-cache'\nimport { normalizePagePath } from '../../../shared/lib/page-path/normalize-page-path'\n\nimport {\n CACHE_ONE_YEAR_SECONDS,\n NEXT_CACHE_TAGS_HEADER,\n PRERENDER_REVALIDATE_HEADER,\n} from '../../../lib/constants'\nimport { toRoute } from '../to-route'\nimport { SharedCacheControls } from './shared-cache-controls.external'\nimport {\n getResumeDataCache,\n workUnitAsyncStorage,\n} from '../../app-render/work-unit-async-storage.external'\nimport { InvariantError } from '../../../shared/lib/invariant-error'\nimport type { Revalidate } from '../cache-control'\nimport { getPreviouslyRevalidatedTags } from '../../server-utils'\nimport { workAsyncStorage } from '../../app-render/work-async-storage.external'\nimport { DetachedPromise } from '../../../lib/detached-promise'\nimport { areTagsExpired, areTagsStale } from './tags-manifest.external'\n\nexport interface CacheHandlerContext {\n fs?: CacheFs\n dev?: boolean\n flushToDisk?: boolean\n serverDistDir?: string\n maxMemoryCacheSize?: number\n fetchCacheKeyPrefix?: string\n prerenderManifest?: PrerenderManifest\n revalidatedTags: string[]\n _requestHeaders: IncrementalCache['requestHeaders']\n}\n\nexport interface CacheHandlerValue {\n lastModified: number\n age?: number\n cacheState?: string\n value: IncrementalCacheValue | null\n}\n\nfunction toHex(buffer: ArrayBufferView | ArrayBuffer): string {\n // Hex-encode body bytes losslessly: decoding as UTF-8 would collapse\n // distinct bytes (0xff/0xfe to U+FFFD) and collide; Buffer isn't on edge.\n const bytes = isArrayBuffer(buffer)\n ? new Uint8Array(buffer)\n : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)\n let hex = ''\n for (const byte of bytes) {\n hex += byte.toString(16).padStart(2, '0')\n }\n return hex\n}\n\ntype Body = NonNullable\n\n// Duck typing to support Edge runtime\n// TODO: Switch to instanceof checks once Edge runtime is removed.\n\nfunction isArrayBuffer(\n buffer: ArrayBuffer | ArrayBufferView\n): buffer is ArrayBuffer {\n return !('buffer' in buffer)\n}\n\nfunction isBodyByteSequence(\n body: Body\n): body is ArrayBufferView | ArrayBuffer {\n return typeof body === 'object' && 'byteLength' in body\n}\n\nfunction isBodyReadableStream(body: Body): body is ReadableStream {\n return typeof (body as any).getReader === 'function'\n}\n\nfunction isBodyFormDataOrURLSearchParams(\n body: Body\n): body is FormData | URLSearchParams {\n return typeof (body as any).keys === 'function'\n}\n\nfunction isBodyBlob(body: Body): body is Blob {\n return typeof (body as any).arrayBuffer === 'function'\n}\n\nexport class CacheHandler {\n // eslint-disable-next-line\n constructor(_ctx: CacheHandlerContext) {}\n\n public async get(\n _cacheKey: string,\n _ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext\n ): Promise {\n return {} as any\n }\n\n public async set(\n _cacheKey: string,\n _data: IncrementalCacheValue | null,\n _ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext\n ): Promise {}\n\n public async revalidateTag(\n _tags: string | string[],\n _durations?: { expire?: number }\n ): Promise {}\n\n public resetRequestCache(): void {}\n}\n\nasync function hashString(cacheString: string): Promise {\n if (process.env.NEXT_RUNTIME === 'edge') {\n const encoder = new TextEncoder()\n const buffer = encoder.encode(cacheString)\n return toHex(await crypto.subtle.digest('SHA-256', buffer))\n } else {\n const crypto = require('crypto') as typeof import('crypto')\n return crypto.createHash('sha256').update(cacheString).digest('hex')\n }\n}\n\n// this should be bumped anytime a fix is made to cache entries\n// that should bust the cache\nconst MAIN_KEY_PREFIX = 'v4'\n\nexport class IncrementalCache implements IncrementalCacheType {\n readonly dev?: boolean\n readonly disableForTestmode?: boolean\n readonly cacheHandler?: CacheHandler\n readonly hasCustomCacheHandler: boolean\n readonly prerenderManifest: DeepReadonly\n readonly requestHeaders: Record\n readonly allowedRevalidateHeaderKeys?: string[]\n readonly minimalMode?: boolean\n readonly fetchCacheKeyPrefix?: string\n readonly isOnDemandRevalidate?: boolean\n readonly revalidatedTags?: readonly string[]\n\n private static readonly debug: boolean =\n !!process.env.NEXT_PRIVATE_DEBUG_CACHE\n private readonly locks = new Map>()\n\n /**\n * The cache controls for routes. This will source the values from the\n * prerender manifest until the in-memory cache is updated with new values.\n */\n private readonly cacheControls: SharedCacheControls\n\n constructor({\n fs,\n dev,\n flushToDisk,\n minimalMode,\n serverDistDir,\n requestHeaders,\n maxMemoryCacheSize,\n getPrerenderManifest,\n fetchCacheKeyPrefix,\n CurCacheHandler,\n allowedRevalidateHeaderKeys,\n }: {\n fs?: CacheFs\n dev: boolean\n minimalMode?: boolean\n serverDistDir?: string\n flushToDisk?: boolean\n allowedRevalidateHeaderKeys?: string[]\n requestHeaders: IncrementalCache['requestHeaders']\n maxMemoryCacheSize?: number\n getPrerenderManifest: () => DeepReadonly\n fetchCacheKeyPrefix?: string\n CurCacheHandler?: typeof CacheHandler\n }) {\n this.hasCustomCacheHandler = Boolean(CurCacheHandler)\n\n const cacheHandlersSymbol = Symbol.for('@next/cache-handlers')\n const _globalThis: typeof globalThis & {\n [cacheHandlersSymbol]?: {\n FetchCache?: typeof CacheHandler\n }\n } = globalThis\n\n if (!CurCacheHandler) {\n // if we have a global cache handler available leverage it\n const globalCacheHandler = _globalThis[cacheHandlersSymbol]\n\n if (globalCacheHandler?.FetchCache) {\n CurCacheHandler = globalCacheHandler.FetchCache\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: using global FetchCache cache handler')\n }\n } else {\n if (fs && serverDistDir) {\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: using filesystem cache handler')\n }\n CurCacheHandler = FileSystemCache\n }\n }\n } else if (IncrementalCache.debug) {\n console.log(\n 'IncrementalCache: using custom cache handler',\n CurCacheHandler.name\n )\n }\n\n if (process.env.__NEXT_TEST_MAX_ISR_CACHE) {\n // Allow cache size to be overridden for testing purposes\n maxMemoryCacheSize = parseInt(process.env.__NEXT_TEST_MAX_ISR_CACHE, 10)\n }\n this.dev = dev\n this.disableForTestmode = process.env.NEXT_PRIVATE_TEST_PROXY === 'true'\n // this is a hack to avoid Webpack knowing this is equal to this.minimalMode\n // because we replace this.minimalMode to true in production bundles.\n const minimalModeKey = 'minimalMode'\n this[minimalModeKey] = minimalMode\n this.requestHeaders = requestHeaders\n this.allowedRevalidateHeaderKeys = allowedRevalidateHeaderKeys\n this.prerenderManifest = getPrerenderManifest()\n this.cacheControls = new SharedCacheControls(this.prerenderManifest)\n this.fetchCacheKeyPrefix = fetchCacheKeyPrefix\n let revalidatedTags: string[] = []\n\n if (\n requestHeaders[PRERENDER_REVALIDATE_HEADER] ===\n this.prerenderManifest?.preview?.previewModeId\n ) {\n this.isOnDemandRevalidate = true\n }\n\n if (minimalMode) {\n revalidatedTags = this.revalidatedTags = getPreviouslyRevalidatedTags(\n requestHeaders,\n this.prerenderManifest?.preview?.previewModeId\n )\n }\n\n if (CurCacheHandler) {\n this.cacheHandler = new CurCacheHandler({\n dev,\n fs,\n flushToDisk,\n serverDistDir,\n revalidatedTags,\n maxMemoryCacheSize,\n _requestHeaders: requestHeaders,\n fetchCacheKeyPrefix,\n })\n }\n }\n\n private calculateRevalidate(\n pathname: string,\n fromTime: number,\n dev: boolean,\n isFallback: boolean | undefined\n ): Revalidate {\n // in development we don't have a prerender-manifest\n // and default to always revalidating to allow easier debugging\n if (dev)\n return Math.floor(performance.timeOrigin + performance.now() - 1000)\n\n const cacheControl = this.cacheControls.get(toRoute(pathname))\n\n // if an entry isn't present in routes we fallback to a default\n // of revalidating after 1 second unless it's a fallback request.\n const initialRevalidateSeconds = cacheControl\n ? cacheControl.revalidate\n : isFallback\n ? false\n : 1\n\n const revalidateAfter =\n typeof initialRevalidateSeconds === 'number'\n ? initialRevalidateSeconds * 1000 + fromTime\n : initialRevalidateSeconds\n\n return revalidateAfter\n }\n\n _getPathname(pathname: string, fetchCache?: boolean) {\n return fetchCache ? pathname : normalizePagePath(pathname)\n }\n\n resetRequestCache() {\n this.cacheHandler?.resetRequestCache?.()\n }\n\n async lock(cacheKey: string): Promise<() => Promise | void> {\n // Wait for any existing lock on this cache key to be released\n // This implements a simple queue-based locking mechanism\n while (true) {\n const lock = this.locks.get(cacheKey)\n\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: lock get', cacheKey, !!lock)\n }\n\n // If no lock exists, we can proceed to acquire it\n if (!lock) break\n\n // Wait for the existing lock to be released before trying again\n await lock\n }\n\n // Create a new detached promise that will represent this lock\n // The resolve function (unlock) will be returned to the caller\n const { resolve, promise } = new DetachedPromise()\n\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: successfully locked', cacheKey)\n }\n\n // Store the lock promise in the locks map\n this.locks.set(cacheKey, promise)\n\n return () => {\n // Resolve the promise to release the lock.\n resolve()\n\n // Remove the lock from the map once it's released so that future gets\n // can acquire the lock.\n this.locks.delete(cacheKey)\n }\n }\n\n async revalidateTag(\n tags: string | string[],\n durations?: { expire?: number }\n ): Promise {\n return this.cacheHandler?.revalidateTag(tags, durations)\n }\n\n async generateSimpleCacheKey(input: string): Promise {\n const cacheString = JSON.stringify([\n MAIN_KEY_PREFIX,\n this.fetchCacheKeyPrefix || '',\n input,\n ])\n\n return hashString(cacheString)\n }\n\n // x-ref: https://github.com/facebook/react/blob/2655c9354d8e1c54ba888444220f63e836925caa/packages/react/src/ReactFetch.js#L23\n async generateCacheKey(\n url: string,\n init: RequestInit | Request = {}\n ): Promise {\n const bodyChunks: string[] = []\n\n const encoder = new TextEncoder()\n\n // Will be set implementing https://fetch.spec.whatwg.org/#concept-bodyinit-extract\n let bodyType: string | null = null\n const body = init.body\n if (body) {\n if (isBodyByteSequence(body)) {\n bodyChunks.push(`bytes:${toHex(body)}`)\n ;(init as any)._ogBody = body\n } else if (isBodyReadableStream(body)) {\n const readableBody = body\n\n const chunks: Uint8Array[] = []\n\n try {\n await readableBody.pipeTo(\n new WritableStream({\n write(chunk) {\n chunks.push(\n typeof chunk === 'string' ? encoder.encode(chunk) : chunk\n )\n },\n })\n )\n\n // Create a new buffer with all the chunks.\n const length = chunks.reduce((total, arr) => total + arr.length, 0)\n const arrayBuffer = new Uint8Array(length)\n\n // Push each of the chunks into the new array buffer.\n let offset = 0\n for (const chunk of chunks) {\n arrayBuffer.set(chunk, offset)\n offset += chunk.length\n }\n\n bodyChunks.push(`bytes:${toHex(arrayBuffer)}`)\n ;(init as any)._ogBody = arrayBuffer\n } catch (err) {\n console.error('Problem reading body', err)\n }\n } else if (isBodyFormDataOrURLSearchParams(body)) {\n bodyType =\n String(body) === '[object FormData]'\n ? // We don't need a boundary because we're not actually using this for a Content-Type header\n 'multipart/form-data; boundary='\n : 'application/x-www-form-urlencoded;charset=UTF-8'\n const iterable = body\n ;(init as any)._ogBody = body\n // Separate, tagged chunks so `[\"a\",\"b\"]` can't collide with `[\"a,b\"]`.\n for (const [key, val] of iterable.entries()) {\n bodyChunks.push(`key:${key}`)\n if (typeof val === 'string') {\n bodyChunks.push(`str:${val}`)\n } else {\n bodyChunks.push(\n 'file',\n val.name,\n val.type,\n `bytes:${toHex(await val.arrayBuffer())}`\n )\n }\n }\n // handle blob body\n } else if (isBodyBlob(body)) {\n const blob = body\n const arrayBuffer = await blob.arrayBuffer()\n bodyChunks.push('blob', blob.type, `bytes:${toHex(arrayBuffer)}`)\n ;(init as any)._ogBody = new Blob([arrayBuffer], { type: blob.type })\n bodyType = blob.type\n } else if (typeof body === 'string') {\n bodyChunks.push(`str:${body}`)\n ;(init as any)._ogBody = body\n bodyType = 'text/plain;charset=UTF-8'\n } else {\n body satisfies never\n throw new Error(`Unsupported body type: ${typeof body}`)\n }\n }\n\n const headers =\n typeof (init.headers || {}).keys === 'function'\n ? Object.fromEntries(init.headers as Headers)\n : Object.assign({} as Record, init.headers)\n\n // w3c trace context headers can break request caching and deduplication\n // so we remove them from the cache key\n if ('traceparent' in headers) delete headers['traceparent']\n if ('tracestate' in headers) delete headers['tracestate']\n\n const cacheString = JSON.stringify([\n MAIN_KEY_PREFIX,\n this.fetchCacheKeyPrefix || '',\n url,\n init.method,\n // Ensures default Content-Type is part of the cache key\n // TODO: Only necessary when headers are not used from the Request instance\n bodyType,\n headers,\n init.mode,\n init.redirect,\n init.credentials,\n init.referrer,\n init.referrerPolicy,\n init.integrity,\n init.cache,\n bodyChunks,\n ])\n\n return hashString(cacheString)\n }\n\n async get(\n cacheKey: string,\n ctx: GetIncrementalFetchCacheContext\n ): Promise\n async get(\n cacheKey: string,\n ctx: GetIncrementalResponseCacheContext\n ): Promise\n async get(\n cacheKey: string,\n ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext\n ): Promise {\n // Unlike other caches if we have a resume data cache, we use it even if\n // testmode would normally disable it or if requestHeaders say 'no-cache'.\n if (ctx.kind === IncrementalCacheKind.FETCH) {\n const workUnitStore = workUnitAsyncStorage.getStore()\n const resumeDataCache = workUnitStore\n ? getResumeDataCache(workUnitStore)\n : null\n if (resumeDataCache) {\n const memoryCacheData = resumeDataCache.fetch.get(cacheKey)\n if (memoryCacheData?.kind === CachedRouteKind.FETCH) {\n // Check if any tags were recently revalidated before returning RDC entry.\n // When a server action calls updateTag(), the re-render should see fresh\n // data instead of stale RDC data.\n const workStore = workAsyncStorage.getStore()\n const combinedTags = [...(ctx.tags || []), ...(ctx.softTags || [])]\n const hasRevalidatedTag = combinedTags.some(\n (tag) =>\n this.revalidatedTags?.includes(tag) ||\n workStore?.pendingRevalidatedTags?.some(\n (item) => item.tag === tag\n )\n )\n\n if (hasRevalidatedTag) {\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: rdc:revalidated-tag', cacheKey)\n }\n // Fall through to cacheHandler lookup\n } else {\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: rdc:hit', cacheKey)\n }\n\n return { isStale: false, value: memoryCacheData }\n }\n } else if (IncrementalCache.debug) {\n console.log('IncrementalCache: rdc:miss', cacheKey)\n }\n } else {\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: rdc:no-resume-data')\n }\n }\n }\n\n // we don't leverage the prerender cache in dev mode\n // so that getStaticProps is always called for easier debugging\n if (\n this.disableForTestmode ||\n (this.dev &&\n (ctx.kind !== IncrementalCacheKind.FETCH ||\n this.requestHeaders['cache-control'] === 'no-cache'))\n ) {\n return null\n }\n\n cacheKey = this._getPathname(\n cacheKey,\n ctx.kind === IncrementalCacheKind.FETCH\n )\n\n const cacheData = await this.cacheHandler?.get(cacheKey, ctx)\n\n if (ctx.kind === IncrementalCacheKind.FETCH) {\n if (!cacheData) {\n return null\n }\n\n if (cacheData.value?.kind !== CachedRouteKind.FETCH) {\n throw new InvariantError(\n `Expected cached value for cache key ${JSON.stringify(cacheKey)} to be a \"FETCH\" kind, got ${JSON.stringify(cacheData.value?.kind)} instead.`\n )\n }\n\n const workStore = workAsyncStorage.getStore()\n const combinedTags = [...(ctx.tags || []), ...(ctx.softTags || [])]\n // if a tag was revalidated we don't return stale data\n if (\n combinedTags.some(\n (tag) =>\n this.revalidatedTags?.includes(tag) ||\n workStore?.pendingRevalidatedTags?.some((item) => item.tag === tag)\n )\n ) {\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: expired tag', cacheKey)\n }\n\n return null\n }\n\n // As we're able to get the cache entry for this fetch, and the prerender\n // resume data cache (RDC) is available, it must have been populated by a\n // previous fetch, but was not yet present in the in-memory cache. This\n // could be the case when performing multiple renders in parallel during\n // build time where we de-duplicate the fetch calls.\n //\n // We add it to the RDC so that the next fetch call will be able to use it\n // and it won't have to reach into the fetch cache implementation.\n const workUnitStore = workUnitAsyncStorage.getStore()\n if (workUnitStore) {\n const resumeDataCache = getResumeDataCache(workUnitStore)\n if (resumeDataCache?.mutable) {\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: rdc:set', cacheKey)\n }\n\n resumeDataCache.fetch.set(cacheKey, cacheData.value)\n }\n }\n\n const revalidate = ctx.revalidate || cacheData.value.revalidate\n const age =\n (performance.timeOrigin +\n performance.now() -\n (cacheData.lastModified || 0)) /\n 1000\n\n let isStale = age > revalidate\n const data = cacheData.value.data\n\n if (areTagsExpired(combinedTags, cacheData.lastModified)) {\n return null\n } else if (areTagsStale(combinedTags, cacheData.lastModified)) {\n isStale = true\n }\n\n return {\n isStale,\n value: { kind: CachedRouteKind.FETCH, data, revalidate },\n }\n } else if (cacheData?.value?.kind === CachedRouteKind.FETCH) {\n throw new InvariantError(\n `Expected cached value for cache key ${JSON.stringify(cacheKey)} not to be a ${JSON.stringify(ctx.kind)} kind, got \"FETCH\" instead.`\n )\n }\n\n let entry: IncrementalResponseCacheEntry | null = null\n const { isFallback } = ctx\n const cacheControl = this.cacheControls.get(toRoute(cacheKey))\n\n let isStale: boolean | -1 | undefined\n let revalidateAfter: Revalidate\n\n if (cacheData?.lastModified === -1) {\n isStale = -1\n revalidateAfter = -1 * CACHE_ONE_YEAR_SECONDS * 1000\n } else {\n const now = performance.timeOrigin + performance.now()\n const lastModified = cacheData?.lastModified || now\n\n revalidateAfter = this.calculateRevalidate(\n cacheKey,\n lastModified,\n this.dev ?? false,\n ctx.isFallback\n )\n\n // If the route's `expire` time has passed, force a blocking revalidation\n // by signalling `isStale = -1`. The response cache treats `-1` as \"skip\n // the early SWR resolve\" and awaits a fresh render before the user sees a\n // response.\n const expireAfter =\n typeof cacheControl?.expire === 'number'\n ? cacheControl.expire * 1000 + lastModified\n : undefined\n\n if (expireAfter !== undefined && expireAfter < now) {\n isStale = -1\n } else {\n isStale =\n revalidateAfter !== false && revalidateAfter < now ? true : undefined\n\n // If the stale time couldn't be determined based on the revalidation\n // time, we check if the tags are expired or stale.\n if (\n isStale === undefined &&\n (cacheData?.value?.kind === CachedRouteKind.APP_PAGE ||\n cacheData?.value?.kind === CachedRouteKind.APP_ROUTE)\n ) {\n const tagsHeader = cacheData.value.headers?.[NEXT_CACHE_TAGS_HEADER]\n\n if (typeof tagsHeader === 'string') {\n const cacheTags = tagsHeader.split(',')\n\n if (cacheTags.length > 0) {\n if (areTagsExpired(cacheTags, lastModified)) {\n isStale = -1\n } else if (areTagsStale(cacheTags, lastModified)) {\n isStale = true\n }\n }\n }\n }\n }\n }\n\n if (cacheData) {\n entry = {\n isStale,\n cacheControl,\n revalidateAfter,\n value: cacheData.value,\n isFallback,\n }\n }\n\n if (\n !cacheData &&\n this.prerenderManifest.notFoundRoutes.includes(cacheKey)\n ) {\n // for the first hit after starting the server the cache\n // may not have a way to save notFound: true so if\n // the prerender-manifest marks this as notFound then we\n // return that entry and trigger a cache set to give it a\n // chance to update in-memory entries\n entry = {\n isStale,\n value: null,\n cacheControl,\n revalidateAfter,\n isFallback,\n }\n this.set(cacheKey, entry.value, { ...ctx, cacheControl })\n }\n return entry\n }\n\n async set(\n pathname: string,\n data: CachedFetchValue | null,\n ctx: SetIncrementalFetchCacheContext\n ): Promise\n async set(\n pathname: string,\n data: Exclude | null,\n ctx: SetIncrementalResponseCacheContext\n ): Promise\n async set(\n pathname: string,\n data: IncrementalCacheValue | null,\n ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext\n ): Promise {\n // Even if we otherwise disable caching for testMode or if no fetchCache is\n // configured we still always stash results in the resume data cache if one\n // exists. This is because this is a transient in memory cache that\n // populates caches ahead of a dynamic render in dev mode to allow the RSC\n // debug info to have the right environment associated to it.\n if (data?.kind === CachedRouteKind.FETCH) {\n const workUnitStore = workUnitAsyncStorage.getStore()\n const resumeDataCache = workUnitStore\n ? getResumeDataCache(workUnitStore)\n : null\n if (resumeDataCache?.mutable) {\n if (IncrementalCache.debug) {\n console.log('IncrementalCache: rdc:set', pathname)\n }\n\n resumeDataCache.fetch.set(pathname, data)\n }\n }\n\n if (this.disableForTestmode || (this.dev && !ctx.fetchCache)) return\n\n pathname = this._getPathname(pathname, ctx.fetchCache)\n\n // FetchCache has upper limit of 2MB per-entry currently\n const itemSize = JSON.stringify(data).length\n if (\n ctx.fetchCache &&\n itemSize > 2 * 1024 * 1024 &&\n // We ignore the size limit when custom cache handler is being used, as it\n // might not have this limit\n !this.hasCustomCacheHandler &&\n // We also ignore the size limit when it's an implicit build-time-only\n // caching that the user isn't even aware of.\n !ctx.isImplicitBuildTimeCache\n ) {\n const warningText = `Failed to set Next.js data cache for ${ctx.fetchUrl || pathname}, items over 2MB can not be cached (${itemSize} bytes)`\n\n if (this.dev) {\n throw new Error(warningText)\n }\n console.warn(warningText)\n return\n }\n\n try {\n if (!ctx.fetchCache && ctx.cacheControl) {\n this.cacheControls.set(toRoute(pathname), ctx.cacheControl)\n }\n\n await this.cacheHandler?.set(pathname, data, ctx)\n } catch (error) {\n console.warn('Failed to update prerender cache for', pathname, error)\n }\n }\n}\n"],"names":["IncrementalCacheKind","CachedRouteKind","FileSystemCache","normalizePagePath","CACHE_ONE_YEAR_SECONDS","NEXT_CACHE_TAGS_HEADER","PRERENDER_REVALIDATE_HEADER","toRoute","SharedCacheControls","getResumeDataCache","workUnitAsyncStorage","InvariantError","getPreviouslyRevalidatedTags","workAsyncStorage","DetachedPromise","areTagsExpired","areTagsStale","toHex","buffer","bytes","isArrayBuffer","Uint8Array","byteOffset","byteLength","hex","byte","toString","padStart","isBodyByteSequence","body","isBodyReadableStream","getReader","isBodyFormDataOrURLSearchParams","keys","isBodyBlob","arrayBuffer","CacheHandler","constructor","_ctx","get","_cacheKey","set","_data","revalidateTag","_tags","_durations","resetRequestCache","hashString","cacheString","process","env","NEXT_RUNTIME","encoder","TextEncoder","encode","crypto","subtle","digest","require","createHash","update","MAIN_KEY_PREFIX","IncrementalCache","debug","NEXT_PRIVATE_DEBUG_CACHE","fs","dev","flushToDisk","minimalMode","serverDistDir","requestHeaders","maxMemoryCacheSize","getPrerenderManifest","fetchCacheKeyPrefix","CurCacheHandler","allowedRevalidateHeaderKeys","locks","Map","hasCustomCacheHandler","Boolean","cacheHandlersSymbol","Symbol","for","_globalThis","globalThis","globalCacheHandler","FetchCache","console","log","name","__NEXT_TEST_MAX_ISR_CACHE","parseInt","disableForTestmode","NEXT_PRIVATE_TEST_PROXY","minimalModeKey","prerenderManifest","cacheControls","revalidatedTags","preview","previewModeId","isOnDemandRevalidate","cacheHandler","_requestHeaders","calculateRevalidate","pathname","fromTime","isFallback","Math","floor","performance","timeOrigin","now","cacheControl","initialRevalidateSeconds","revalidate","revalidateAfter","_getPathname","fetchCache","lock","cacheKey","resolve","promise","delete","tags","durations","generateSimpleCacheKey","input","JSON","stringify","generateCacheKey","url","init","bodyChunks","bodyType","push","_ogBody","readableBody","chunks","pipeTo","WritableStream","write","chunk","length","reduce","total","arr","offset","err","error","String","iterable","key","val","entries","type","blob","Blob","Error","headers","Object","fromEntries","assign","method","mode","redirect","credentials","referrer","referrerPolicy","integrity","cache","ctx","cacheData","kind","FETCH","workUnitStore","getStore","resumeDataCache","memoryCacheData","fetch","workStore","combinedTags","softTags","hasRevalidatedTag","some","tag","includes","pendingRevalidatedTags","item","isStale","value","mutable","age","lastModified","data","entry","expireAfter","expire","undefined","APP_PAGE","APP_ROUTE","tagsHeader","cacheTags","split","notFoundRoutes","itemSize","isImplicitBuildTimeCache","warningText","fetchUrl","warn"],"mappings":"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","ignoreList":[0]}