@vercel/next 4.1.3 → 4.1.4

package/dist/index.js

@@ -9677,7 +9677,19 @@ async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
   }
   return routesManifest;
 }
-async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes, canUsePreviewMode, bypassToken, isServerMode, dynamicMiddlewareRouteMap, experimentalPPR) {
+async function getDynamicRoutes({
+  entryPath,
+  entryDirectory,
+  dynamicPages,
+  isDev,
+  routesManifest,
+  omittedRoutes,
+  canUsePreviewMode,
+  bypassToken,
+  isServerMode,
+  dynamicMiddlewareRouteMap,
+  experimentalPPRRoutes
+}) {
   if (routesManifest) {
     switch (routesManifest.version) {
       case 1:
@@ -9730,7 +9742,7 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
               }
             ];
           }
-          if (experimentalPPR) {
+          if (experimentalPPRRoutes.has(page)) {
             let dest = route.dest?.replace(/($|\?)/, ".prefetch.rsc$1");
             if (page === "/" || page === "/index") {
               dest = dest?.replace(/([^/]+\.prefetch\.rsc(\?.*|$))/, "__$1");
@@ -10628,7 +10640,8 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     pageLambdaMap,
     routesManifest,
     isCorrectNotFoundRoutes,
-    isEmptyAllowQueryForPrendered
+    isEmptyAllowQueryForPrendered,
+    omittedPrerenderRoutes
   } = prerenderRouteArgs;
   if (isBlocking && isFallback) {
     throw new import_build_utils.NowBuildError({
@@ -10910,17 +10923,23 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     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 /");
+    let experimentalStreamingLambdaPath;
+    if (experimentalPPR) {
+      if (!experimentalStreamingLambdaPaths) {
+        throw new Error(
+          "Invariant: experimentalStreamingLambdaPaths doesn't exist"
+        );
+      }
+      if (srcRoute && !omittedPrerenderRoutes.has(srcRoute)) {
+        experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths.get(
+          pathnameToOutputName(entryDirectory, srcRoute)
+        );
+      } else {
+        experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths.get(
+          pathnameToOutputName(entryDirectory, routeKey)
+        );
       }
-      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,
@@ -11076,6 +11095,16 @@ function normalizeIndexOutput(outputName, isServerMode) {
 function getNextServerPath(nextVersion) {
   return import_semver.default.gte(nextVersion, "v11.0.2-canary.4") ? "next/dist/server" : "next/dist/next-server/server";
 }
+function pathnameToOutputName(entryDirectory, pathname) {
+  if (pathname === "/")
+    pathname = "/index";
+  return import_path2.default.posix.join(entryDirectory, pathname);
+}
+function getPostponeResumePathname(entryDirectory, pathname) {
+  if (pathname === "/")
+    pathname = "/index";
+  return import_path2.default.posix.join(entryDirectory, "_next/postponed/resume", pathname);
+}
 function updateRouteSrc(route, index, manifestItems) {
   if (route.src) {
     route.src = manifestItems[index].regex;
@@ -12017,7 +12046,8 @@ async function serverBuild({
   isCorrectLocaleAPIRoutes,
   lambdaCompressedByteLimit,
   requiredServerFilesManifest,
-  variantsManifest
+  variantsManifest,
+  experimentalPPRRoutes
 }) {
   lambdaPages = Object.assign({}, lambdaPages, lambdaAppPaths);
   const experimentalAllowBundling = Boolean(
@@ -12127,16 +12157,6 @@ 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),
@@ -12778,7 +12798,7 @@ async function serverBuild({
       const isPPR = experimental.ppr && group.isAppRouter && !group.isAppRouteHandler;
       let revalidate;
       if (isPPR) {
-        if (isPPR && !options.isStreaming) {
+        if (!options.isStreaming) {
           throw new Error("Invariant: PPR lambda isn't streaming");
         }
         revalidate = await createLambdaFromPseudoLayers({
@@ -12786,44 +12806,58 @@ async function serverBuild({
           isStreaming: false
         });
       }
-      for (const page of group.pages) {
-        const pageNoExt = page.replace(/\.js$/, "");
-        let isPrerender = prerenderRoutes.has(
-          import_path4.default.join("/", pageNoExt === "index" ? "" : pageNoExt)
-        );
+      for (const pageFilename of group.pages) {
+        const pageName = pageFilename.replace(/\.js$/, "");
+        const pagePath = import_path4.default.posix.join("/", pageName);
+        const pagePathname = pagePath === "/index" ? "/" : pagePath;
+        let isPrerender = prerenderRoutes.has(pagePathname);
         if (!isPrerender && routesManifest?.i18n) {
           isPrerender = routesManifest.i18n.locales.some((locale) => {
             return prerenderRoutes.has(
-              import_path4.default.join("/", locale, pageNoExt === "index" ? "" : pageNoExt)
+              import_path4.default.join("/", locale, pageName === "index" ? "" : pageName)
             );
           });
         }
-        let outputName = import_path4.default.posix.join(entryDirectory, pageNoExt);
-        if (!group.isAppRouter && !group.isAppRouteHandler) {
-          outputName = normalizeIndexOutput(outputName, true);
-        }
+        let outputName = import_path4.default.posix.join(entryDirectory, pageName);
         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);
+          if (!omittedPrerenderRoutes.has(pagePathname)) {
+            const key = getPostponeResumePathname(entryDirectory, pageName);
+            lambdas[key] = lambda;
+            experimentalStreamingLambdaPaths.set(outputName, key);
+          } else {
+            for (const [
+              routePathname,
+              { srcRoute, experimentalPPR }
+            ] of Object.entries(prerenderManifest.staticRoutes)) {
+              if (srcRoute !== pagePathname || !experimentalPPR)
+                continue;
+              if (routePathname === pagePathname)
+                continue;
+              const key = getPostponeResumePathname(
+                entryDirectory,
+                routePathname
+              );
+              lambdas[key] = lambda;
+              outputName = import_path4.default.posix.join(entryDirectory, routePathname);
+              experimentalStreamingLambdaPaths.set(outputName, key);
+            }
+          }
           continue;
         }
-        if (i18n && !isPrerender && !group.isAppRouter && (!isCorrectLocaleAPIRoutes || !(pageNoExt === "api" || pageNoExt.startsWith("api/")))) {
+        if (!group.isAppRouter && !group.isAppRouteHandler) {
+          outputName = normalizeIndexOutput(outputName, true);
+        }
+        if (i18n && !isPrerender && !group.isAppRouter && (!isCorrectLocaleAPIRoutes || !(pageName === "api" || pageName.startsWith("api/")))) {
           for (const locale of i18n.locales) {
             lambdas[normalizeIndexOutput(
               import_path4.default.posix.join(
                 entryDirectory,
                 locale,
-                pageNoExt === "index" ? "" : pageNoExt
+                pageName === "index" ? "" : pageName
               ),
               true
             )] = lambda;
@@ -12853,7 +12887,8 @@ async function serverBuild({
     localePrefixed404,
     hasPages404: routesManifest.pages404,
     isCorrectNotFoundRoutes,
-    isEmptyAllowQueryForPrendered
+    isEmptyAllowQueryForPrendered,
+    omittedPrerenderRoutes
   });
   await Promise.all(
     Object.keys(prerenderManifest.staticRoutes).map(
@@ -12872,9 +12907,9 @@ async function serverBuild({
   );
   if (static404Page && canUsePreviewMode) {
     await Promise.all(
-      [...omittedPrerenderRoutes].map((route) => {
-        return prerenderRoute(route, { isOmitted: true });
-      })
+      Array.from(omittedPrerenderRoutes).map(
+        (route) => prerenderRoute(route, { isOmitted: true })
+      )
     );
   }
   prerenderRoutes.forEach((route) => {
@@ -12899,19 +12934,19 @@ async function serverBuild({
     appPathRoutesManifest: appPathRoutesManifest || {}
   });
   const isNextDataServerResolving = middleware.staticRoutes.length > 0 && import_semver3.default.gte(nextVersion, NEXT_DATA_MIDDLEWARE_RESOLVING_VERSION);
-  const dynamicRoutes = await getDynamicRoutes(
+  const dynamicRoutes = await getDynamicRoutes({
     entryPath,
     entryDirectory,
     dynamicPages,
-    false,
+    isDev: false,
     routesManifest,
-    omittedPrerenderRoutes,
+    omittedRoutes: omittedPrerenderRoutes,
     canUsePreviewMode,
-    prerenderManifest.bypassToken || "",
-    true,
-    middleware.dynamicRouteMap,
-    experimental.ppr
-  ).then(
+    bypassToken: prerenderManifest.bypassToken || "",
+    isServerMode: true,
+    dynamicMiddlewareRouteMap: middleware.dynamicRouteMap,
+    experimentalPPRRoutes
+  }).then(
     (arr) => localizeDynamicRoutes(
       arr,
       dynamicPrefix,
@@ -13080,6 +13115,28 @@ async function serverBuild({
   if (experimental.ppr && !rscPrefetchHeader) {
     throw new Error("Invariant: cannot use PPR without 'rsc.prefetchHeader'");
   }
+  if (experimental.ppr) {
+    for (const { srcRoute, dataRoute, experimentalPPR } of Object.values(
+      prerenderManifest.staticRoutes
+    )) {
+      if (!experimentalPPR || !dataRoute || !srcRoute)
+        continue;
+      if (!omittedPrerenderRoutes.has(srcRoute))
+        continue;
+      const srcPathname = srcRoute.substring(1);
+      const dataPathname = dataRoute.substring(1);
+      const dataPathnameExists = dataPathname in lambdas;
+      if (dataPathnameExists)
+        continue;
+      const srcPathnameExists = srcPathname in lambdas;
+      if (!srcPathnameExists) {
+        throw new Error(
+          `Invariant: Expected to have a lambda for the source route: ${srcPathname}`
+        );
+      }
+      lambdas[dataPathname] = lambdas[srcPathname];
+    }
+  }
   return {
     wildcard: wildcardConfig,
     images: getImagesConfig(imagesManifest),
@@ -14546,6 +14603,17 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         }
       }
     }
+    const experimentalPPRRoutes = /* @__PURE__ */ new Set();
+    for (const [route, { experimentalPPR }] of [
+      ...Object.entries(prerenderManifest.staticRoutes),
+      ...Object.entries(prerenderManifest.blockingFallbackRoutes),
+      ...Object.entries(prerenderManifest.fallbackRoutes),
+      ...Object.entries(prerenderManifest.omittedRoutes)
+    ]) {
+      if (!experimentalPPR)
+        continue;
+      experimentalPPRRoutes.add(route);
+    }
     if (requiredServerFilesManifest) {
       if (!routesManifest) {
         throw new Error(
@@ -14593,7 +14661,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         privateOutputs,
         hasIsr404Page,
         hasIsr500Page,
-        variantsManifest
+        variantsManifest,
+        experimentalPPRRoutes
       });
     }
     const pageKeys = Object.keys(pages);
@@ -14982,17 +15051,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         })
       );
     }
-    dynamicRoutes = await getDynamicRoutes(
+    dynamicRoutes = await getDynamicRoutes({
       entryPath,
       entryDirectory,
       dynamicPages,
-      false,
+      isDev: false,
       routesManifest,
-      omittedPrerenderRoutes,
+      omittedRoutes: omittedPrerenderRoutes,
       canUsePreviewMode,
-      prerenderManifest.bypassToken || "",
-      isServerMode
-    ).then(
+      bypassToken: prerenderManifest.bypassToken || "",
+      isServerMode,
+      experimentalPPRRoutes
+    }).then(
       (arr) => localizeDynamicRoutes(
         arr,
         dynamicPrefix,
@@ -15007,17 +15077,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     if (isSharedLambdas) {
       const launcherPath2 = import_path5.default.join(__dirname, "templated-launcher-shared.js");
       const launcherData2 = await (0, import_fs_extra6.readFile)(launcherPath2, "utf8");
-      const completeDynamicRoutes = await getDynamicRoutes(
+      const completeDynamicRoutes = await getDynamicRoutes({
         entryPath,
         entryDirectory,
         dynamicPages,
-        false,
+        isDev: false,
         routesManifest,
-        void 0,
+        omittedRoutes: void 0,
         canUsePreviewMode,
-        prerenderManifest.bypassToken || "",
-        isServerMode
-      ).then(
+        bypassToken: prerenderManifest.bypassToken || "",
+        isServerMode,
+        experimentalPPRRoutes
+      }).then(
         (arr) => arr.map((route) => {
           route.src = route.src.replace("^", `^${dynamicPrefix}`);
           return route;
@@ -15194,21 +15265,30 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       prerenderManifest,
       appPathRoutesManifest,
       isSharedLambdas,
-      canUsePreviewMode
+      canUsePreviewMode,
+      omittedPrerenderRoutes
     });
-    Object.keys(prerenderManifest.staticRoutes).forEach(
-      (route) => prerenderRoute(route, { isBlocking: false, isFallback: false })
+    await Promise.all(
+      Object.keys(prerenderManifest.staticRoutes).map(
+        (route) => prerenderRoute(route, {})
+      )
     );
-    Object.keys(prerenderManifest.fallbackRoutes).forEach(
-      (route) => prerenderRoute(route, { isBlocking: false, 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, isFallback: false })
+    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(
+        Array.from(omittedPrerenderRoutes).map(
+          (route) => prerenderRoute(route, { isOmitted: true })
+        )
+      );
     }
     if (!(routesManifest && routesManifest.dataRoutes)) {
       [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -30,7 +30,7 @@
     "@types/semver": "6.0.0",
     "@types/text-table": "0.2.1",
     "@types/webpack-sources": "3.2.0",
-    "@vercel/build-utils": "7.7.0",
+    "@vercel/build-utils": "7.7.1",
     "@vercel/routing-utils": "3.1.0",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",