vercel · unstubbable · May 19, 2025 · May 15, 2025
diff --git a/packages/next/src/build/index.ts b/packages/next/src/build/index.ts
@@ -193,7 +193,6 @@ import {
 } from '../server/lib/experimental/ppr'
 import { FallbackMode, fallbackModeToFallbackField } from '../lib/fallback'
 import { RenderingMode } from './rendering-mode'
-import { getParamKeys } from '../server/request/fallback-params'
 import { InvariantError } from '../shared/lib/invariant-error'
 import { HTML_LIMITED_BOT_UA_RE_STRING } from '../shared/lib/router/utils/is-bot'
 import type { UseCacheTrackerKey } from './webpack/plugins/telemetry-plugin/use-cache-tracker-utils'
@@ -1613,10 +1612,6 @@ export default async function build(
      const serverPropsPages = new Set<string>()
      const additionalPaths = new Map<string, PrerenderedRoute[]>()
      const staticPaths = new Map<string, PrerenderedRoute[]>()
-      const prospectiveRenders = new Map<
-        string,
-        { page: string; originalAppPath: string }
-      >()
      const appNormalizedPaths = new Map<string, string>()
      const fallbackModes = new Map<string, FallbackMode>()
      const appDefaultConfigs = new Map<string, AppSegmentConfig>()
@@ -1975,31 +1970,6 @@ export default async function build(

                            staticPaths.set(originalAppPath, [])
                          }
-                          // As PPR isn't enabled for this route, if dynamic IO
-                          // is enabled, and this is a dynamic route, we should
-                          // complete a prospective render for the route so that
-                          // we can use the fallback behavior. This lets us
-                          // check that dynamic pages won't error when they
-                          // enable PPR.
-                          else if (config.experimental.dynamicIO && isDynamic) {
-                            // If there's a page with a more specific render
-                            // available, then we should skip the prospective
-                            // render because it'll be done as a part of the
-                            // that render to validate the dynamic state.
-                            if (
-                              // The existence of any prerendered routes when
-                              // PPR is disabled means that the route has more
-                              // specific prerendered routes that should be
-                              // used for the diagnostic render anyways.
-                              !workerResult.prerenderedRoutes ||
-                              workerResult.prerenderedRoutes.length === 0
-                            ) {
-                              prospectiveRenders.set(originalAppPath, {
-                                page,
-                                originalAppPath,
-                              })
-                            }
-                          }

                          if (workerResult.prerenderedRoutes) {
                            staticPaths.set(
@@ -2718,28 +2688,6 @@ export default async function build(
                })
              })

