{"version":3,"sources":["../../../src/server/use-cache/use-cache-wrapper.ts"],"sourcesContent":["import type { DeepReadonly } from '../../shared/lib/deep-readonly'\n/* eslint-disable import/no-extraneous-dependencies */\nimport {\n  renderToReadableStream,\n  decodeReply,\n  decodeReplyFromAsyncIterable,\n  createTemporaryReferenceSet as createServerTemporaryReferenceSet,\n} from 'react-server-dom-webpack/server'\nimport {\n  createFromReadableStream,\n  encodeReply,\n  createTemporaryReferenceSet as createClientTemporaryReferenceSet,\n} from 'react-server-dom-webpack/client'\nimport { prerender } from 'react-server-dom-webpack/static'\n/* eslint-enable import/no-extraneous-dependencies */\n\nimport type { WorkStore } from '../app-render/work-async-storage.external'\nimport { workAsyncStorage } from '../app-render/work-async-storage.external'\nimport type {\n  PrerenderStoreModernClient,\n  PrerenderStoreModernRuntime,\n  PrivateUseCacheStore,\n  RequestStore,\n  RevalidateStore,\n  UseCacheStore,\n  WorkUnitStore,\n} from '../app-render/work-unit-async-storage.external'\nimport {\n  getHmrRefreshHash,\n  getRenderResumeDataCache,\n  getPrerenderResumeDataCache,\n  workUnitAsyncStorage,\n  getDraftModeProviderForCacheScope,\n  getCacheSignal,\n  isHmrRefresh,\n  getServerComponentsHmrCache,\n  getRuntimeStagePromise,\n} from '../app-render/work-unit-async-storage.external'\n\nimport {\n  makeDevtoolsIOAwarePromise,\n  makeHangingPromise,\n} from '../dynamic-rendering-utils'\n\nimport type { ClientReferenceManifest } from '../../build/webpack/plugins/flight-manifest-plugin'\n\nimport {\n  getClientReferenceManifest,\n  getServerModuleMap,\n} from '../app-render/manifests-singleton'\nimport type { CacheEntry } from '../lib/cache-handlers/types'\nimport type { CacheSignal } from '../app-render/cache-signal'\nimport { decryptActionBoundArgs } from '../app-render/encryption'\nimport { InvariantError } from '../../shared/lib/invariant-error'\nimport { createReactServerErrorHandler } from '../app-render/create-error-handler'\nimport { DYNAMIC_EXPIRE, RUNTIME_PREFETCH_DYNAMIC_STALE } from './constants'\nimport { getCacheHandler } from './handlers'\nimport { UseCacheTimeoutError } from './use-cache-errors'\nimport {\n  createHangingInputAbortSignal,\n  postponeWithTracking,\n  throwToInterruptStaticGeneration,\n} from '../app-render/dynamic-rendering'\nimport {\n  makeErroringSearchParamsForUseCache,\n  type SearchParams,\n} from '../request/search-params'\nimport type { Params } from '../request/params'\nimport { createLazyResult, isResolvedLazyResult } from '../lib/lazy-result'\nimport { dynamicAccessAsyncStorage } from '../app-render/dynamic-access-async-storage.external'\nimport type { CacheLife } from './cache-life'\nimport { RenderStage } from '../app-render/staged-rendering'\nimport * as Log from '../../build/output/log'\n\ninterface PrivateCacheContext {\n  readonly kind: 'private'\n  readonly outerWorkUnitStore:\n    | RequestStore\n    | PrivateUseCacheStore\n    | PrerenderStoreModernRuntime\n}\n\ninterface PublicCacheContext {\n  readonly kind: 'public'\n  // TODO: We should probably forbid nesting \"use cache\" inside unstable_cache.\n  readonly outerWorkUnitStore:\n    | Exclude<WorkUnitStore, PrerenderStoreModernClient>\n    | undefined\n}\n\ntype CacheContext = PrivateCacheContext | PublicCacheContext\n\ntype CacheKeyParts =\n  | [buildId: string, id: string, args: unknown[]]\n  | [buildId: string, id: string, args: unknown[], hmrRefreshHash: string]\n\ninterface UseCachePageInnerProps {\n  params: Promise<Params>\n  searchParams?: Promise<SearchParams>\n}\n\nexport interface UseCachePageProps {\n  params: Promise<Params>\n  searchParams: Promise<SearchParams>\n  $$isPage: true\n}\n\nexport type UseCacheLayoutProps = {\n  params: Promise<Params>\n  $$isLayout: true\n} & {\n  // The value type should be React.ReactNode. But such an index signature would\n  // be incompatible with the other two props.\n  [slot: string]: any\n}\n\nconst isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge'\n\nconst debug = process.env.NEXT_PRIVATE_DEBUG_CACHE\n  ? console.debug.bind(console, 'use-cache:')\n  : undefined\n\nconst filterStackFrame =\n  process.env.NODE_ENV !== 'production'\n    ? (require('../lib/source-maps') as typeof import('../lib/source-maps'))\n        .filterStackFrameDEV\n    : undefined\nconst findSourceMapURL =\n  process.env.NODE_ENV !== 'production'\n    ? (require('../lib/source-maps') as typeof import('../lib/source-maps'))\n        .findSourceMapURLDEV\n    : undefined\n\nfunction generateCacheEntry(\n  workStore: WorkStore,\n  cacheContext: CacheContext,\n  clientReferenceManifest: DeepReadonly<ClientReferenceManifest>,\n  encodedArguments: FormData | string,\n  fn: (...args: unknown[]) => Promise<unknown>,\n  timeoutError: UseCacheTimeoutError\n) {\n  // We need to run this inside a clean AsyncLocalStorage snapshot so that the cache\n  // generation cannot read anything from the context we're currently executing which\n  // might include request specific things like cookies() inside a React.cache().\n  // Note: It is important that we await at least once before this because it lets us\n  // pop out of any stack specific contexts as well - aka \"Sync\" Local Storage.\n  return workStore.runInCleanSnapshot(\n    generateCacheEntryWithRestoredWorkStore,\n    workStore,\n    cacheContext,\n    clientReferenceManifest,\n    encodedArguments,\n    fn,\n    timeoutError\n  )\n}\n\nfunction generateCacheEntryWithRestoredWorkStore(\n  workStore: WorkStore,\n  cacheContext: CacheContext,\n  clientReferenceManifest: DeepReadonly<ClientReferenceManifest>,\n  encodedArguments: FormData | string,\n  fn: (...args: unknown[]) => Promise<unknown>,\n  timeoutError: UseCacheTimeoutError\n) {\n  // Since we cleared the AsyncLocalStorage we need to restore the workStore.\n  // Note: We explicitly don't restore the RequestStore nor the PrerenderStore.\n  // We don't want any request specific information leaking an we don't want to create a\n  // bloated fake request mock for every cache call. So any feature that currently lives\n  // in RequestStore but should be available to Caches need to move to WorkStore.\n  // PrerenderStore is not needed inside the cache scope because the outer most one will\n  // be the one to report its result to the outer Prerender.\n  return workAsyncStorage.run(\n    workStore,\n    generateCacheEntryWithCacheContext,\n    workStore,\n    cacheContext,\n    clientReferenceManifest,\n    encodedArguments,\n    fn,\n    timeoutError\n  )\n}\n\nfunction createUseCacheStore(\n  workStore: WorkStore,\n  cacheContext: CacheContext,\n  defaultCacheLife: Required<CacheLife>\n): UseCacheStore {\n  if (cacheContext.kind === 'private') {\n    const outerWorkUnitStore = cacheContext.outerWorkUnitStore\n\n    return {\n      type: 'private-cache',\n      phase: 'render',\n      implicitTags: outerWorkUnitStore?.implicitTags,\n      revalidate: defaultCacheLife.revalidate,\n      expire: defaultCacheLife.expire,\n      stale: defaultCacheLife.stale,\n      explicitRevalidate: undefined,\n      explicitExpire: undefined,\n      explicitStale: undefined,\n      tags: null,\n      hmrRefreshHash: getHmrRefreshHash(workStore, outerWorkUnitStore),\n      isHmrRefresh: isHmrRefresh(workStore, outerWorkUnitStore),\n      serverComponentsHmrCache: getServerComponentsHmrCache(\n        workStore,\n        outerWorkUnitStore\n      ),\n      forceRevalidate: shouldForceRevalidate(workStore, outerWorkUnitStore),\n      runtimeStagePromise: getRuntimeStagePromise(outerWorkUnitStore),\n      draftMode: getDraftModeProviderForCacheScope(\n        workStore,\n        outerWorkUnitStore\n      ),\n      rootParams: outerWorkUnitStore.rootParams,\n      headers: outerWorkUnitStore.headers,\n      cookies: outerWorkUnitStore.cookies,\n    }\n  } else {\n    let useCacheOrRequestStore: RequestStore | UseCacheStore | undefined\n    const outerWorkUnitStore = cacheContext.outerWorkUnitStore\n\n    if (outerWorkUnitStore) {\n      switch (outerWorkUnitStore?.type) {\n        case 'cache':\n        case 'private-cache':\n        case 'request':\n          useCacheOrRequestStore = outerWorkUnitStore\n          break\n        case 'prerender-runtime':\n        case 'prerender':\n        case 'prerender-ppr':\n        case 'prerender-legacy':\n        case 'unstable-cache':\n          break\n        default:\n          outerWorkUnitStore satisfies never\n      }\n    }\n\n    return {\n      type: 'cache',\n      phase: 'render',\n      implicitTags: outerWorkUnitStore?.implicitTags,\n      revalidate: defaultCacheLife.revalidate,\n      expire: defaultCacheLife.expire,\n      stale: defaultCacheLife.stale,\n      explicitRevalidate: undefined,\n      explicitExpire: undefined,\n      explicitStale: undefined,\n      tags: null,\n      hmrRefreshHash:\n        outerWorkUnitStore && getHmrRefreshHash(workStore, outerWorkUnitStore),\n      isHmrRefresh: useCacheOrRequestStore?.isHmrRefresh ?? false,\n      serverComponentsHmrCache:\n        useCacheOrRequestStore?.serverComponentsHmrCache,\n      forceRevalidate: shouldForceRevalidate(workStore, outerWorkUnitStore),\n      draftMode:\n        outerWorkUnitStore &&\n        getDraftModeProviderForCacheScope(workStore, outerWorkUnitStore),\n    }\n  }\n}\n\nfunction assertDefaultCacheLife(\n  defaultCacheLife: CacheLife | undefined\n): asserts defaultCacheLife is Required<CacheLife> {\n  if (\n    !defaultCacheLife ||\n    defaultCacheLife.revalidate == null ||\n    defaultCacheLife.expire == null ||\n    defaultCacheLife.stale == null\n  ) {\n    throw new InvariantError(\n      'A default cacheLife profile must always be provided.'\n    )\n  }\n}\n\nfunction generateCacheEntryWithCacheContext(\n  workStore: WorkStore,\n  cacheContext: CacheContext,\n  clientReferenceManifest: DeepReadonly<ClientReferenceManifest>,\n  encodedArguments: FormData | string,\n  fn: (...args: unknown[]) => Promise<unknown>,\n  timeoutError: UseCacheTimeoutError\n) {\n  if (!workStore.cacheLifeProfiles) {\n    throw new InvariantError('cacheLifeProfiles should always be provided.')\n  }\n  const defaultCacheLife = workStore.cacheLifeProfiles['default']\n  assertDefaultCacheLife(defaultCacheLife)\n\n  // Initialize the Store for this Cache entry.\n  const cacheStore = createUseCacheStore(\n    workStore,\n    cacheContext,\n    defaultCacheLife\n  )\n\n  return workUnitAsyncStorage.run(cacheStore, () =>\n    dynamicAccessAsyncStorage.run(\n      { abortController: new AbortController() },\n      generateCacheEntryImpl,\n      workStore,\n      cacheContext,\n      cacheStore,\n      clientReferenceManifest,\n      encodedArguments,\n      fn,\n      timeoutError\n    )\n  )\n}\n\nfunction propagateCacheLifeAndTagsToRevalidateStore(\n  revalidateStore: RevalidateStore,\n  entry: CacheEntry\n): void {\n  const outerTags = (revalidateStore.tags ??= [])\n\n  for (const tag of entry.tags) {\n    if (!outerTags.includes(tag)) {\n      outerTags.push(tag)\n    }\n  }\n\n  if (revalidateStore.stale > entry.stale) {\n    revalidateStore.stale = entry.stale\n  }\n\n  if (revalidateStore.revalidate > entry.revalidate) {\n    revalidateStore.revalidate = entry.revalidate\n  }\n\n  if (revalidateStore.expire > entry.expire) {\n    revalidateStore.expire = entry.expire\n  }\n}\n\nfunction propagateCacheLifeAndTags(\n  cacheContext: CacheContext,\n  entry: CacheEntry\n): void {\n  if (cacheContext.kind === 'private') {\n    switch (cacheContext.outerWorkUnitStore.type) {\n      case 'prerender-runtime':\n      case 'private-cache':\n        propagateCacheLifeAndTagsToRevalidateStore(\n          cacheContext.outerWorkUnitStore,\n          entry\n        )\n        break\n      case 'request':\n      case undefined:\n        break\n      default:\n        cacheContext.outerWorkUnitStore satisfies never\n    }\n  } else {\n    switch (cacheContext.outerWorkUnitStore?.type) {\n      case 'cache':\n      case 'private-cache':\n      case 'prerender':\n      case 'prerender-runtime':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n        propagateCacheLifeAndTagsToRevalidateStore(\n          cacheContext.outerWorkUnitStore,\n          entry\n        )\n        break\n      case 'request':\n      case 'unstable-cache':\n      case undefined:\n        break\n      default:\n        cacheContext.outerWorkUnitStore satisfies never\n    }\n  }\n}\n\nasync function collectResult(\n  savedStream: ReadableStream<Uint8Array>,\n  workStore: WorkStore,\n  cacheContext: CacheContext,\n  innerCacheStore: UseCacheStore,\n  startTime: number,\n  errors: Array<unknown> // This is a live array that gets pushed into.\n): Promise<CacheEntry> {\n  // We create a buffered stream that collects all chunks until the end to\n  // ensure that RSC has finished rendering and therefore we have collected\n  // all tags. In the future the RSC API might allow for the equivalent of\n  // the allReady Promise that exists on SSR streams.\n  //\n  // If something errored or rejected anywhere in the render, we close\n  // the stream as errored. This lets a CacheHandler choose to save the\n  // partial result up until that point for future hits for a while to avoid\n  // unnecessary retries or not to retry. We use the end of the stream for\n  // this to avoid another complicated side-channel. A receiver has to consider\n  // that the stream might also error for other reasons anyway such as losing\n  // connection.\n\n  const buffer: Uint8Array[] = []\n  const reader = savedStream.getReader()\n\n  try {\n    for (let entry; !(entry = await reader.read()).done; ) {\n      buffer.push(entry.value)\n    }\n  } catch (error) {\n    errors.push(error)\n  }\n\n  let idx = 0\n  const bufferStream = new ReadableStream<Uint8Array>({\n    pull(controller) {\n      if (workStore.invalidDynamicUsageError) {\n        controller.error(workStore.invalidDynamicUsageError)\n      } else if (idx < buffer.length) {\n        controller.enqueue(buffer[idx++])\n      } else if (errors.length > 0) {\n        // TODO: Should we use AggregateError here?\n        controller.error(errors[0])\n      } else {\n        controller.close()\n      }\n    },\n  })\n\n  const collectedTags = innerCacheStore.tags\n  // If cacheLife() was used to set an explicit revalidate time we use that.\n  // Otherwise, we use the lowest of all inner fetch()/unstable_cache() or nested \"use cache\".\n  // If they're lower than our default.\n  const collectedRevalidate =\n    innerCacheStore.explicitRevalidate !== undefined\n      ? innerCacheStore.explicitRevalidate\n      : innerCacheStore.revalidate\n  const collectedExpire =\n    innerCacheStore.explicitExpire !== undefined\n      ? innerCacheStore.explicitExpire\n      : innerCacheStore.expire\n  const collectedStale =\n    innerCacheStore.explicitStale !== undefined\n      ? innerCacheStore.explicitStale\n      : innerCacheStore.stale\n\n  const entry: CacheEntry = {\n    value: bufferStream,\n    timestamp: startTime,\n    revalidate: collectedRevalidate,\n    expire: collectedExpire,\n    stale: collectedStale,\n    tags: collectedTags === null ? [] : collectedTags,\n  }\n\n  if (cacheContext.outerWorkUnitStore) {\n    const outerWorkUnitStore = cacheContext.outerWorkUnitStore\n\n    // Propagate cache life & tags to the parent context if appropriate.\n    switch (outerWorkUnitStore.type) {\n      case 'prerender':\n      case 'prerender-runtime': {\n        // If we've just created a cache result, and we're filling caches for a\n        // Cache Components prerender, then we don't want to propagate cache\n        // life & tags yet, in case the entry ends up being omitted from the\n        // final prerender due to short expire/stale times. If it is omitted,\n        // then it shouldn't have any effects on the prerender. We'll decide\n        // whether or not this cache should have its life & tags propagated when\n        // we read the entry in the final prerender from the resume data cache.\n\n        break\n      }\n      case 'request': {\n        if (\n          process.env.NODE_ENV === 'development' &&\n          outerWorkUnitStore.cacheSignal\n        ) {\n          // If we're filling caches for a dev request, apply the same logic as prerenders do above,\n          // and don't propagate cache life/tags yet.\n          break\n        }\n        // fallthrough\n      }\n\n      case 'private-cache':\n      case 'cache':\n      case 'unstable-cache':\n      case 'prerender-legacy':\n      case 'prerender-ppr': {\n        propagateCacheLifeAndTags(cacheContext, entry)\n        break\n      }\n      default: {\n        outerWorkUnitStore satisfies never\n      }\n    }\n\n    const cacheSignal = getCacheSignal(outerWorkUnitStore)\n    if (cacheSignal) {\n      cacheSignal.endRead()\n    }\n  }\n\n  return entry\n}\n\ntype GenerateCacheEntryResult =\n  | {\n      readonly type: 'cached'\n      readonly stream: ReadableStream\n      readonly pendingCacheEntry: Promise<CacheEntry>\n    }\n  | {\n      readonly type: 'prerender-dynamic'\n      readonly hangingPromise: Promise<never>\n    }\n\nasync function generateCacheEntryImpl(\n  workStore: WorkStore,\n  cacheContext: CacheContext,\n  innerCacheStore: UseCacheStore,\n  clientReferenceManifest: DeepReadonly<ClientReferenceManifest>,\n  encodedArguments: FormData | string,\n  fn: (...args: unknown[]) => Promise<unknown>,\n  timeoutError: UseCacheTimeoutError\n): Promise<GenerateCacheEntryResult> {\n  const temporaryReferences = createServerTemporaryReferenceSet()\n  const outerWorkUnitStore = cacheContext.outerWorkUnitStore\n\n  const [, , args] =\n    typeof encodedArguments === 'string'\n      ? await decodeReply<CacheKeyParts>(\n          encodedArguments,\n          getServerModuleMap(),\n          { temporaryReferences }\n        )\n      : await decodeReplyFromAsyncIterable<CacheKeyParts>(\n          {\n            async *[Symbol.asyncIterator]() {\n              for (const entry of encodedArguments) {\n                yield entry\n              }\n\n              if (outerWorkUnitStore) {\n                switch (outerWorkUnitStore.type) {\n                  case 'prerender-runtime':\n                  case 'prerender':\n                    // The encoded arguments might contain hanging promises. In\n                    // this case we don't want to reject with \"Error: Connection\n                    // closed.\", so we intentionally keep the iterable alive.\n                    // This is similar to the halting trick that we do while\n                    // rendering.\n                    await new Promise<void>((resolve) => {\n                      if (outerWorkUnitStore.renderSignal.aborted) {\n                        resolve()\n                      } else {\n                        outerWorkUnitStore.renderSignal.addEventListener(\n                          'abort',\n                          () => resolve(),\n                          { once: true }\n                        )\n                      }\n                    })\n                    break\n                  case 'prerender-ppr':\n                  case 'prerender-legacy':\n                  case 'request':\n                  case 'cache':\n                  case 'private-cache':\n                  case 'unstable-cache':\n                    break\n                  default:\n                    outerWorkUnitStore satisfies never\n                }\n              }\n            },\n          },\n          getServerModuleMap(),\n          { temporaryReferences }\n        )\n\n  // Track the timestamp when we started computing the result.\n  const startTime = performance.timeOrigin + performance.now()\n\n  // Invoke the inner function to load a new result. We delay the invocation\n  // though, until React awaits the promise so that React's request store (ALS)\n  // is available when the function is invoked. This allows us, for example, to\n  // capture logs so that we can later replay them.\n  const resultPromise = createLazyResult(fn.bind(null, ...args))\n\n  let errors: Array<unknown> = []\n\n  // In the \"Cache\" environment, we only need to make sure that the error\n  // digests are handled correctly. Error formatting and reporting is not\n  // necessary here; the errors are encoded in the stream, and will be reported\n  // in the \"Server\" environment.\n  const handleError = createReactServerErrorHandler(\n    workStore.dev,\n    workStore.isBuildTimePrerendering ?? false,\n    workStore.reactServerErrorsByDigest,\n    (error) => {\n      // In production, we log the original error here. It gets a digest that\n      // can be used to associate the error with the obfuscated error that might\n      // be logged if the error is caught. In development, we prefer logging the\n      // transported error in the server environment. It's not obfuscated and\n      // also includes the (dev-only) environment name.\n      if (process.env.NODE_ENV === 'production') {\n        Log.error(error)\n      }\n\n      errors.push(error)\n    }\n  )\n\n  let stream: ReadableStream<Uint8Array>\n\n  switch (outerWorkUnitStore?.type) {\n    case 'prerender-runtime':\n    case 'prerender':\n      const timeoutAbortController = new AbortController()\n\n      // If we're prerendering, we give you 50 seconds to fill a cache entry.\n      // Otherwise we assume you stalled on hanging input and de-opt. This needs\n      // to be lower than just the general timeout of 60 seconds.\n      const timer = setTimeout(() => {\n        workStore.invalidDynamicUsageError = timeoutError\n        timeoutAbortController.abort(timeoutError)\n      }, 50000)\n\n      const dynamicAccessAbortSignal =\n        dynamicAccessAsyncStorage.getStore()?.abortController.signal\n\n      const abortSignal = dynamicAccessAbortSignal\n        ? AbortSignal.any([\n            dynamicAccessAbortSignal,\n            outerWorkUnitStore.renderSignal,\n            timeoutAbortController.signal,\n          ])\n        : timeoutAbortController.signal\n\n      const { prelude } = await prerender(\n        resultPromise,\n        clientReferenceManifest.clientModules,\n        {\n          environmentName: 'Cache',\n          filterStackFrame,\n          signal: abortSignal,\n          temporaryReferences,\n          onError(error) {\n            if (abortSignal.aborted && abortSignal.reason === error) {\n              return undefined\n            }\n\n            return handleError(error)\n          },\n        }\n      )\n\n      clearTimeout(timer)\n\n      if (timeoutAbortController.signal.aborted) {\n        // When the timeout is reached we always error the stream. Even for\n        // fallback shell prerenders we don't want to return a hanging promise,\n        // which would allow the function to become a dynamic hole. Because that\n        // would mean that a non-empty shell could be generated which would be\n        // subject to revalidation, and we don't want to create long\n        // revalidation times.\n        stream = new ReadableStream({\n          start(controller) {\n            controller.error(timeoutAbortController.signal.reason)\n          },\n        })\n      } else if (dynamicAccessAbortSignal?.aborted) {\n        // If the prerender is aborted because of dynamic access (e.g. reading\n        // fallback params), we return a hanging promise. This essentially makes\n        // the \"use cache\" function dynamic.\n        const hangingPromise = makeHangingPromise<never>(\n          outerWorkUnitStore.renderSignal,\n          workStore.route,\n          'dynamic \"use cache\"'\n        )\n\n        if (outerWorkUnitStore.cacheSignal) {\n          outerWorkUnitStore.cacheSignal.endRead()\n        }\n\n        return { type: 'prerender-dynamic', hangingPromise }\n      } else {\n        stream = prelude\n      }\n      break\n    case 'request':\n      // If we're filling caches for a staged render, make sure that\n      // it takes at least a task, so we'll always notice a cache miss between stages.\n      //\n      // TODO(restart-on-cache-miss): This is suboptimal.\n      // Ideally we wouldn't need to restart for microtasky caches,\n      // but the current logic for omitting short-lived caches only works correctly\n      // if we do a second render, so that's the best we can do until we refactor that.\n      if (\n        process.env.NODE_ENV === 'development' &&\n        outerWorkUnitStore.cacheSignal\n      ) {\n        await new Promise((resolve) => setTimeout(resolve))\n      }\n    // fallthrough\n    case 'prerender-ppr':\n    case 'prerender-legacy':\n    case 'cache':\n    case 'private-cache':\n    case 'unstable-cache':\n    case undefined:\n      stream = renderToReadableStream(\n        resultPromise,\n        clientReferenceManifest.clientModules,\n        {\n          environmentName: 'Cache',\n          filterStackFrame,\n          temporaryReferences,\n          onError: handleError,\n        }\n      )\n      break\n    default:\n      return outerWorkUnitStore satisfies never\n  }\n\n  const [returnStream, savedStream] = stream.tee()\n\n  const pendingCacheEntry = collectResult(\n    savedStream,\n    workStore,\n    cacheContext,\n    innerCacheStore,\n    startTime,\n    errors\n  )\n\n  if (process.env.NODE_ENV === 'development') {\n    // Name the stream for React DevTools.\n    // @ts-expect-error\n    returnStream.name = 'use cache'\n  }\n\n  return {\n    type: 'cached',\n    // Return the stream as we're creating it. This means that if it ends up\n    // erroring we cannot return a stale-if-error version but it allows\n    // streaming back the result earlier.\n    stream: returnStream,\n    pendingCacheEntry,\n  }\n}\n\nfunction cloneCacheEntry(entry: CacheEntry): [CacheEntry, CacheEntry] {\n  const [streamA, streamB] = entry.value.tee()\n  entry.value = streamA\n  const clonedEntry: CacheEntry = {\n    value: streamB,\n    timestamp: entry.timestamp,\n    revalidate: entry.revalidate,\n    expire: entry.expire,\n    stale: entry.stale,\n    tags: entry.tags,\n  }\n  return [entry, clonedEntry]\n}\n\nasync function clonePendingCacheEntry(\n  pendingCacheEntry: Promise<CacheEntry>\n): Promise<[CacheEntry, CacheEntry]> {\n  const entry = await pendingCacheEntry\n  return cloneCacheEntry(entry)\n}\n\nasync function getNthCacheEntry(\n  split: Promise<[CacheEntry, CacheEntry]>,\n  i: number\n): Promise<CacheEntry> {\n  return (await split)[i]\n}\n\nasync function encodeFormData(formData: FormData): Promise<string> {\n  let result = ''\n  for (let [key, value] of formData) {\n    // We don't need this key to be serializable but from a security perspective it should not be\n    // possible to generate a string that looks the same from a different structure. To ensure this\n    // we need a delimeter between fields but just using a delimeter is not enough since a string\n    // might contain that delimeter. We use the length of each field as the delimeter to avoid\n    // escaping the values.\n    result += key.length.toString(16) + ':' + key\n    let stringValue\n    if (typeof value === 'string') {\n      stringValue = value\n    } else {\n      // The FormData might contain binary data that is not valid UTF-8 so this cache\n      // key may generate a UCS-2 string. Passing this to another service needs to be\n      // aware that the key might not be compatible.\n      const arrayBuffer = await value.arrayBuffer()\n      if (arrayBuffer.byteLength % 2 === 0) {\n        stringValue = String.fromCodePoint(...new Uint16Array(arrayBuffer))\n      } else {\n        stringValue =\n          String.fromCodePoint(\n            ...new Uint16Array(arrayBuffer, 0, (arrayBuffer.byteLength - 1) / 2)\n          ) +\n          String.fromCodePoint(\n            new Uint8Array(arrayBuffer, arrayBuffer.byteLength - 1, 1)[0]\n          )\n      }\n    }\n    result += stringValue.length.toString(16) + ':' + stringValue\n  }\n  return result\n}\n\nfunction createTrackedReadableStream(\n  stream: ReadableStream,\n  cacheSignal: CacheSignal\n) {\n  const reader = stream.getReader()\n  return new ReadableStream({\n    async pull(controller) {\n      const { done, value } = await reader.read()\n      if (done) {\n        controller.close()\n        cacheSignal.endRead()\n      } else {\n        controller.enqueue(value)\n      }\n    },\n  })\n}\n\nexport async function cache(\n  kind: string,\n  id: string,\n  boundArgsLength: number,\n  originalFn: (...args: unknown[]) => Promise<unknown>,\n  argsObj: IArguments\n) {\n  let args = Array.prototype.slice.call(argsObj)\n\n  const isPrivate = kind === 'private'\n\n  // Private caches are currently only stored in the Resume Data Cache (RDC),\n  // and not in cache handlers.\n  const cacheHandler = isPrivate ? undefined : getCacheHandler(kind)\n\n  if (!isPrivate && !cacheHandler) {\n    throw new Error('Unknown cache handler: ' + kind)\n  }\n\n  const timeoutError = new UseCacheTimeoutError()\n  Error.captureStackTrace(timeoutError, cache)\n\n  const wrapAsInvalidDynamicUsageError = (\n    error: Error,\n    workStore: WorkStore\n  ) => {\n    Error.captureStackTrace(error, cache)\n    workStore.invalidDynamicUsageError ??= error\n\n    return error\n  }\n\n  const workStore = workAsyncStorage.getStore()\n  if (workStore === undefined) {\n    throw new Error(\n      '\"use cache\" cannot be used outside of App Router. Expected a WorkStore.'\n    )\n  }\n\n  const workUnitStore = workUnitAsyncStorage.getStore()\n  const name = originalFn.name\n  let fn = originalFn\n  let cacheContext: CacheContext\n\n  if (isPrivate) {\n    const expression = '\"use cache: private\"'\n\n    switch (workUnitStore?.type) {\n      // \"use cache: private\" is dynamic in prerendering contexts.\n      case 'prerender':\n        return makeHangingPromise(\n          workUnitStore.renderSignal,\n          workStore.route,\n          expression\n        )\n      case 'prerender-ppr':\n        return postponeWithTracking(\n          workStore.route,\n          expression,\n          workUnitStore.dynamicTracking\n        )\n      case 'prerender-legacy':\n        return throwToInterruptStaticGeneration(\n          expression,\n          workStore,\n          workUnitStore\n        )\n      case 'prerender-client':\n        throw new InvariantError(\n          `${expression} must not be used within a client component. Next.js should be preventing ${expression} from being allowed in client components statically, but did not in this case.`\n        )\n      case 'unstable-cache': {\n        throw wrapAsInvalidDynamicUsageError(\n          new Error(\n            // TODO: Add a link to an error documentation page when we have one.\n            `${expression} must not be used within \\`unstable_cache()\\`.`\n          ),\n          workStore\n        )\n      }\n      case 'cache': {\n        throw wrapAsInvalidDynamicUsageError(\n          new Error(\n            // TODO: Add a link to an error documentation page when we have one.\n            `${expression} must not be used within \"use cache\". It can only be nested inside of another ${expression}.`\n          ),\n          workStore\n        )\n      }\n      case 'request':\n      case 'prerender-runtime':\n      case 'private-cache':\n        cacheContext = {\n          kind: 'private',\n          outerWorkUnitStore: workUnitStore,\n        }\n        break\n      case undefined:\n        throw wrapAsInvalidDynamicUsageError(\n          new Error(\n            // TODO: Add a link to an error documentation page when we have one.\n            `${expression} cannot be used outside of a request context.`\n          ),\n          workStore\n        )\n      default:\n        workUnitStore satisfies never\n        // This is dead code, but without throwing an error here, TypeScript\n        // will assume that cacheContext is used before being assigned.\n        throw new InvariantError(`Unexpected work unit store.`)\n    }\n  } else {\n    switch (workUnitStore?.type) {\n      case 'prerender-client':\n        const expression = '\"use cache\"'\n        throw new InvariantError(\n          `${expression} must not be used within a client component. Next.js should be preventing ${expression} from being allowed in client components statically, but did not in this case.`\n        )\n      case 'prerender':\n      case 'prerender-runtime':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'request':\n      case 'cache':\n      case 'private-cache':\n      // TODO: We should probably forbid nesting \"use cache\" inside\n      // unstable_cache. (fallthrough)\n      case 'unstable-cache':\n      case undefined:\n        cacheContext = {\n          kind: 'public',\n          outerWorkUnitStore: workUnitStore,\n        }\n        break\n      default:\n        workUnitStore satisfies never\n        // This is dead code, but without throwing an error here, TypeScript\n        // will assume that cacheContext is used before being assigned.\n        throw new InvariantError(`Unexpected work unit store.`)\n    }\n  }\n\n  // Get the clientReferenceManifest while we're still in the outer Context.\n  // In case getClientReferenceManifestSingleton is implemented using AsyncLocalStorage.\n  const clientReferenceManifest = getClientReferenceManifest()\n\n  // Because the Action ID is not yet unique per implementation of that Action we can't\n  // safely reuse the results across builds yet. In the meantime we add the buildId to the\n  // arguments as a seed to ensure they're not reused. Remove this once Action IDs hash\n  // the implementation.\n  const buildId = workStore.buildId\n\n  // In dev mode, when the HMR refresh hash is set, we include it in the\n  // cache key. This ensures that cache entries are not reused when server\n  // components have been edited. This is a very coarse approach. But it's\n  // also only a temporary solution until Action IDs are unique per\n  // implementation. Remove this once Action IDs hash the implementation.\n  const hmrRefreshHash =\n    workUnitStore && getHmrRefreshHash(workStore, workUnitStore)\n\n  const hangingInputAbortSignal = workUnitStore\n    ? createHangingInputAbortSignal(workUnitStore)\n    : undefined\n\n  if (cacheContext.kind === 'private') {\n    const { outerWorkUnitStore } = cacheContext\n    switch (outerWorkUnitStore.type) {\n      case 'prerender-runtime': {\n        // In a runtime prerender, we have to make sure that APIs that would hang during a static prerender\n        // are resolved with a delay, in the runtime stage. Private caches are one of these.\n        if (outerWorkUnitStore.runtimeStagePromise) {\n          await outerWorkUnitStore.runtimeStagePromise\n        }\n        break\n      }\n      case 'request': {\n        if (process.env.NODE_ENV === 'development') {\n          // Similar to runtime prerenders, private caches should not resolve in the static stage\n          // of a dev request, so we delay them.\n          await makeDevtoolsIOAwarePromise(\n            undefined,\n            outerWorkUnitStore,\n            RenderStage.Runtime\n          )\n        }\n        break\n      }\n      case 'private-cache':\n        break\n      default: {\n        outerWorkUnitStore satisfies never\n      }\n    }\n  }\n\n  let isPageOrLayoutSegmentFunction = false\n\n  // For page and layout segment functions (i.e. the page/layout component,\n  // or generateMetadata/generateViewport), the cache function is\n  // overwritten, which allows us to apply special handling for params and\n  // searchParams. For pages and layouts we're using the outer params prop,\n  // and not the inner one that was serialized/deserialized. While it's not\n  // generally true for \"use cache\" args, in the case of `params` the inner\n  // and outer object are essentially equivalent, so this is safe to do\n  // (including fallback params that are hanging promises). It allows us to\n  // avoid waiting for the timeout, when prerendering a fallback shell of a\n  // cached page or layout that awaits params.\n  if (isPageSegmentFunction(args)) {\n    isPageOrLayoutSegmentFunction = true\n\n    const [\n      { params: outerParams, searchParams: outerSearchParams },\n      ...otherOuterArgs\n    ] = args\n\n    const props: UseCachePageInnerProps = {\n      params: outerParams,\n      // Omit searchParams and $$isPage.\n    }\n\n    if (isPrivate) {\n      // Private caches allow accessing search params. We need to include\n      // them in the serialized args and when generating the cache key.\n      props.searchParams = outerSearchParams\n    }\n\n    args = [props, ...otherOuterArgs]\n\n    fn = {\n      [name]: async (\n        {\n          params: _innerParams,\n          searchParams: innerSearchParams,\n        }: UseCachePageInnerProps,\n        ...otherInnerArgs: unknown[]\n      ) =>\n        originalFn.apply(null, [\n          {\n            params: outerParams,\n            searchParams:\n              innerSearchParams ??\n              // For public caches, search params are omitted from the cache\n              // key (and the serialized args) to avoid mismatches between\n              // prerendering and resuming a cached page that does not\n              // access search params. This is also the reason why we're not\n              // using a hanging promise for search params. For cached pages\n              // that do access them, which is an invalid dynamic usage, we\n              // need to ensure that an error is shown.\n              makeErroringSearchParamsForUseCache(workStore),\n          },\n          ...otherInnerArgs,\n        ]),\n    }[name] as (...args: unknown[]) => Promise<unknown>\n  } else if (isLayoutSegmentFunction(args)) {\n    isPageOrLayoutSegmentFunction = true\n\n    const [\n      { params: outerParams, $$isLayout, ...outerSlots },\n      ...otherOuterArgs\n    ] = args\n\n    // Overwrite the props to omit $$isLayout. Note that slots are only\n    // passed to the layout component (if any are defined), and not to\n    // generateMetadata nor generateViewport. For those functions,\n    // outerSlots/innerSlots is an empty object, which is fine because we're\n    // just spreading it into the props.\n    args = [{ params: outerParams, ...outerSlots }, ...otherOuterArgs]\n\n    fn = {\n      [name]: async (\n        {\n          params: _innerParams,\n          ...innerSlots\n        }: Omit<UseCacheLayoutProps, '$$isLayout'>,\n        ...otherInnerArgs: unknown[]\n      ) =>\n        originalFn.apply(null, [\n          { params: outerParams, ...innerSlots },\n          ...otherInnerArgs,\n        ]),\n    }[name] as (...args: unknown[]) => Promise<unknown>\n  }\n\n  if (boundArgsLength > 0) {\n    if (args.length === 0) {\n      throw new InvariantError(\n        `Expected the \"use cache\" function ${JSON.stringify(fn.name)} to receive its encrypted bound arguments as the first argument.`\n      )\n    }\n\n    const encryptedBoundArgs = args.shift()\n    const boundArgs = await decryptActionBoundArgs(id, encryptedBoundArgs)\n\n    if (!Array.isArray(boundArgs)) {\n      throw new InvariantError(\n        `Expected the bound arguments of \"use cache\" function ${JSON.stringify(fn.name)} to deserialize into an array, got ${typeof boundArgs} instead.`\n      )\n    }\n\n    if (boundArgsLength !== boundArgs.length) {\n      throw new InvariantError(\n        `Expected the \"use cache\" function ${JSON.stringify(fn.name)} to receive ${boundArgsLength} bound arguments, got ${boundArgs.length} instead.`\n      )\n    }\n\n    args.unshift(boundArgs)\n  }\n\n  const temporaryReferences = createClientTemporaryReferenceSet()\n\n  // For private caches, which are allowed to read cookies, we still don't\n  // need to include the cookies in the cache key. This is because we don't\n  // store the cache entries in a cache handler, but only in the Resume Data\n  // Cache (RDC). Private caches are only used during dynamic requests and\n  // runtime prefetches. For dynamic requests, the RDC is immutable, so it\n  // does not include any private caches. For runtime prefetches, the RDC is\n  // mutable, but only lives as long as the request, so the key does not\n  // need to include cookies.\n  const cacheKeyParts: CacheKeyParts = hmrRefreshHash\n    ? [buildId, id, args, hmrRefreshHash]\n    : [buildId, id, args]\n\n  const encodeCacheKeyParts = () =>\n    encodeReply(cacheKeyParts, {\n      temporaryReferences,\n      signal: hangingInputAbortSignal,\n    })\n\n  let encodedCacheKeyParts: FormData | string\n\n  switch (workUnitStore?.type) {\n    case 'prerender-runtime':\n    // We're currently only using `dynamicAccessAsyncStorage` for params,\n    // which are always available in a runtime prerender, so they will never hang,\n    // effectively making the tracking below a no-op.\n    // However, a runtime prerender shares a lot of the semantics with a static prerender,\n    // and might need to follow this codepath in the future\n    // if we start using `dynamicAccessAsyncStorage` for other APIs.\n    //\n    // fallthrough\n    case 'prerender':\n      if (!isPageOrLayoutSegmentFunction) {\n        // If the \"use cache\" function is not a page or layout segment\n        // function, we need to track dynamic access already when encoding\n        // the arguments. If params are passed explicitly into a \"use cache\"\n        // function (as opposed to receiving them automatically in a page or\n        // layout), we assume that the params are also accessed. This allows\n        // us to abort early, and treat the function as dynamic, instead of\n        // waiting for the timeout to be reached.\n        const dynamicAccessAbortController = new AbortController()\n\n        encodedCacheKeyParts = await dynamicAccessAsyncStorage.run(\n          { abortController: dynamicAccessAbortController },\n          encodeCacheKeyParts\n        )\n\n        if (dynamicAccessAbortController.signal.aborted) {\n          return makeHangingPromise(\n            workUnitStore.renderSignal,\n            workStore.route,\n            'dynamic \"use cache\"'\n          )\n        }\n        break\n      }\n    // fallthrough\n    case 'prerender-ppr':\n    case 'prerender-legacy':\n    case 'request':\n    // TODO(restart-on-cache-miss): We need to handle params/searchParams on page components.\n    // the promises will be tasky, so `encodeCacheKeyParts` will not resolve in the static stage.\n    // We have not started a cache read at this point, so we might just miss the cache completely.\n    // fallthrough\n    case 'cache':\n    case 'private-cache':\n    case 'unstable-cache':\n    case undefined:\n      encodedCacheKeyParts = await encodeCacheKeyParts()\n      break\n    default:\n      return workUnitStore satisfies never\n  }\n\n  const serializedCacheKey =\n    typeof encodedCacheKeyParts === 'string'\n      ? // Fast path for the simple case for simple inputs. We let the CacheHandler\n        // Convert it to an ArrayBuffer if it wants to.\n        encodedCacheKeyParts\n      : await encodeFormData(encodedCacheKeyParts)\n\n  let stream: undefined | ReadableStream = undefined\n\n  // Get an immutable and mutable versions of the resume data cache.\n  const prerenderResumeDataCache = workUnitStore\n    ? getPrerenderResumeDataCache(workUnitStore)\n    : null\n  const renderResumeDataCache = workUnitStore\n    ? getRenderResumeDataCache(workUnitStore)\n    : null\n\n  if (renderResumeDataCache) {\n    const cacheSignal = workUnitStore ? getCacheSignal(workUnitStore) : null\n\n    if (cacheSignal) {\n      cacheSignal.beginRead()\n    }\n    const cachedEntry = renderResumeDataCache.cache.get(serializedCacheKey)\n    if (cachedEntry !== undefined) {\n      const existingEntry = await cachedEntry\n      if (workUnitStore !== undefined && existingEntry !== undefined) {\n        if (\n          existingEntry.revalidate === 0 ||\n          existingEntry.expire < DYNAMIC_EXPIRE\n        ) {\n          switch (workUnitStore.type) {\n            case 'prerender':\n              // In a Dynamic I/O prerender, if the cache entry has\n              // revalidate: 0 or if the expire time is under 5 minutes,\n              // then we consider this cache entry dynamic as it's not worth\n              // generating static pages for such data. It's better to leave\n              // a dynamic hole that can be filled in during the resume with\n              // a potentially cached entry.\n              if (cacheSignal) {\n                cacheSignal.endRead()\n              }\n              return makeHangingPromise(\n                workUnitStore.renderSignal,\n                workStore.route,\n                'dynamic \"use cache\"'\n              )\n            case 'prerender-runtime': {\n              // In the final phase of a runtime prerender, we have to make\n              // sure that APIs that would hang during a static prerender\n              // are resolved with a delay, in the runtime stage.\n              if (workUnitStore.runtimeStagePromise) {\n                await workUnitStore.runtimeStagePromise\n              }\n              break\n            }\n            case 'request': {\n              if (process.env.NODE_ENV === 'development') {\n                // We delay the cache here so that it doesn't resolve in the static task --\n                // in a regular static prerender, it'd be a hanging promise, and we need to reflect that,\n                // so it has to resolve later.\n                // TODO(restart-on-cache-miss): Optimize this to avoid unnecessary restarts.\n                // We don't end the cache read here, so this will always appear as a cache miss in the static stage,\n                // and thus will cause a restart even if all caches are filled.\n                await makeDevtoolsIOAwarePromise(\n                  undefined,\n                  workUnitStore,\n                  RenderStage.Runtime\n                )\n              }\n              break\n            }\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'cache':\n            case 'private-cache':\n            case 'unstable-cache':\n              break\n            default:\n              workUnitStore satisfies never\n          }\n        }\n\n        if (existingEntry.stale < RUNTIME_PREFETCH_DYNAMIC_STALE) {\n          switch (workUnitStore.type) {\n            case 'prerender-runtime':\n              // In a runtime prerender, if the cache entry will become\n              // stale in less then 30 seconds, we consider this cache entry\n              // dynamic as it's not worth prefetching. It's better to leave\n              // a dynamic hole that can be filled during the navigation.\n              if (cacheSignal) {\n                cacheSignal.endRead()\n              }\n              return makeHangingPromise(\n                workUnitStore.renderSignal,\n                workStore.route,\n                'dynamic \"use cache\"'\n              )\n            case 'request': {\n              if (process.env.NODE_ENV === 'development') {\n                // We delay the cache here so that it doesn't resolve in the runtime phase --\n                // in a regular runtime prerender, it'd be a hanging promise, and we need to reflect that,\n                // so it has to resolve later.\n                // TODO(restart-on-cache-miss): Optimize this to avoid unnecessary restarts.\n                // We don't end the cache read here, so this will always appear as a cache miss in the runtime stage,\n                // and thus will cause a restart even if all caches are filled.\n                await makeDevtoolsIOAwarePromise(\n                  undefined,\n                  workUnitStore,\n                  RenderStage.Dynamic\n                )\n              }\n              break\n            }\n            case 'prerender':\n            case 'prerender-ppr':\n            case 'prerender-legacy':\n            case 'cache':\n            case 'private-cache':\n            case 'unstable-cache':\n              break\n            default:\n              workUnitStore satisfies never\n          }\n        }\n      }\n\n      // We want to make sure we only propagate cache life & tags if the\n      // entry was *not* omitted from the prerender. So we only do this\n      // after the above early returns.\n      propagateCacheLifeAndTags(cacheContext, existingEntry)\n\n      const [streamA, streamB] = existingEntry.value.tee()\n      existingEntry.value = streamB\n\n      if (cacheSignal) {\n        // When we have a cacheSignal we need to block on reading the cache\n        // entry before ending the read.\n        stream = createTrackedReadableStream(streamA, cacheSignal)\n      } else {\n        stream = streamA\n      }\n    } else {\n      if (cacheSignal) {\n        cacheSignal.endRead()\n      }\n\n      if (workUnitStore) {\n        switch (workUnitStore.type) {\n          case 'prerender':\n            // If `allowEmptyStaticShell` is true, and thus a prefilled\n            // resume data cache was provided, then a cache miss means that\n            // params were part of the cache key. In this case, we can make\n            // this cache function a dynamic hole in the shell (or produce\n            // an empty shell if there's no parent suspense boundary).\n            // Currently, this also includes layouts and pages that don't\n            // read params, which will be improved when we implement\n            // NAR-136. Otherwise, we assume that if params are passed\n            // explicitly into a \"use cache\" function, that the params are\n            // also accessed. This allows us to abort early, and treat the\n            // function as dynamic, instead of waiting for the timeout to be\n            // reached. Compared to the instrumentation-based params bailout\n            // we do here, this also covers the case where params are\n            // transformed with an async function, before being passed into\n            // the \"use cache\" function, which escapes the instrumentation.\n            if (workUnitStore.allowEmptyStaticShell) {\n              return makeHangingPromise(\n                workUnitStore.renderSignal,\n                workStore.route,\n                'dynamic \"use cache\"'\n              )\n            }\n            break\n          case 'prerender-runtime':\n          case 'prerender-ppr':\n          case 'prerender-legacy':\n          case 'request':\n          case 'cache':\n          case 'private-cache':\n          case 'unstable-cache':\n            break\n          default:\n            workUnitStore satisfies never\n        }\n      }\n    }\n  }\n\n  if (stream === undefined) {\n    const cacheSignal = workUnitStore ? getCacheSignal(workUnitStore) : null\n    if (cacheSignal) {\n      // Either the cache handler or the generation can be using I/O at this point.\n      // We need to track when they start and when they complete.\n      cacheSignal.beginRead()\n    }\n\n    const lazyRefreshTags = workStore.refreshTagsByCacheKind.get(kind)\n\n    if (lazyRefreshTags && !isResolvedLazyResult(lazyRefreshTags)) {\n      await lazyRefreshTags\n    }\n\n    let entry: CacheEntry | undefined\n\n    // We ignore existing cache entries when force revalidating.\n    if (cacheHandler && !shouldForceRevalidate(workStore, workUnitStore)) {\n      entry = await cacheHandler.get(\n        serializedCacheKey,\n        workUnitStore?.implicitTags?.tags ?? []\n      )\n    }\n\n    if (entry) {\n      const implicitTags = workUnitStore?.implicitTags?.tags ?? []\n      let implicitTagsExpiration = 0\n\n      if (workUnitStore?.implicitTags) {\n        const lazyExpiration =\n          workUnitStore.implicitTags.expirationsByCacheKind.get(kind)\n\n        if (lazyExpiration) {\n          const expiration = isResolvedLazyResult(lazyExpiration)\n            ? lazyExpiration.value\n            : await lazyExpiration\n\n          // If a cache handler returns an expiration time of Infinity, it\n          // signals to Next.js that it handles checking cache entries for\n          // staleness based on the expiration of the implicit tags passed\n          // into the `get` method. In this case, we keep the default of 0,\n          // which means that the implicit tags are not considered expired.\n          if (expiration < Infinity) {\n            implicitTagsExpiration = expiration\n          }\n        }\n      }\n\n      if (\n        shouldDiscardCacheEntry(\n          entry,\n          workStore,\n          workUnitStore,\n          implicitTags,\n          implicitTagsExpiration\n        )\n      ) {\n        debug?.('discarding expired entry', serializedCacheKey)\n        entry = undefined\n      }\n    }\n\n    const currentTime = performance.timeOrigin + performance.now()\n    if (\n      workUnitStore !== undefined &&\n      entry !== undefined &&\n      (entry.revalidate === 0 || entry.expire < DYNAMIC_EXPIRE)\n    ) {\n      switch (workUnitStore.type) {\n        case 'prerender':\n          // In a Dynamic I/O prerender, if the cache entry has revalidate:\n          // 0 or if the expire time is under 5 minutes, then we consider\n          // this cache entry dynamic as it's not worth generating static\n          // pages for such data. It's better to leave a dynamic hole that\n          // can be filled in during the resume with a potentially cached\n          // entry.\n          if (cacheSignal) {\n            cacheSignal.endRead()\n          }\n          return makeHangingPromise(\n            workUnitStore.renderSignal,\n            workStore.route,\n            'dynamic \"use cache\"'\n          )\n        case 'request': {\n          if (process.env.NODE_ENV === 'development') {\n            // We delay the cache here so that it doesn't resolve in the static task --\n            // in a regular static prerender, it'd be a hanging promise, and we need to reflect that,\n            // so it has to resolve later.\n            // TODO(restart-on-cache-miss): Optimize this to avoid unnecessary restarts.\n            // We don't end the cache read here, so this will always appear as a cache miss in the static stage,\n            // and thus will cause a restart even if all caches are filled.\n            await makeDevtoolsIOAwarePromise(\n              undefined,\n              workUnitStore,\n              RenderStage.Runtime\n            )\n          }\n          break\n        }\n        case 'prerender-runtime':\n        case 'prerender-ppr':\n        case 'prerender-legacy':\n        case 'cache':\n        case 'private-cache':\n        case 'unstable-cache':\n          break\n        default:\n          workUnitStore satisfies never\n      }\n    }\n\n    if (\n      entry === undefined ||\n      currentTime > entry.timestamp + entry.expire * 1000 ||\n      (workStore.isStaticGeneration &&\n        currentTime > entry.timestamp + entry.revalidate * 1000)\n    ) {\n      // Miss. Generate a new result.\n\n      // If the cache entry is stale and we're prerendering, we don't want to use the\n      // stale entry since it would unnecessarily need to shorten the lifetime of the\n      // prerender. We're not time constrained here so we can re-generated it now.\n\n      // We need to run this inside a clean AsyncLocalStorage snapshot so that the cache\n      // generation cannot read anything from the context we're currently executing which\n      // might include request specific things like cookies() inside a React.cache().\n      // Note: It is important that we await at least once before this because it lets us\n      // pop out of any stack specific contexts as well - aka \"Sync\" Local Storage.\n\n      if (entry) {\n        if (currentTime > entry.timestamp + entry.expire * 1000) {\n          debug?.('entry is expired', serializedCacheKey)\n        }\n\n        if (\n          workStore.isStaticGeneration &&\n          currentTime > entry.timestamp + entry.revalidate * 1000\n        ) {\n          debug?.('static generation, entry is stale', serializedCacheKey)\n        }\n      }\n\n      const result = await generateCacheEntry(\n        workStore,\n        cacheContext,\n        clientReferenceManifest,\n        encodedCacheKeyParts,\n        fn,\n        timeoutError\n      )\n\n      if (result.type === 'prerender-dynamic') {\n        return result.hangingPromise\n      }\n\n      const { stream: newStream, pendingCacheEntry } = result\n\n      // When draft mode is enabled, we must not save the cache entry.\n      if (!workStore.isDraftMode) {\n        let savedCacheEntry\n\n        if (prerenderResumeDataCache) {\n          // Create a clone that goes into the cache scope memory cache.\n          const split = clonePendingCacheEntry(pendingCacheEntry)\n          savedCacheEntry = getNthCacheEntry(split, 0)\n          prerenderResumeDataCache.cache.set(\n            serializedCacheKey,\n            getNthCacheEntry(split, 1)\n          )\n        } else {\n          savedCacheEntry = pendingCacheEntry\n        }\n\n        if (cacheHandler) {\n          const promise = cacheHandler.set(serializedCacheKey, savedCacheEntry)\n\n          workStore.pendingRevalidateWrites ??= []\n          workStore.pendingRevalidateWrites.push(promise)\n        }\n      }\n\n      stream = newStream\n    } else {\n      // If we have an entry at this point, this can't be a private cache\n      // entry.\n      if (cacheContext.kind === 'private') {\n        throw new InvariantError(\n          `A private cache entry must not be retrieved from the cache handler.`\n        )\n      }\n\n      propagateCacheLifeAndTags(cacheContext, entry)\n\n      // We want to return this stream, even if it's stale.\n      stream = entry.value\n\n      // If we have a cache scope, we need to clone the entry and set it on\n      // the inner cache scope.\n      if (prerenderResumeDataCache) {\n        const [entryLeft, entryRight] = cloneCacheEntry(entry)\n        if (cacheSignal) {\n          stream = createTrackedReadableStream(entryLeft.value, cacheSignal)\n        } else {\n          stream = entryLeft.value\n        }\n\n        prerenderResumeDataCache.cache.set(\n          serializedCacheKey,\n          Promise.resolve(entryRight)\n        )\n      } else {\n        // If we're not regenerating we need to signal that we've finished\n        // putting the entry into the cache scope at this point. Otherwise we do\n        // that inside generateCacheEntry.\n        cacheSignal?.endRead()\n      }\n\n      if (currentTime > entry.timestamp + entry.revalidate * 1000) {\n        // If this is stale, and we're not in a prerender (i.e. this is\n        // dynamic render), then we should warm up the cache with a fresh\n        // revalidated entry.\n        const result = await generateCacheEntry(\n          workStore,\n          // This is not running within the context of this unit.\n          { kind: cacheContext.kind, outerWorkUnitStore: undefined },\n          clientReferenceManifest,\n          encodedCacheKeyParts,\n          fn,\n          timeoutError\n        )\n\n        if (result.type === 'cached') {\n          const { stream: ignoredStream, pendingCacheEntry } = result\n          let savedCacheEntry: Promise<CacheEntry>\n\n          if (prerenderResumeDataCache) {\n            const split = clonePendingCacheEntry(pendingCacheEntry)\n            savedCacheEntry = getNthCacheEntry(split, 0)\n            prerenderResumeDataCache.cache.set(\n              serializedCacheKey,\n              getNthCacheEntry(split, 1)\n            )\n          } else {\n            savedCacheEntry = pendingCacheEntry\n          }\n\n          if (cacheHandler) {\n            const promise = cacheHandler.set(\n              serializedCacheKey,\n              savedCacheEntry\n            )\n\n            workStore.pendingRevalidateWrites ??= []\n            workStore.pendingRevalidateWrites.push(promise)\n          }\n\n          await ignoredStream.cancel()\n        }\n      }\n    }\n  }\n\n  // Logs are replayed even if it's a hit - to ensure we see them on the client eventually.\n  // If we didn't then the client wouldn't see the logs if it was seeded from a prewarm that\n  // never made it to the client. However, this also means that you see logs even when the\n  // cached function isn't actually re-executed. We should instead ensure prewarms always\n  // make it to the client. Another issue is that this will cause double logging in the\n  // server terminal. Once while generating the cache entry and once when replaying it on\n  // the server, which is required to pick it up for replaying again on the client.\n  const replayConsoleLogs = true\n\n  const serverConsumerManifest = {\n    // moduleLoading must be null because we don't want to trigger preloads of ClientReferences\n    // to be added to the consumer. Instead, we'll wait for any ClientReference to be emitted\n    // which themselves will handle the preloading.\n    moduleLoading: null,\n    moduleMap: isEdgeRuntime\n      ? clientReferenceManifest.edgeRscModuleMapping\n      : clientReferenceManifest.rscModuleMapping,\n    serverModuleMap: getServerModuleMap(),\n  }\n\n  return createFromReadableStream(stream, {\n    findSourceMapURL,\n    serverConsumerManifest,\n    temporaryReferences,\n    replayConsoleLogs,\n    environmentName: 'Cache',\n  })\n}\n\n/**\n * Returns `true` if the `'use cache'` function is the page component itself,\n * or `generateMetadata`/`generateViewport` in a page file.\n */\nfunction isPageSegmentFunction(\n  args: any[]\n): args is [UseCachePageProps, ...unknown[]] {\n  const [maybeProps] = args\n\n  return (\n    maybeProps !== null &&\n    typeof maybeProps === 'object' &&\n    (maybeProps as UseCachePageProps).$$isPage === true\n  )\n}\n\n/**\n * Returns `true` if the `'use cache'` function is the layout component itself,\n * or `generateMetadata`/`generateViewport` in a layout file.\n */\nfunction isLayoutSegmentFunction(\n  args: any[]\n): args is [UseCacheLayoutProps, ...unknown[]] {\n  const [maybeProps] = args\n\n  return (\n    maybeProps !== null &&\n    typeof maybeProps === 'object' &&\n    (maybeProps as UseCacheLayoutProps).$$isLayout === true\n  )\n}\n\nfunction shouldForceRevalidate(\n  workStore: WorkStore,\n  workUnitStore: WorkUnitStore | undefined\n): boolean {\n  if (workStore.isOnDemandRevalidate || workStore.isDraftMode) {\n    return true\n  }\n\n  if (workStore.dev && workUnitStore) {\n    switch (workUnitStore.type) {\n      case 'request':\n        return workUnitStore.headers.get('cache-control') === 'no-cache'\n      case 'cache':\n      case 'private-cache':\n        return workUnitStore.forceRevalidate\n      case 'prerender-runtime':\n      case 'prerender':\n      case 'prerender-client':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'unstable-cache':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n\n  return false\n}\n\nfunction shouldDiscardCacheEntry(\n  entry: CacheEntry,\n  workStore: WorkStore,\n  workUnitStore: WorkUnitStore | undefined,\n  implicitTags: string[],\n  implicitTagsExpiration: number\n): boolean {\n  // If the cache entry was created before any of the implicit tags were\n  // revalidated last, we need to discard it.\n  if (entry.timestamp <= implicitTagsExpiration) {\n    debug?.(\n      'entry was created at',\n      entry.timestamp,\n      'before implicit tags were revalidated at',\n      implicitTagsExpiration\n    )\n\n    return true\n  }\n\n  // During prerendering, we ignore recently revalidated tags. In dev mode, we\n  // can assume that the dynamic dev rendering will have discarded and recreated\n  // the affected cache entries, and we don't want to discard those again during\n  // the prerender validation. During build-time prerendering, there will never\n  // be any pending revalidated tags.\n  if (workUnitStore) {\n    switch (workUnitStore.type) {\n      case 'prerender':\n        return false\n      case 'prerender-runtime':\n      case 'prerender-client':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'request':\n      case 'cache':\n      case 'private-cache':\n      case 'unstable-cache':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n\n  // If the cache entry contains revalidated tags that the cache handler might\n  // not know about yet, we need to discard it.\n  if (entry.tags.some((tag) => isRecentlyRevalidatedTag(tag, workStore))) {\n    return true\n  }\n\n  // Finally, if any of the implicit tags have been revalidated recently, we\n  // also need to discard the cache entry.\n  if (implicitTags.some((tag) => isRecentlyRevalidatedTag(tag, workStore))) {\n    return true\n  }\n\n  return false\n}\n\nfunction isRecentlyRevalidatedTag(tag: string, workStore: WorkStore): boolean {\n  const { previouslyRevalidatedTags, pendingRevalidatedTags } = workStore\n\n  // Was the tag previously revalidated (e.g. by a redirecting server action)?\n  if (previouslyRevalidatedTags.includes(tag)) {\n    debug?.('tag', tag, 'was previously revalidated')\n\n    return true\n  }\n\n  // It could also have been revalidated by the currently running server action.\n  // In this case the revalidation might not have been fully propagated by a\n  // remote cache handler yet, so we read it from the pending tags in the work\n  // store.\n  if (pendingRevalidatedTags?.some((item) => item.tag === tag)) {\n    debug?.('tag', tag, 'was just revalidated')\n\n    return true\n  }\n\n  return false\n}\n"],"names":["cache","isEdgeRuntime","process","env","NEXT_RUNTIME","debug","NEXT_PRIVATE_DEBUG_CACHE","console","bind","undefined","filterStackFrame","NODE_ENV","require","filterStackFrameDEV","findSourceMapURL","findSourceMapURLDEV","generateCacheEntry","workStore","cacheContext","clientReferenceManifest","encodedArguments","fn","timeoutError","runInCleanSnapshot","generateCacheEntryWithRestoredWorkStore","workAsyncStorage","run","generateCacheEntryWithCacheContext","createUseCacheStore","defaultCacheLife","kind","outerWorkUnitStore","type","phase","implicitTags","revalidate","expire","stale","explicitRevalidate","explicitExpire","explicitStale","tags","hmrRefreshHash","getHmrRefreshHash","isHmrRefresh","serverComponentsHmrCache","getServerComponentsHmrCache","forceRevalidate","shouldForceRevalidate","runtimeStagePromise","getRuntimeStagePromise","draftMode","getDraftModeProviderForCacheScope","rootParams","headers","cookies","useCacheOrRequestStore","assertDefaultCacheLife","InvariantError","cacheLifeProfiles","cacheStore","workUnitAsyncStorage","dynamicAccessAsyncStorage","abortController","AbortController","generateCacheEntryImpl","propagateCacheLifeAndTagsToRevalidateStore","revalidateStore","entry","outerTags","tag","includes","push","propagateCacheLifeAndTags","collectResult","savedStream","innerCacheStore","startTime","errors","buffer","reader","getReader","read","done","value","error","idx","bufferStream","ReadableStream","pull","controller","invalidDynamicUsageError","length","enqueue","close","collectedTags","collectedRevalidate","collectedExpire","collectedStale","timestamp","cacheSignal","getCacheSignal","endRead","temporaryReferences","createServerTemporaryReferenceSet","args","decodeReply","getServerModuleMap","decodeReplyFromAsyncIterable","Symbol","asyncIterator","Promise","resolve","renderSignal","aborted","addEventListener","once","performance","timeOrigin","now","resultPromise","createLazyResult","handleError","createReactServerErrorHandler","dev","isBuildTimePrerendering","reactServerErrorsByDigest","Log","stream","timeoutAbortController","timer","setTimeout","abort","dynamicAccessAbortSignal","getStore","signal","abortSignal","AbortSignal","any","prelude","prerender","clientModules","environmentName","onError","reason","clearTimeout","start","hangingPromise","makeHangingPromise","route","renderToReadableStream","returnStream","tee","pendingCacheEntry","name","cloneCacheEntry","streamA","streamB","clonedEntry","clonePendingCacheEntry","getNthCacheEntry","split","i","encodeFormData","formData","result","key","toString","stringValue","arrayBuffer","byteLength","String","fromCodePoint","Uint16Array","Uint8Array","createTrackedReadableStream","id","boundArgsLength","originalFn","argsObj","Array","prototype","slice","call","isPrivate","cacheHandler","getCacheHandler","Error","UseCacheTimeoutError","captureStackTrace","wrapAsInvalidDynamicUsageError","workUnitStore","expression","postponeWithTracking","dynamicTracking","throwToInterruptStaticGeneration","getClientReferenceManifest","buildId","hangingInputAbortSignal","createHangingInputAbortSignal","makeDevtoolsIOAwarePromise","RenderStage","Runtime","isPageOrLayoutSegmentFunction","isPageSegmentFunction","params","outerParams","searchParams","outerSearchParams","otherOuterArgs","props","_innerParams","innerSearchParams","otherInnerArgs","apply","makeErroringSearchParamsForUseCache","isLayoutSegmentFunction","$$isLayout","outerSlots","innerSlots","JSON","stringify","encryptedBoundArgs","shift","boundArgs","decryptActionBoundArgs","isArray","unshift","createClientTemporaryReferenceSet","cacheKeyParts","encodeCacheKeyParts","encodeReply","encodedCacheKeyParts","dynamicAccessAbortController","serializedCacheKey","prerenderResumeDataCache","getPrerenderResumeDataCache","renderResumeDataCache","getRenderResumeDataCache","beginRead","cachedEntry","get","existingEntry","DYNAMIC_EXPIRE","RUNTIME_PREFETCH_DYNAMIC_STALE","Dynamic","allowEmptyStaticShell","lazyRefreshTags","refreshTagsByCacheKind","isResolvedLazyResult","implicitTagsExpiration","lazyExpiration","expirationsByCacheKind","expiration","Infinity","shouldDiscardCacheEntry","currentTime","isStaticGeneration","newStream","isDraftMode","savedCacheEntry","set","promise","pendingRevalidateWrites","entryLeft","entryRight","ignoredStream","cancel","replayConsoleLogs","serverConsumerManifest","moduleLoading","moduleMap","edgeRscModuleMapping","rscModuleMapping","serverModuleMap","createFromReadableStream","maybeProps","$$isPage","isOnDemandRevalidate","some","isRecentlyRevalidatedTag","previouslyRevalidatedTags","pendingRevalidatedTags","item"],"mappings":"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","ignoreList":[0]}