@vercel/next 4.0.12 → 4.0.14

package/dist/index.js

@@ -9677,7 +9677,7 @@ async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
   }
   return routesManifest;
 }
-async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes, canUsePreviewMode, bypassToken, isServerMode, dynamicMiddlewareRouteMap) {
+async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes, canUsePreviewMode, bypassToken, isServerMode, dynamicMiddlewareRouteMap, experimentalPPR) {
   if (routesManifest) {
     switch (routesManifest.version) {
       case 1:
@@ -9730,6 +9730,20 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
               }
             ];
           }
+          if (experimentalPPR) {
+            let dest = route.dest?.replace(/($|\?)/, ".prefetch.rsc$1");
+            if (page === "/" || page === "/index") {
+              dest = dest?.replace(/([^/]+\.prefetch\.rsc(\?.*|$))/, "__$1");
+            }
+            routes2.push({
+              ...route,
+              src: route.src.replace(
+                new RegExp((0, import_escape_string_regexp.default)("(?:/)?$")),
+                "(?:\\.prefetch\\.rsc)(?:/)?$"
+              ),
+              dest
+            });
+          }
           routes2.push({
             ...route,
             src: route.src.replace(
@@ -9739,7 +9753,6 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
             dest: route.dest?.replace(/($|\?)/, ".rsc$1")
           });
           routes2.push(route);
-          continue;
         }
         return routes2;
       }
@@ -10152,47 +10165,68 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
         let initialStatus;
         let initialHeaders;
         let experimentalBypassFor;
+        let experimentalPPR;
+        let prefetchDataRoute;
         if (manifest.version === 4) {
           initialStatus = manifest.routes[route].initialStatus;
           initialHeaders = manifest.routes[route].initialHeaders;
           experimentalBypassFor = manifest.routes[route].experimentalBypassFor;
+          experimentalPPR = manifest.routes[route].experimentalPPR;
+          prefetchDataRoute = manifest.routes[route].prefetchDataRoute;
         }
         ret.staticRoutes[route] = {
           initialRevalidate: initialRevalidateSeconds === false ? false : Math.max(1, initialRevalidateSeconds),
           dataRoute,
+          prefetchDataRoute,
           srcRoute,
           initialStatus,
           initialHeaders,
-          experimentalBypassFor
+          experimentalBypassFor,
+          experimentalPPR
         };
       });
       lazyRoutes.forEach((lazyRoute) => {
         const { routeRegex, fallback, dataRoute, dataRouteRegex } = manifest.dynamicRoutes[lazyRoute];
         let experimentalBypassFor;
+        let experimentalPPR;
+        let prefetchDataRoute;
+        let prefetchDataRouteRegex;
         if (manifest.version === 4) {
           experimentalBypassFor = manifest.dynamicRoutes[lazyRoute].experimentalBypassFor;
+          experimentalPPR = manifest.dynamicRoutes[lazyRoute].experimentalPPR;
+          prefetchDataRoute = manifest.dynamicRoutes[lazyRoute].prefetchDataRoute;
+          prefetchDataRouteRegex = manifest.dynamicRoutes[lazyRoute].prefetchDataRouteRegex;
         }
         if (typeof fallback === "string") {
           ret.fallbackRoutes[lazyRoute] = {
             experimentalBypassFor,
+            experimentalPPR,
             routeRegex,
             fallback,
             dataRoute,
-            dataRouteRegex
+            dataRouteRegex,
+            prefetchDataRoute,
+            prefetchDataRouteRegex
           };
         } else if (fallback === null) {
           ret.blockingFallbackRoutes[lazyRoute] = {
             experimentalBypassFor,
+            experimentalPPR,
             routeRegex,
             dataRoute,
-            dataRouteRegex
+            dataRouteRegex,
+            prefetchDataRoute,
+            prefetchDataRouteRegex
           };
         } else {
           ret.omittedRoutes[lazyRoute] = {
             experimentalBypassFor,
+            experimentalPPR,
             routeRegex,
             dataRoute,
-            dataRouteRegex
+            dataRouteRegex,
+            prefetchDataRoute,
+            prefetchDataRouteRegex
           };
         }
       });