-              // If the app does have dynamic IO enabled but does not have PPR
-              // enabled, then we need to perform a prospective render for all
-              // the dynamic pages to ensure that they won't error during
-              // rendering (due to a missing prelude).
-              for (const {
-                page,
-                originalAppPath,
-              } of prospectiveRenders.values()) {
-                defaultMap[page] = {
-                  page: originalAppPath,
-                  _ssgPath: page,
-                  _fallbackRouteParams: getParamKeys(page),
-                  // Prospective renders are only enabled for app pages.
-                  _isAppDir: true,
-                  // Prospective renders are only enabled when PPR is disabled.
-                  _isRoutePPREnabled: false,
-                  _isProspectiveRender: true,
-                  // Dynamic IO does not currently support `dynamic === 'error'`.
-                  _isDynamicError: false,
-                }
-              }
-
              if (i18n) {
                for (const page of [
                  ...staticPages,

diff --git a/packages/next/src/export/routes/app-page.ts b/packages/next/src/export/routes/app-page.ts
@@ -30,58 +30,6 @@ import type { RequestLifecycleOpts } from '../../server/base-server'
 import type { AppSharedContext } from '../../server/app-render/app-render'
 import type { MultiFileWriter } from '../../lib/multi-file-writer'

-export async function prospectiveRenderAppPage(
-  req: MockedRequest,
-  res: MockedResponse,
-  page: string,
-  pathname: string,
-  query: NextParsedUrlQuery,
-  fallbackRouteParams: FallbackRouteParams | null,
-  partialRenderOpts: Omit<RenderOpts, keyof RequestLifecycleOpts>,
-  sharedContext: AppSharedContext
-): Promise<undefined> {
-  const afterRunner = new AfterRunner()
-
-  // If the page is `/_not-found`, then we should update the page to be `/404`.
-  // UNDERSCORE_NOT_FOUND_ROUTE value used here, however we don't want to import it here as it causes constants to be inlined which we don't want here.
-  if (page === '/_not-found/page') {
-    pathname = '/404'
-  }
-
-  try {
-    await lazyRenderAppPage(
-      new NodeNextRequest(req),
-      new NodeNextResponse(res),
-      pathname,
-      query,
-      fallbackRouteParams,
-      {
-        ...partialRenderOpts,
-        waitUntil: afterRunner.context.waitUntil,
-        onClose: afterRunner.context.onClose,
-        onAfterTaskError: afterRunner.context.onTaskError,
-      },
-      undefined,
-      false,
-      sharedContext
-    )
-
-    // TODO(after): if we abort a prerender because of an error in an after-callback
-    // we should probably communicate that better (and not log the error twice)
-    await afterRunner.executeAfter()
-  } catch (err) {
-    if (!isDynamicUsageError(err)) {
-      throw err
-    }
-
-    // We should fail rendering if a client side rendering bailout
-    // occurred at the page level.
-    if (isBailoutToCSRError(err)) {
-      throw err
-    }
-  }
-}
-
 /**
 * Renders & exports a page associated with the /app directory
 */

diff --git a/packages/next/src/export/worker.ts b/packages/next/src/export/worker.ts
@@ -26,7 +26,7 @@ import { createRequestResponseMocks } from '../server/lib/mock-request'
 import { isAppRouteRoute } from '../lib/is-app-route-route'
 import { hasNextSupport } from '../server/ci-info'
 import { exportAppRoute } from './routes/app-route'
-import { exportAppPage, prospectiveRenderAppPage } from './routes/app-page'
+import { exportAppPage } from './routes/app-page'
 import { exportPagesPage } from './routes/pages'
 import { getParams } from './helpers/get-params'
 import { createIncrementalCache } from './helpers/create-incremental-cache'
@@ -104,10 +104,6 @@ async function exportPageImpl(
    // the renderOpts.
    _isRoutePPREnabled: isRoutePPREnabled,

-    // If this is a prospective render, we don't actually want to persist the
-    // result, we just want to use it to error the build if there's a problem.
-    _isProspectiveRender: isProspectiveRender = false,
-
    // Configure the rendering of the page not to throw if an empty static shell
    // is generated while rendering using PPR.
    _doNotThrowOnEmptyStaticShell: doNotThrowOnEmptyStaticShell = false,
@@ -287,21 +283,6 @@ async function exportPageImpl(
      buildId: input.buildId,
    }

-    // If this is a prospective render, don't return any metrics or revalidate
-    // timings as we aren't persisting this render (it was only to error).
-    if (isProspectiveRender) {
-      return prospectiveRenderAppPage(
-        req,
-        res,
-        page,
-        pathname,
-        query,
-        fallbackRouteParams,
-        renderOpts,
-        sharedContext
-      )
-    }
-
    return exportAppPage(
      req,
      res,

diff --git a/packages/next/src/server/config-schema.ts b/packages/next/src/server/config-schema.ts
@@ -41,7 +41,6 @@ const zExportMap: zod.ZodType<ExportPathMap> = z.record(
    _isAppDir: z.boolean().optional(),
    _isDynamicError: z.boolean().optional(),
    _isRoutePPREnabled: z.boolean().optional(),
-    _isProspectiveRender: z.boolean().optional(),
    _doNotThrowOnEmptyStaticShell: z.boolean().optional(),
  })
 )

diff --git a/packages/next/src/server/config-shared.ts b/packages/next/src/server/config-shared.ts
@@ -743,16 +743,6 @@ export type ExportPathMap = {
     */
    _isRoutePPREnabled?: boolean

-    /**
-     * When true, it indicates that this page is being rendered in an attempt to
-     * discover if the page will be safe to generate with PPR. This is only
-     * enabled when the app has `experimental.dynamicIO` enabled but does not
-     * have `experimental.ppr` enabled.
-     *
-     * @internal
-     */
-    _isProspectiveRender?: boolean
-
    /**
     * When true, it indicates that the diagnostic render for this page is
     * disabled. This is only used when the app has `experimental.ppr` and

diff --git a/packages/next/src/server/request/fallback-params.ts b/packages/next/src/server/request/fallback-params.ts
@@ -3,7 +3,7 @@ import { getRouteRegex } from '../../shared/lib/router/utils/route-regex'

 export type FallbackRouteParams = ReadonlyMap<string, string>

-export function getParamKeys(page: string) {
+function getParamKeys(page: string) {
  const pattern = getRouteRegex(page)
  const matcher = getRouteMatcher(pattern)


diff --git a/test/e2e/app-dir/dynamic-io-errors/dynamic-io-errors.prospective-fallback.test.ts b/test/e2e/app-dir/dynamic-io-errors/dynamic-io-errors.prospective-fallback.test.ts
diff --git a/test/e2e/app-dir/dynamic-io-errors/fixtures/prospective-fallback/app/blog/[slug]/page.jsx b/test/e2e/app-dir/dynamic-io-errors/fixtures/prospective-fallback/app/blog/[slug]/page.jsx
diff --git a/test/e2e/app-dir/dynamic-io-errors/fixtures/prospective-fallback/app/layout.jsx b/test/e2e/app-dir/dynamic-io-errors/fixtures/prospective-fallback/app/layout.jsx
diff --git a/test/e2e/app-dir/dynamic-io-errors/fixtures/prospective-fallback/next.config.js b/test/e2e/app-dir/dynamic-io-errors/fixtures/prospective-fallback/next.config.js