{"version":3,"sources":["../../../src/server/app-render/work-unit-async-storage.external.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'async_hooks'\nimport type { DraftModeProvider } from '../async-storage/draft-mode-provider'\nimport type { ResponseCookies } from '../web/spec-extension/cookies'\nimport type { ReadonlyHeaders } from '../web/spec-extension/adapters/headers'\nimport type { ReadonlyRequestCookies } from '../web/spec-extension/adapters/request-cookies'\nimport type { CacheSignal } from './cache-signal'\nimport type { ResponseVaryParamsAccumulator } from './vary-params'\nimport type { DynamicTrackingState } from './dynamic-rendering'\nimport type { OpaqueFallbackRouteParams } from '../request/fallback-params'\n\n// Share the instance module in the next-shared layer\nimport { workUnitAsyncStorageInstance } from './work-unit-async-storage-instance' with { 'turbopack-transition': 'next-shared' }\nimport type { ServerComponentsHmrCache } from '../response-cache'\nimport type {\n  RenderResumeDataCache,\n  PrerenderResumeDataCache,\n} from '../resume-data-cache/resume-data-cache'\nimport type { Params } from '../request/params'\nimport type { ImplicitTags } from '../lib/implicit-tags'\nimport type { WorkStore } from './work-async-storage.external'\nimport { NEXT_HMR_REFRESH_HASH_COOKIE } from '../../client/components/app-router-headers'\nimport { InvariantError } from '../../shared/lib/invariant-error'\nimport type { StagedRenderingController } from './staged-rendering'\nimport { RenderStage } from './staged-rendering'\nimport type { ValidationBoundaryTracking } from './instant-validation/boundary-tracking'\nimport type { InstantValidationSampleTracking } from './instant-validation/instant-samples'\n\nexport type WorkUnitPhase = 'action' | 'render' | 'after'\n\nexport interface CommonWorkUnitStore {\n  /** NOTE: Will be mutated as phases change */\n  phase: WorkUnitPhase\n  readonly implicitTags: ImplicitTags\n}\n\nexport interface RequestStore extends CommonWorkUnitStore {\n  readonly type: 'request'\n\n  /**\n   * The URL of the request. This only specifies the pathname and the search\n   * part of the URL.\n   */\n  readonly url: {\n    /**\n     * The pathname of the requested URL.\n     */\n    readonly pathname: string\n\n    /**\n     * The search part of the requested URL. If the request did not provide a\n     * search part, this will be an empty string.\n     */\n    readonly search: string\n  }\n\n  readonly headers: ReadonlyHeaders\n  // This is mutable because we need to reassign it when transitioning from the action phase to the render phase.\n  // The cookie object itself is deliberately read only and thus can't be updated.\n  cookies: ReadonlyRequestCookies\n  readonly mutableCookies: ResponseCookies\n  readonly userspaceMutableCookies: ResponseCookies\n  readonly draftMode: DraftModeProvider\n  readonly isHmrRefresh?: boolean\n  readonly serverComponentsHmrCache?: ServerComponentsHmrCache\n\n  readonly rootParams: Params\n\n  /**\n   * The resume data cache for this request. This will be a immutable cache.\n   */\n  renderResumeDataCache: RenderResumeDataCache | null\n\n  stale?: number\n  stagedRendering?: StagedRenderingController | null\n  asyncApiPromises?: AsyncApiPromises\n  cacheSignal?: CacheSignal | null\n  prerenderResumeDataCache?: PrerenderResumeDataCache | null\n  fallbackParams?: OpaqueFallbackRouteParams | null\n\n  // Only in build-time instant-validation\n  // We mirror the controller/renderSignal from prerender stores to allow aborting the render\n  // in case we hit an error that makes it unnecessary to continue\n  controller?: AbortController\n  renderSignal?: AbortSignal\n  validationSamples?: InstantValidationSamples\n  validationSampleTracking?: InstantValidationSampleTracking | null\n\n  // DEV-only\n  usedDynamic?: boolean\n}\n\nexport type InstantValidationSamples = {\n  params: Params | undefined\n  searchParams: Record<string, string | string[] | null> | undefined\n}\n\nexport type AsyncApiPromises = {\n  cookies: Promise<ReadonlyRequestCookies>\n  earlyCookies: Promise<ReadonlyRequestCookies>\n\n  mutableCookies: Promise<ReadonlyRequestCookies>\n  earlyMutableCookies: Promise<ReadonlyRequestCookies>\n\n  headers: Promise<ReadonlyHeaders>\n  earlyHeaders: Promise<ReadonlyHeaders>\n\n  sharedParamsParent: Promise<string>\n  earlySharedParamsParent: Promise<string>\n\n  sharedSearchParamsParent: Promise<string>\n  earlySharedSearchParamsParent: Promise<string>\n\n  // Connection is not a runtime promise and doesn't\n  // need to distinguish between early and late\n  connection: Promise<undefined>\n}\n\n/**\n * Returns true if the current render stage is an early stage (EarlyStatic or\n * EarlyRuntime). The early stages are for runtime-prefetchable segments. When\n * true, runtime APIs should use the early promise variant that resolves at\n * EarlyRuntime rather than Runtime.\n */\nexport function isInEarlyRenderStage(requestStore: RequestStore): boolean {\n  const stagedRendering = requestStore.stagedRendering\n  if (stagedRendering) {\n    return (\n      stagedRendering.currentStage === RenderStage.EarlyStatic ||\n      stagedRendering.currentStage === RenderStage.EarlyRuntime\n    )\n  }\n  return false\n}\n\n/**\n * The Prerender store is for tracking information related to prerenders.\n *\n * It can be used for both RSC and SSR prerendering and should be scoped as close\n * to the individual `renderTo...` API call as possible. To keep the type simple\n * we don't distinguish between RSC and SSR prerendering explicitly but instead\n * use conditional object properties to infer which mode we are in. For instance cache tracking\n * only needs to happen during the RSC prerender when we are prospectively prerendering\n * to fill all caches.\n */\nexport type PrerenderStoreModern =\n  | PrerenderStoreModernClient\n  | PrerenderStoreModernServer\n  | PrerenderStoreModernRuntime\n  | ValidationStoreClient\n\n/** Like `PrerenderStoreModern`, but only including static prerenders (i.e. not runtime prerenders) */\nexport type StaticPrerenderStoreModern = Exclude<\n  PrerenderStoreModern,\n  PrerenderStoreModernRuntime | ValidationStoreClient\n>\n\nexport interface PrerenderStoreModernClient\n  extends PrerenderStoreModernCommon,\n    StaticPrerenderStoreCommon {\n  readonly type: 'prerender-client'\n}\n\nexport interface ValidationStoreClient extends PrerenderStoreModernCommon {\n  readonly type: 'validation-client'\n  readonly boundaryState: ValidationBoundaryTracking | null\n  validationSamples: InstantValidationSamples | null\n  validationSampleTracking: InstantValidationSampleTracking | null\n  fallbackRouteParams: OpaqueFallbackRouteParams | null\n}\n\nexport interface PrerenderStoreModernServer\n  extends PrerenderStoreModernCommon,\n    StaticPrerenderStoreCommon {\n  readonly type: 'prerender'\n}\n\nexport interface PrerenderStoreModernRuntime\n  extends PrerenderStoreModernCommon {\n  readonly type: 'prerender-runtime'\n\n  /**\n   * The staged rendering controller for this prerender. Models stage\n   * transitions (Before → Static → Runtime → Dynamic). Null for prospective\n   * renders where all stages run without sequencing.\n   */\n  readonly stagedRendering: StagedRenderingController | null\n\n  readonly headers: RequestStore['headers']\n  readonly cookies: RequestStore['cookies']\n  readonly draftMode: RequestStore['draftMode']\n}\n\nexport interface RevalidateStore {\n  // Collected revalidate times and tags for this document during the prerender.\n  revalidate: number // in seconds. 0 means dynamic. INFINITE_CACHE and higher means never revalidate.\n  expire: number // server expiration time\n  stale: number // client expiration time\n  tags: null | string[]\n}\n\ninterface PrerenderStoreModernCommon\n  extends CommonWorkUnitStore,\n    RevalidateStore {\n  /**\n   * The render signal is aborted after React's `prerender` function is aborted\n   * (using a separate signal), which happens in two cases:\n   *\n   * 1. When all caches are filled during the prospective prerender.\n   * 2. When the final prerender is aborted immediately after the prerender was\n   *    started.\n   *\n   * It can be used to reject any pending I/O, including hanging promises. This\n   * allows React to properly track the async I/O in dev mode, which yields\n   * better owner stacks for dynamic validation errors.\n   */\n  readonly renderSignal: AbortSignal\n\n  /**\n   * This is the AbortController which represents the boundary between Prerender\n   * and dynamic. In some renders it is the same as the controller for React,\n   * but in others it is a separate controller. It should be aborted whenever we\n   * are no longer in the prerender phase of rendering. Typically this is after\n   * one task, or when you call a sync API which requires the prerender to end\n   * immediately.\n   */\n  readonly controller: AbortController\n\n  /**\n   * When not null, this signal is used to track cache reads during prerendering\n   * and to await all cache reads completing, before aborting the prerender.\n   */\n  readonly cacheSignal: null | CacheSignal\n\n  /**\n   * During some prerenders we want to track dynamic access.\n   */\n  readonly dynamicTracking: null | DynamicTrackingState\n\n  readonly rootParams: Params\n\n  /**\n   * A mutable resume data cache for this prerender.\n   */\n  prerenderResumeDataCache: PrerenderResumeDataCache | null\n\n  /**\n   * An immutable resume data cache for this prerender. This may be provided\n   * instead of the `prerenderResumeDataCache` if the prerender is not supposed\n   * to fill caches, and only read from prefilled caches, e.g. when prerendering\n   * an optional fallback shell.\n   */\n  renderResumeDataCache: RenderResumeDataCache | null\n\n  /**\n   * The HMR refresh hash is only provided in dev mode. It is needed for the dev\n   * warmup render to ensure that the cache keys will be identical for the\n   * subsequent dynamic render.\n   */\n  readonly hmrRefreshHash: string | undefined\n\n  /**\n   * A mutable accumulator for per-segment vary params during prerender. Tracks\n   * which route params each segment actually accesses, allowing the client\n   * cache to re-key entries for better sharing across different param values.\n   */\n  readonly varyParamsAccumulator: ResponseVaryParamsAccumulator | null\n}\n\ninterface StaticPrerenderStoreCommon {\n  /**\n   * The set of unknown route parameters. Accessing these will be tracked as\n   * a dynamic access.\n   */\n  readonly fallbackRouteParams: OpaqueFallbackRouteParams | null\n\n  /**\n   * When true, the page is prerendered as a fallback shell, while allowing any\n   * dynamic accesses to result in an empty shell. This is the case when there\n   * are also routes prerendered with a more complete set of params.\n   * Prerendering those routes would catch any invalid dynamic accesses.\n   */\n  readonly allowEmptyStaticShell: boolean\n}\n\nexport interface PrerenderStorePPR\n  extends CommonWorkUnitStore,\n    RevalidateStore {\n  readonly type: 'prerender-ppr'\n  readonly rootParams: Params\n  readonly dynamicTracking: null | DynamicTrackingState\n\n  /**\n   * The set of unknown route parameters. Accessing these will be tracked as\n   * a dynamic access.\n   */\n  readonly fallbackRouteParams: OpaqueFallbackRouteParams | null\n\n  /**\n   * The resume data cache for this prerender.\n   */\n  prerenderResumeDataCache: PrerenderResumeDataCache\n}\n\nexport interface PrerenderStoreLegacy\n  extends CommonWorkUnitStore,\n    RevalidateStore {\n  readonly type: 'prerender-legacy'\n  readonly rootParams: Params\n}\n\nexport type PrerenderStore =\n  | PrerenderStoreLegacy\n  | PrerenderStorePPR\n  | PrerenderStoreModern\n\n// /** Like `PrerenderStoreModern`, but only including static prerenders (i.e. not runtime prerenders) */\nexport type StaticPrerenderStore = Exclude<\n  PrerenderStore,\n  PrerenderStoreModernRuntime | ValidationStoreClient\n>\n\nexport interface CommonCacheStore\n  extends Omit<CommonWorkUnitStore, 'implicitTags'> {\n  /**\n   * A cache work unit store might not always have an outer work unit store,\n   * from which implicit tags could be inherited.\n   */\n  readonly implicitTags: ImplicitTags | undefined\n  /**\n   * Draft mode is only available if the outer work unit store is a request\n   * store and draft mode is enabled.\n   */\n  readonly draftMode: DraftModeProvider | undefined\n}\n\nexport interface CommonUseCacheStore extends CommonCacheStore, RevalidateStore {\n  explicitRevalidate: undefined | number // explicit revalidate time from cacheLife() calls\n  explicitExpire: undefined | number // server expiration time\n  explicitStale: undefined | number // client expiration time\n  readonly hmrRefreshHash: string | undefined\n  readonly isHmrRefresh: boolean\n  readonly serverComponentsHmrCache: ServerComponentsHmrCache | undefined\n  readonly forceRevalidate: boolean\n}\n\nexport interface PublicUseCacheStore extends CommonUseCacheStore {\n  readonly type: 'cache'\n\n  /**\n   * The root params for the current route. `undefined` when nested inside\n   * `unstable_cache`, which doesn't carry root params. Currently, `\"use cache\"`\n   * inside `unstable_cache` is allowed, so this case must be handled. The error\n   * message in `getRootParam` assumes this is the only scenario where\n   * `rootParams` is `undefined`.\n   */\n  readonly rootParams: Params | undefined\n  /**\n   * Tracks which root param names were read during this cache invocation.\n   */\n  readonly readRootParamNames: Set<string>\n}\n\nexport interface PrivateUseCacheStore extends CommonUseCacheStore {\n  readonly type: 'private-cache'\n\n  readonly headers: ReadonlyHeaders\n  readonly cookies: ReadonlyRequestCookies\n\n  /**\n   * Private caches don't currently need to track read root params for the cache\n   * key because they're not persisted anywhere.\n   */\n  readonly rootParams: Params\n}\n\nexport type UseCacheStore = PublicUseCacheStore | PrivateUseCacheStore\n\nexport interface UnstableCacheStore extends CommonCacheStore {\n  readonly type: 'unstable-cache'\n  /**\n   * Always `undefined` for `unstable_cache` — root params are not available in\n   * this context. If a `\"use cache\"` function nested inside `unstable_cache`\n   * tries to access root params, it will encounter `undefined` here and throw.\n   */\n  readonly rootParams: undefined\n}\n\n/**\n * The Cache store is for tracking information inside a \"use cache\" or\n * unstable_cache context. A cache store shadows an outer request store (if\n * present) as a work unit, so that we never accidentally expose any request or\n * page specific information to cache functions, unless it's explicitly desired.\n * For those exceptions, the data is copied over from the request store to the\n * cache store, instead of generally making the request store available to cache\n * functions.\n */\nexport type CacheStore = UseCacheStore | UnstableCacheStore\n\nexport interface GenerateStaticParamsStore extends CommonWorkUnitStore {\n  readonly type: 'generate-static-params'\n  readonly rootParams: Params\n}\n\nexport type WorkUnitStore =\n  | RequestStore\n  | CacheStore\n  | PrerenderStore\n  | GenerateStaticParamsStore\n\nexport type WorkUnitAsyncStorage = AsyncLocalStorage<WorkUnitStore>\n\nexport { workUnitAsyncStorageInstance as workUnitAsyncStorage }\n\nexport function throwForMissingRequestStore(callingExpression: string): never {\n  throw new Error(\n    `\\`${callingExpression}\\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`\n  )\n}\n\nexport function throwInvariantForMissingStore(): never {\n  throw new InvariantError('Expected workUnitAsyncStorage to have a store.')\n}\n\nexport function getPrerenderResumeDataCache(\n  workUnitStore: WorkUnitStore\n): PrerenderResumeDataCache | null {\n  switch (workUnitStore.type) {\n    case 'prerender':\n    case 'prerender-runtime':\n    case 'prerender-ppr':\n      return workUnitStore.prerenderResumeDataCache\n    case 'prerender-client':\n    case 'validation-client':\n      // TODO eliminate fetch caching in client scope and stop exposing this data\n      // cache during SSR.\n      return workUnitStore.prerenderResumeDataCache\n    case 'request': {\n      // In dev, we might fill caches even during a dynamic request.\n      if (workUnitStore.prerenderResumeDataCache) {\n        return workUnitStore.prerenderResumeDataCache\n      }\n      // fallthrough\n    }\n    case 'prerender-legacy':\n    case 'cache':\n    case 'private-cache':\n    case 'unstable-cache':\n    case 'generate-static-params':\n      return null\n    default:\n      return workUnitStore satisfies never\n  }\n}\n\nexport function getRenderResumeDataCache(\n  workUnitStore: WorkUnitStore\n): RenderResumeDataCache | null {\n  switch (workUnitStore.type) {\n    case 'request':\n    case 'prerender':\n    case 'prerender-runtime':\n    case 'prerender-client':\n    case 'validation-client':\n      if (workUnitStore.renderResumeDataCache) {\n        // If we are in a prerender, we might have a render resume data cache\n        // that is used to read from prefilled caches.\n        return workUnitStore.renderResumeDataCache\n      }\n    // fallthrough\n    case 'prerender-ppr':\n      // Otherwise we return the mutable resume data cache here as an immutable\n      // version of the cache as it can also be used for reading.\n      return workUnitStore.prerenderResumeDataCache ?? null\n    case 'cache':\n    case 'private-cache':\n    case 'unstable-cache':\n    case 'prerender-legacy':\n    case 'generate-static-params':\n      return null\n    default:\n      return workUnitStore satisfies never\n  }\n}\n\nexport function getHmrRefreshHash(\n  workUnitStore: WorkUnitStore\n): string | undefined {\n  if (process.env.__NEXT_DEV_SERVER) {\n    switch (workUnitStore.type) {\n      case 'cache':\n      case 'private-cache':\n      case 'prerender':\n      case 'prerender-runtime':\n        return workUnitStore.hmrRefreshHash\n      case 'request':\n        return workUnitStore.cookies.get(NEXT_HMR_REFRESH_HASH_COOKIE)?.value\n      case 'prerender-client':\n      case 'validation-client':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'unstable-cache':\n      case 'generate-static-params':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n\n  return undefined\n}\n\nexport function isHmrRefresh(workUnitStore: WorkUnitStore): boolean {\n  if (process.env.__NEXT_DEV_SERVER) {\n    switch (workUnitStore.type) {\n      case 'cache':\n      case 'private-cache':\n      case 'request':\n        return workUnitStore.isHmrRefresh ?? false\n      case 'prerender':\n      case 'prerender-client':\n      case 'validation-client':\n      case 'prerender-runtime':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'unstable-cache':\n      case 'generate-static-params':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n\n  return false\n}\n\nexport function getServerComponentsHmrCache(\n  workUnitStore: WorkUnitStore\n): ServerComponentsHmrCache | undefined {\n  if (process.env.__NEXT_DEV_SERVER) {\n    switch (workUnitStore.type) {\n      case 'cache':\n      case 'private-cache':\n      case 'request':\n        return workUnitStore.serverComponentsHmrCache\n      case 'prerender':\n      case 'prerender-client':\n      case 'validation-client':\n      case 'prerender-runtime':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'unstable-cache':\n      case 'generate-static-params':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n\n  return undefined\n}\n\n/**\n * Returns a draft mode provider only if draft mode is enabled.\n */\nexport function getDraftModeProviderForCacheScope(\n  workStore: WorkStore,\n  workUnitStore: WorkUnitStore\n): DraftModeProvider | undefined {\n  if (workStore.isDraftMode) {\n    switch (workUnitStore.type) {\n      case 'cache':\n      case 'private-cache':\n      case 'unstable-cache':\n      case 'prerender-runtime':\n      case 'request':\n        return workUnitStore.draftMode\n      case 'prerender':\n      case 'prerender-client':\n      case 'validation-client':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'generate-static-params':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n\n  return undefined\n}\n\nexport function getStagedRenderingController(\n  workUnitStore: WorkUnitStore\n): StagedRenderingController | null {\n  switch (workUnitStore.type) {\n    case 'request':\n    case 'prerender-runtime':\n      return workUnitStore.stagedRendering ?? null\n    case 'prerender':\n    case 'prerender-client':\n    case 'validation-client':\n    case 'prerender-ppr':\n    case 'prerender-legacy':\n    case 'cache':\n    case 'private-cache':\n    case 'unstable-cache':\n    case 'generate-static-params':\n      return null\n    default:\n      return workUnitStore satisfies never\n  }\n}\n\nexport function getCacheSignal(\n  workUnitStore: WorkUnitStore\n): CacheSignal | null {\n  switch (workUnitStore.type) {\n    case 'prerender':\n    case 'prerender-client':\n    case 'validation-client':\n    case 'prerender-runtime':\n      return workUnitStore.cacheSignal\n    case 'request': {\n      // In dev, we might fill caches even during a dynamic request.\n      if (workUnitStore.cacheSignal) {\n        return workUnitStore.cacheSignal\n      }\n      // fallthrough\n    }\n    case 'prerender-ppr':\n    case 'prerender-legacy':\n    case 'cache':\n    case 'private-cache':\n    case 'unstable-cache':\n    case 'generate-static-params':\n      return null\n    default:\n      return workUnitStore satisfies never\n  }\n}\n"],"names":["getCacheSignal","getDraftModeProviderForCacheScope","getHmrRefreshHash","getPrerenderResumeDataCache","getRenderResumeDataCache","getServerComponentsHmrCache","getStagedRenderingController","isHmrRefresh","isInEarlyRenderStage","throwForMissingRequestStore","throwInvariantForMissingStore","workUnitAsyncStorage","workUnitAsyncStorageInstance","requestStore","stagedRendering","currentStage","RenderStage","EarlyStatic","EarlyRuntime","callingExpression","Error","InvariantError","workUnitStore","type","prerenderResumeDataCache","renderResumeDataCache","process","env","__NEXT_DEV_SERVER","hmrRefreshHash","cookies","get","NEXT_HMR_REFRESH_HASH_COOKIE","value","undefined","serverComponentsHmrCache","workStore","isDraftMode","draftMode","cacheSignal"],"mappings":"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","ignoreList":[0]}