@@ -10322,6 +10356,7 @@ async function getPageLambdaGroups({
   functionsConfigManifest,
   pages,
   prerenderRoutes,
+  experimentalPPRRoutes,
   pageTraces,
   compressedPages,
   tracedPseudoLayer,
@@ -10336,6 +10371,7 @@ async function getPageLambdaGroups({
     const newPages = [...internalPages, page];
     const routeName = normalizePage(page.replace(/\.js$/, ""));
     const isPrerenderRoute = prerenderRoutes.has(routeName);
+    const isExperimentalPPR = experimentalPPRRoutes?.has(routeName) ?? false;
     let opts = {};
     if (functionsConfigManifest && functionsConfigManifest.functions[routeName]) {
       opts = functionsConfigManifest.functions[routeName];
@@ -10353,7 +10389,7 @@ async function getPageLambdaGroups({
       opts = { ...vercelConfigOpts, ...opts };
     }
     let matchingGroup = groups.find((group) => {
-      const matches = group.maxDuration === opts.maxDuration && group.memory === opts.memory && group.isPrerenders === isPrerenderRoute;
+      const matches = group.maxDuration === opts.maxDuration && group.memory === opts.memory && group.isPrerenders === isPrerenderRoute && group.isExperimentalPPR === isExperimentalPPR;
       if (matches) {
         let newTracedFilesSize = group.pseudoLayerBytes;
         let newTracedFilesUncompressedSize = group.pseudoLayerUncompressedBytes;
@@ -10381,6 +10417,7 @@ async function getPageLambdaGroups({
         pages: [page],
         ...opts,
         isPrerenders: isPrerenderRoute,
+        isExperimentalPPR,
         isApiLambda: !!isApiPage(page),
         pseudoLayerBytes: initialPseudoLayer.pseudoLayerBytes,
         pseudoLayerUncompressedBytes: initialPseudoLayerUncompressed,
@@ -10562,7 +10599,7 @@ var onPrerenderRouteInitial = (prerenderManifest, canUsePreviewMode, entryDirect
   };
 };
 var prerenderGroup = 1;
-var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
+var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
   isBlocking,
   isFallback,
   isOmitted,
@@ -10579,6 +10616,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
     isServerMode,
     canUsePreviewMode,
     lambdas,
+    experimentalStreamingLambdaPaths,
     prerenders,
     pageLambdaMap,
     routesManifest,
@@ -10621,9 +10659,11 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
   let initialRevalidate;
   let srcRoute;
   let dataRoute;
+  let prefetchDataRoute;
   let initialStatus;
   let initialHeaders;
   let experimentalBypassFor;
+  let experimentalPPR;
   if (isFallback || isBlocking) {
     const pr = isFallback ? prerenderManifest.fallbackRoutes[routeKey] : prerenderManifest.blockingFallbackRoutes[routeKey];
     initialRevalidate = 1;
@@ -10636,11 +10676,15 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
     srcRoute = null;
     dataRoute = pr.dataRoute;
     experimentalBypassFor = pr.experimentalBypassFor;
+    experimentalPPR = pr.experimentalPPR;
+    prefetchDataRoute = pr.prefetchDataRoute;
   } else if (isOmitted) {
     initialRevalidate = false;
     srcRoute = routeKey;
     dataRoute = prerenderManifest.omittedRoutes[routeKey].dataRoute;
     experimentalBypassFor = prerenderManifest.omittedRoutes[routeKey].experimentalBypassFor;
+    experimentalPPR = prerenderManifest.omittedRoutes[routeKey].experimentalPPR;
+    prefetchDataRoute = prerenderManifest.omittedRoutes[routeKey].prefetchDataRoute;
   } else {
     const pr = prerenderManifest.staticRoutes[routeKey];
     ({
@@ -10649,7 +10693,9 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
       dataRoute,
       initialHeaders,
       initialStatus,
-      experimentalBypassFor
+      experimentalBypassFor,
+      experimentalPPR,
+      prefetchDataRoute
     } = pr);
   }
   let isAppPathRoute = false;
@@ -10658,7 +10704,38 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
   }
   const isOmittedOrNotFound = isOmitted || isNotFound;
   let htmlFsRef;
-  if (appDir && !dataRoute && isAppPathRoute && !(isBlocking || isFallback)) {
+  let prerender;
+  if (experimentalPPR && appDir) {
+    const htmlPath = import_path2.default.join(appDir, `${routeFileNoExt}.html`);
+    const metaPath = import_path2.default.join(appDir, `${routeFileNoExt}.meta`);
+    if (import_fs_extra3.default.existsSync(htmlPath) && import_fs_extra3.default.existsSync(metaPath)) {
+      const meta = JSON.parse(await import_fs_extra3.default.readFile(metaPath, "utf8"));
+      if ("postponed" in meta && typeof meta.postponed === "string") {
+        prerender = meta.postponed;
+        initialHeaders ??= {};
+        initialHeaders["content-type"] = `application/x-nextjs-pre-render; state-length=${meta.postponed.length}`;
+        const html = await import_fs_extra3.default.readFileSync(htmlPath, "utf8");
+        prerender += html;
+      }
+    }
+    if (!dataRoute?.endsWith(".rsc")) {
+      throw new Error(
+        `Invariant: unexpected output path for ${dataRoute} and PPR`
+      );
+    }
+    if (!prefetchDataRoute?.endsWith(".prefetch.rsc")) {
+      throw new Error(
+        `Invariant: unexpected output path for ${prefetchDataRoute} and PPR`
+      );
+    }
+  }
+  if (prerender) {
+    const contentType = initialHeaders?.["content-type"];
+    if (!contentType) {
+      throw new Error("Invariant: contentType can't be undefined");
+    }
+    htmlFsRef = new import_build_utils.FileBlob({ contentType, data: prerender });
+  } else if (appDir && !dataRoute && isAppPathRoute && !(isBlocking || isFallback)) {
     const contentType = initialHeaders?.["content-type"];
     htmlFsRef = new import_build_utils.FileFsRef({
       fsPath: import_path2.default.join(appDir, `${routeFileNoExt}.body`),
@@ -10691,7 +10768,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
     isFallback || isBlocking || isNotFound && !static404Page || !dataRoute ? null : new import_build_utils.FileFsRef({
       fsPath: import_path2.default.join(
         isAppPathRoute && !isOmittedOrNotFound && appDir ? appDir : pagesDir,
-        `${isOmittedOrNotFound ? localePrefixed404 ? addLocaleOrDefault("/404.html", routesManifest, locale) : "/404.html" : isAppPathRoute ? dataRoute : routeFileNoExt + ".json"}`
+        `${isOmittedOrNotFound ? localePrefixed404 ? addLocaleOrDefault("/404.html", routesManifest, locale) : "/404.html" : isAppPathRoute ? prefetchDataRoute || dataRoute : routeFileNoExt + ".json"}`
       )
     })
   );
@@ -10714,11 +10791,10 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
     origRouteFileNoExt
   );
   let lambda;
-  let outputPathData = null;
-  if (dataRoute) {
-    outputPathData = import_path2.default.posix.join(entryDirectory, dataRoute);
+  function normalizeDataRoute(route) {
+    let normalized = import_path2.default.posix.join(entryDirectory, route);
     if (nonDynamicSsg || isFallback || isOmitted) {
-      outputPathData = outputPathData.replace(
+      normalized = normalized.replace(
         new RegExp(`${(0, import_escape_string_regexp.default)(origRouteFileNoExt)}.json$`),
         // ensure we escape "$" correctly while replacing as "$" is a special
         // character, we need to do double escaping as first is for the initial
@@ -10726,7 +10802,24 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
         `${routeFileNoExt.replace(/\$/g, "$$$$")}.json`
       );
     }
+    return normalized;
   }
+  let outputPathData = null;
+  if (dataRoute) {
+    outputPathData = normalizeDataRoute(dataRoute);
+  }
+  let outputPathPrefetchData = null;
+  if (prefetchDataRoute) {
+    if (!experimentalPPR) {
+      throw new Error(
+        "Invariant: prefetchDataRoute can't be set without PPR"
+      );
+    }
+    outputPathPrefetchData = normalizeDataRoute(prefetchDataRoute);
+  } else if (experimentalPPR) {
+    throw new Error("Invariant: expected to find prefetch data route PPR");
+  }
+  const outputPrerenderPathData = outputPathPrefetchData || outputPathData;
   if (isSharedLambdas) {
     const outputSrcPathPage = normalizeIndexOutput(
       import_path2.default.join(
@@ -10760,8 +10853,8 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
     if (!canUsePreviewMode || routeKey === "/404" && !lambdas[outputPathPage]) {
       htmlFsRef.contentType = htmlContentType;
       prerenders[outputPathPage] = htmlFsRef;
-      if (outputPathData) {
-        prerenders[outputPathData] = jsonFsRef;
+      if (outputPrerenderPathData) {
+        prerenders[outputPrerenderPathData] = jsonFsRef;
       }
     }
   }
@@ -10797,10 +10890,22 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
     const rscEnabled = !!routesManifest?.rsc;
     const rscVaryHeader = routesManifest?.rsc?.varyHeader || "RSC, Next-Router-State-Tree, Next-Router-Prefetch";
     const rscContentTypeHeader = routesManifest?.rsc?.contentTypeHeader || RSC_CONTENT_TYPE;
+    const rscDidPostponeHeader = routesManifest?.rsc?.didPostponeHeader;
     let sourcePath;
     if (`/${outputPathPage}` !== srcRoute && srcRoute) {
       sourcePath = srcRoute;
     }
+    let key = srcRoute || routeKey;
+    if (key === "/") {
+      key = "index";
+    } else {
+      if (!key.startsWith("/")) {
+        throw new Error("Invariant: key doesn't start with /");
+      }
+      key = key.substring(1);
+    }
+    key = import_path2.default.posix.join(entryDirectory, key);
+    const experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths?.get(key);
     prerenders[outputPathPage] = new import_build_utils.Prerender({
       expiration: initialRevalidate,
       lambda,
@@ -10812,6 +10917,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
       initialStatus,
       initialHeaders,
       sourcePath,
+      experimentalStreamingLambdaPath,
       ...isNotFound ? {
         initialStatus: 404
       } : {},
@@ -10822,8 +10928,16 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
         }
       } : {}
     });
-    if (outputPathData) {
-      prerenders[outputPathData] = new import_build_utils.Prerender({
+    if (outputPrerenderPathData) {
+      let normalizedPathData = outputPrerenderPathData;
+      if ((srcRoute === "/" || srcRoute == "/index") && outputPrerenderPathData.endsWith(RSC_PREFETCH_SUFFIX)) {
+        delete lambdas[normalizedPathData];
+        normalizedPathData = normalizedPathData.replace(
+          /([^/]+\.prefetch\.rsc)$/,
+          "__$1"
+        );
+      }
+      prerenders[normalizedPathData] = new import_build_utils.Prerender({
         expiration: initialRevalidate,
         lambda,
         allowQuery,
@@ -10837,7 +10951,9 @@ var onPrerenderRoute = (prerenderRouteArgs) => (routeKey, {
         ...rscEnabled ? {
           initialHeaders: {
             "content-type": rscContentTypeHeader,
-            vary: rscVaryHeader
+            vary: rscVaryHeader,
+            // If it contains a pre-render, then it was postponed.
+            ...prerender && rscDidPostponeHeader ? { [rscDidPostponeHeader]: "1" } : {}
           }
         } : {}
       });
@@ -11877,13 +11993,16 @@ async function serverBuild({
       inversedAppPathManifest[appPathRoutesManifest[ogRoute]] = ogRoute;
     }
   }
+  const experimental = {
+    ppr: requiredServerFilesManifest.config.experimental?.ppr === true
+  };
   let appRscPrefetches = {};
   let appBuildTraces = {};
   let appDir = null;
   if (appPathRoutesManifest) {
     appDir = import_path4.default.join(pagesDir, "../app");
     appBuildTraces = await (0, import_build_utils2.glob)("**/*.js.nft.json", appDir);
-    appRscPrefetches = await (0, import_build_utils2.glob)(`**/*${RSC_PREFETCH_SUFFIX}`, appDir);
+    appRscPrefetches = experimental.ppr ? {} : await (0, import_build_utils2.glob)(`**/*${RSC_PREFETCH_SUFFIX}`, appDir);
     const rscContentTypeHeader = routesManifest?.rsc?.contentTypeHeader || RSC_CONTENT_TYPE;
     appRscPrefetches = normalizePrefetches(appRscPrefetches);
     for (const value of Object.values(appRscPrefetches)) {
@@ -11952,6 +12071,16 @@ async function serverBuild({
   if (lambdaPages["404.js"]) {
     internalPages.push("404.js");
   }
+  const experimentalPPRRoutes = /* @__PURE__ */ new Set();
+  for (const [route, { experimentalPPR }] of [
+    ...Object.entries(prerenderManifest.staticRoutes),
+    ...Object.entries(prerenderManifest.blockingFallbackRoutes),
+    ...Object.entries(prerenderManifest.fallbackRoutes)
+  ]) {
+    if (!experimentalPPR)
+      continue;
+    experimentalPPRRoutes.add(route);
+  }
   const prerenderRoutes = /* @__PURE__ */ new Set([
     ...canUsePreviewMode ? omittedPrerenderRoutes : [],
     ...Object.keys(prerenderManifest.blockingFallbackRoutes),
@@ -11961,6 +12090,7 @@ async function serverBuild({
       return staticRoute.srcRoute || route;
     })
   ]);
+  const experimentalStreamingLambdaPaths = /* @__PURE__ */ new Map();
   if (hasLambdas) {
     const initialTracingLabel = "Traced Next.js server files in";
     console.time(initialTracingLabel);
@@ -12206,8 +12336,8 @@ async function serverBuild({
       "utf8"
     );
     let launcher = launcherData.replace(
-      "conf: __NEXT_CONFIG__",
-      `conf: ${JSON.stringify({
+      "const conf = __NEXT_CONFIG__",
+      `const conf = ${JSON.stringify({
         ...requiredServerFilesManifest.config,
         distDir: import_path4.default.relative(
           projectDir,
@@ -12354,6 +12484,7 @@ async function serverBuild({
       prerenderRoutes,
       pageTraces,
       compressedPages,
+      experimentalPPRRoutes: void 0,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
       lambdaCompressedByteLimit,
@@ -12372,6 +12503,7 @@ async function serverBuild({
       prerenderRoutes,
       pageTraces,
       compressedPages,
+      experimentalPPRRoutes,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
       lambdaCompressedByteLimit,
@@ -12387,6 +12519,7 @@ async function serverBuild({
       prerenderRoutes,
       pageTraces,
       compressedPages,
+      experimentalPPRRoutes: void 0,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
       lambdaCompressedByteLimit,
@@ -12395,7 +12528,7 @@ async function serverBuild({
       pageExtensions
     });
     for (const group of appRouterLambdaGroups) {
-      if (!group.isPrerenders) {
+      if (!group.isPrerenders || group.isExperimentalPPR) {
         group.isStreaming = true;
       }
       group.isAppRouter = true;
@@ -12415,6 +12548,7 @@ async function serverBuild({
       prerenderRoutes,
       pageTraces,
       compressedPages,
+      experimentalPPRRoutes: void 0,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
       initialPseudoLayerUncompressed: uncompressedInitialSize,
@@ -12529,7 +12663,7 @@ async function serverBuild({
         [import_path4.default.join(import_path4.default.relative(baseDir, projectDir), "___next_launcher.cjs")]: new import_build_utils2.FileBlob({ data: group.isAppRouter ? appLauncher : launcher })
       };
       const operationType = getOperationType({ group, prerenderManifest });
-      const lambda = await createLambdaFromPseudoLayers({
+      const options = {
         files: {
           ...launcherFiles,
           ...updatedManifestFiles
@@ -12545,7 +12679,19 @@ async function serverBuild({
         maxDuration: group.maxDuration,
         isStreaming: group.isStreaming,
         nextVersion
-      });
+      };
+      const lambda = await createLambdaFromPseudoLayers(options);
+      const isPPR = experimental.ppr && group.isAppRouter && !group.isAppRouteHandler;
+      let revalidate;
+      if (isPPR) {
+        if (isPPR && !options.isStreaming) {
+          throw new Error("Invariant: PPR lambda isn't streaming");
+        }
+        revalidate = await createLambdaFromPseudoLayers({
+          ...options,
+          isStreaming: false
+        });
+      }
       for (const page of group.pages) {
         const pageNoExt = page.replace(/\.js$/, "");
         let isPrerender = prerenderRoutes.has(
@@ -12558,10 +12704,25 @@ async function serverBuild({
             );
           });
         }
-        const outputName = normalizeIndexOutput(
+        let outputName = normalizeIndexOutput(
           import_path4.default.posix.join(entryDirectory, pageNoExt),
           true
         );
+        if (isPPR) {
+          if (!revalidate) {
+            throw new Error("Invariant: PPR lambda isn't set");
+          }
+          outputName = import_path4.default.posix.join(entryDirectory, pageNoExt);
+          lambdas[outputName] = revalidate;
+          const pprOutputName = import_path4.default.posix.join(
+            entryDirectory,
+            "/_next/postponed/resume",
+            pageNoExt
+          );
+          lambdas[pprOutputName] = lambda;
+          experimentalStreamingLambdaPaths.set(outputName, pprOutputName);
+          continue;
+        }
         if (i18n && !isPrerender && !group.isAppRouter && (!isCorrectLocaleAPIRoutes || !(pageNoExt === "api" || pageNoExt.startsWith("api/")))) {
           for (const locale of i18n.locales) {
             lambdas[normalizeIndexOutput(
@@ -12585,6 +12746,7 @@ async function serverBuild({
     pagesDir,
     pageLambdaMap: {},
     lambdas,
+    experimentalStreamingLambdaPaths,
     prerenders,
     entryDirectory,
     routesManifest,
@@ -12599,21 +12761,31 @@ async function serverBuild({
     isCorrectNotFoundRoutes,
     isEmptyAllowQueryForPrendered
   });
-  Object.keys(prerenderManifest.staticRoutes).forEach(
-    (route) => prerenderRoute(route, {})
+  await Promise.all(
+    Object.keys(prerenderManifest.staticRoutes).map(
+      (route) => prerenderRoute(route, {})
+    )
   );
-  Object.keys(prerenderManifest.fallbackRoutes).forEach(
-    (route) => prerenderRoute(route, { isFallback: true })
+  await Promise.all(
+    Object.keys(prerenderManifest.fallbackRoutes).map(
+      (route) => prerenderRoute(route, { isFallback: true })
+    )
   );
-  Object.keys(prerenderManifest.blockingFallbackRoutes).forEach(
-    (route) => prerenderRoute(route, { isBlocking: true })
+  await Promise.all(
+    Object.keys(prerenderManifest.blockingFallbackRoutes).map(
+      (route) => prerenderRoute(route, { isBlocking: true })
+    )
   );
   if (static404Page && canUsePreviewMode) {
-    omittedPrerenderRoutes.forEach((route) => {
-      prerenderRoute(route, { isOmitted: true });
-    });
+    await Promise.all(
+      [...omittedPrerenderRoutes].map((route) => {
+        return prerenderRoute(route, { isOmitted: true });
+      })
+    );
   }
   prerenderRoutes.forEach((route) => {
+    if (experimentalPPRRoutes.has(route))
+      return;
     if (routesManifest?.i18n) {
       route = normalizeLocalePath(route, routesManifest.i18n.locales).pathname;
     }
@@ -12643,7 +12815,8 @@ async function serverBuild({
     canUsePreviewMode,
     prerenderManifest.bypassToken || "",
     true,
-    middleware.dynamicRouteMap
+    middleware.dynamicRouteMap,
+    experimental.ppr
   ).then(
     (arr) => localizeDynamicRoutes(
       arr,
@@ -12783,20 +12956,20 @@ async function serverBuild({
   }
   if (appPathRoutesManifest) {
     const edgeFunctions = middleware.edgeFunctions;
-    for (let route of Object.values(appPathRoutesManifest)) {
+    for (const route of Object.values(appPathRoutesManifest)) {
       const ogRoute = inversedAppPathManifest[route];
       if (ogRoute.endsWith("/route")) {
         continue;
       }
-      route = normalizeIndexOutput(
+      const pathname = normalizeIndexOutput(
         import_path4.default.posix.join("./", entryDirectory, route === "/" ? "/index" : route),
         true
       );
-      if (lambdas[route]) {
-        lambdas[`${route}.rsc`] = lambdas[route];
+      if (lambdas[pathname]) {
+        lambdas[`${pathname}.rsc`] = lambdas[pathname];
       }
-      if (edgeFunctions[route]) {
-        edgeFunctions[`${route}.rsc`] = edgeFunctions[route];
+      if (edgeFunctions[pathname]) {
+        edgeFunctions[`${pathname}.rsc`] = edgeFunctions[pathname];
       }
     }
   }
@@ -12809,6 +12982,9 @@ async function serverBuild({
     ...value,
     metadata: value.metadata ?? {}
   })) : [];
+  if (experimental.ppr && !rscPrefetchHeader) {
+    throw new Error("Invariant: cannot use PPR without 'rsc.prefetchHeader'");
+  }
   return {
     wildcard: wildcardConfig,
     images: getImagesConfig(imagesManifest),
@@ -13091,7 +13267,7 @@ async function serverBuild({
           check: true
         }
       ] : [],
-      ...rscPrefetchHeader ? [
+      ...rscPrefetchHeader && !experimental.ppr ? [
         {
           src: import_path4.default.posix.join(
             "/",
@@ -13114,7 +13290,11 @@ async function serverBuild({
             entryDirectory,
             `/(.+?)${RSC_PREFETCH_SUFFIX}(?:/)?$`
           )}`,
-          dest: import_path4.default.posix.join("/", entryDirectory, "/$1.rsc"),
+          dest: import_path4.default.posix.join(
+            "/",
+            entryDirectory,
+            `/$1${experimental.ppr ? RSC_PREFETCH_SUFFIX : ".rsc"}`
+          ),
           has: [
             {
               type: "header",
@@ -13285,8 +13465,6 @@ async function serverBuild({
         continue: true,
         important: true
       },
-      // TODO: remove below workaround when `/` is allowed to be output
-      // different than `/index`
       {
         src: import_path4.default.posix.join("/", entryDirectory, "/index"),
         headers: {
@@ -14472,7 +14650,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         lambdaCompressedByteLimit,
         // internal pages are already referenced in traces for serverless
         // like builds
-        internalPages: []
+        internalPages: [],
+        experimentalPPRRoutes: void 0
       });
       const initialApiLambdaGroups = await getPageLambdaGroups({
         entryPath,
@@ -14486,7 +14665,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         initialPseudoLayer: { pseudoLayer: {}, pseudoLayerBytes: 0 },
         initialPseudoLayerUncompressed: 0,
         lambdaCompressedByteLimit,
-        internalPages: []
+        internalPages: [],
+        experimentalPPRRoutes: void 0
       });
       for (const group of initialApiLambdaGroups) {
         group.isApiLambda = true;
@@ -14894,6 +15074,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       static404Page,
       pageLambdaMap,
       lambdas,
+      experimentalStreamingLambdaPaths: void 0,
       isServerMode,
       prerenders,
       entryDirectory,
@@ -14921,20 +15102,40 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       [
         ...Object.entries(prerenderManifest.fallbackRoutes),
         ...Object.entries(prerenderManifest.blockingFallbackRoutes)
-      ].forEach(([, { dataRouteRegex, dataRoute }]) => {
-        if (!dataRoute || !dataRouteRegex)
-          return;
-        dataRoutes.push({
-          // Next.js provided data route regex
-          src: dataRouteRegex.replace(
-            /^\^/,
-            `^${appMountPrefixNoTrailingSlash}`
-          ),
-          // Location of lambda in builder output
-          dest: import_path5.default.posix.join(entryDirectory, dataRoute),
-          check: true
-        });
-      });
+      ].forEach(
+        ([
+          ,
+          {
+            dataRouteRegex,
+            dataRoute,
+            prefetchDataRouteRegex,
+            prefetchDataRoute
+          }
+        ]) => {
+          if (!dataRoute || !dataRouteRegex)
+            return;
+          dataRoutes.push({
+            // Next.js provided data route regex
+            src: dataRouteRegex.replace(
+              /^\^/,
+              `^${appMountPrefixNoTrailingSlash}`
+            ),
+            // Location of lambda in builder output
+            dest: import_path5.default.posix.join(entryDirectory, dataRoute),
+            check: true
+          });
+          if (!prefetchDataRoute || !prefetchDataRouteRegex)
+            return;
+          dataRoutes.push({
+            src: prefetchDataRouteRegex.replace(
+              /^\^/,
+              `^${appMountPrefixNoTrailingSlash}`
+            ),
+            dest: import_path5.default.posix.join(entryDirectory, prefetchDataRoute),
+            check: true
+          });
+        }
+      );
     }
   }
   if (!isSharedLambdas) {

package/dist/server-launcher.js

@@ -12,20 +12,23 @@ if (process.env.NODE_ENV !== "production" && region !== "dev1") {
 }
 // @preserve pre-next-server-target
 const NextServer = require("__NEXT_SERVER_PATH__").default;
+const conf = __NEXT_CONFIG__;
 const nextServer = new NextServer({
-  // @ts-ignore __NEXT_CONFIG__ value is injected
-  conf: __NEXT_CONFIG__,
+  conf,
   dir: ".",
   minimalMode: true,
   customServer: false
 });
-const requestHandler = nextServer.getRequestHandler();
-module.exports = async (req, res) => {
+const serve = (handler) => async (req, res) => {
   try {
     // @preserve entryDirectory handler
-    await requestHandler(req, res);
+    await handler(req, res);
   } catch (err) {
     console.error(err);
     process.exit(1);
   }
 };
+module.exports = serve(nextServer.getRequestHandler());
+if (conf.experimental?.ppr && "getRequestHandlerWithMetadata" in nextServer && typeof nextServer.getRequestHandlerWithMetadata === "function") {
+  module.exports.getRequestHandlerWithMetadata = (metadata) => serve(nextServer.getRequestHandlerWithMetadata(metadata));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.0.12",
+  "version": "4.0.14",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",