@vercel/next 4.3.10 → 4.3.12

package/dist/index.js

@@ -10623,6 +10623,7 @@ function getImagesConfig(imagesManifest) {
     domains: imagesManifest.images.domains,
     sizes: imagesManifest.images.sizes,
     remotePatterns: imagesManifest.images.remotePatterns,
+    localPatterns: imagesManifest.images.localPatterns,
     minimumCacheTTL: imagesManifest.images.minimumCacheTTL,
     formats: imagesManifest.images.formats,
     dangerouslyAllowSVG: imagesManifest.images.dangerouslyAllowSVG,
@@ -11114,7 +11115,8 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
         ret.staticRoutes[route] = {
           initialRevalidate: initialRevalidateSeconds === false ? false : Math.max(1, initialRevalidateSeconds),
           dataRoute,
-          srcRoute
+          srcRoute,
+          renderingMode: "STATIC" /* STATIC */
         };
       });
       lazyRoutes.forEach((lazyRoute) => {
@@ -11124,13 +11126,15 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
             routeRegex,
             fallback,
             dataRoute,
-            dataRouteRegex
+            dataRouteRegex,
+            renderingMode: "STATIC" /* STATIC */
           };
         } else {
           ret.blockingFallbackRoutes[lazyRoute] = {
             routeRegex,
             dataRoute,
-            dataRouteRegex
+            dataRouteRegex,
+            renderingMode: "STATIC" /* STATIC */
           };
         }
       });
@@ -11158,14 +11162,16 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
         let initialStatus;
         let initialHeaders;
         let experimentalBypassFor;
-        let experimentalPPR;
         let prefetchDataRoute;
+        let renderingMode;
         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;
+          renderingMode = manifest.routes[route].renderingMode ?? (manifest.routes[route].experimentalPPR ? "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ : "STATIC" /* STATIC */);
+        } else {
+          renderingMode = "STATIC" /* STATIC */;
         }
         ret.staticRoutes[route] = {
           initialRevalidate: initialRevalidateSeconds === false ? false : Math.max(1, initialRevalidateSeconds),
@@ -11175,29 +11181,30 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
           initialStatus,
           initialHeaders,
           experimentalBypassFor,
-          experimentalPPR
+          renderingMode
         };
       });
       lazyRoutes.forEach((lazyRoute) => {
         const { routeRegex, fallback, dataRoute, dataRouteRegex } = manifest.dynamicRoutes[lazyRoute];
         let experimentalBypassFor;
-        let experimentalPPR;
         let prefetchDataRoute;
         let prefetchDataRouteRegex;
         let fallbackStatus;
         let fallbackHeaders;
+        let renderingMode = "STATIC" /* STATIC */;
         if (manifest.version === 4) {
           experimentalBypassFor = manifest.dynamicRoutes[lazyRoute].experimentalBypassFor;
-          experimentalPPR = manifest.dynamicRoutes[lazyRoute].experimentalPPR;
           prefetchDataRoute = manifest.dynamicRoutes[lazyRoute].prefetchDataRoute;
           prefetchDataRouteRegex = manifest.dynamicRoutes[lazyRoute].prefetchDataRouteRegex;
           fallbackStatus = manifest.dynamicRoutes[lazyRoute].fallbackStatus;
           fallbackHeaders = manifest.dynamicRoutes[lazyRoute].fallbackHeaders;
+          renderingMode = manifest.dynamicRoutes[lazyRoute].renderingMode ?? // By default, when the rendering mode isn't specified, fallback to
+          // using the `experimentalPPR` flag.
+          (manifest.dynamicRoutes[lazyRoute].experimentalPPR ? "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ : "STATIC" /* STATIC */);
         }
         if (typeof fallback === "string") {
           ret.fallbackRoutes[lazyRoute] = {
             experimentalBypassFor,
-            experimentalPPR,
             routeRegex,
             fallback,
             fallbackStatus,
@@ -11205,27 +11212,28 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
             dataRoute,
             dataRouteRegex,
             prefetchDataRoute,
-            prefetchDataRouteRegex
+            prefetchDataRouteRegex,
+            renderingMode
           };
         } else if (fallback === null) {
           ret.blockingFallbackRoutes[lazyRoute] = {
             experimentalBypassFor,
-            experimentalPPR,
             routeRegex,
             dataRoute,
             dataRouteRegex,
             prefetchDataRoute,
-            prefetchDataRouteRegex
+            prefetchDataRouteRegex,
+            renderingMode
           };
         } else {
           ret.omittedRoutes[lazyRoute] = {
             experimentalBypassFor,
-            experimentalPPR,
             routeRegex,
             dataRoute,
             dataRouteRegex,
             prefetchDataRoute,
-            prefetchDataRouteRegex
+            prefetchDataRouteRegex,
+            renderingMode
           };
         }
       });
@@ -11671,7 +11679,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
   let initialStatus;
   let initialHeaders;
   let experimentalBypassFor;
-  let experimentalPPR;
+  let renderingMode;
   if (isFallback || isBlocking) {
     const pr = isFallback ? prerenderManifest.fallbackRoutes[routeKey] : prerenderManifest.blockingFallbackRoutes[routeKey];
     initialRevalidate = 1;
@@ -11684,14 +11692,14 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     srcRoute = null;
     dataRoute = pr.dataRoute;
     experimentalBypassFor = pr.experimentalBypassFor;
-    experimentalPPR = pr.experimentalPPR;
+    renderingMode = pr.renderingMode;
     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;
+    renderingMode = prerenderManifest.omittedRoutes[routeKey].renderingMode;
     prefetchDataRoute = prerenderManifest.omittedRoutes[routeKey].prefetchDataRoute;
   } else {
     const pr = prerenderManifest.staticRoutes[routeKey];
@@ -11702,12 +11710,12 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       initialHeaders,
       initialStatus,
       experimentalBypassFor,
-      experimentalPPR,
+      renderingMode,
       prefetchDataRoute
     } = pr);
   }
   let isAppPathRoute = false;
-  if (appDir && experimentalPPR) {
+  if (appDir && renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */) {
     isAppPathRoute = true;
     if (isFallback) {
       const { fallbackStatus, fallbackHeaders } = prerenderManifest.fallbackRoutes[routeKey];
@@ -11725,7 +11733,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
   const isOmittedOrNotFound = isOmitted || isNotFound;
   let htmlFsRef = null;
   let postponedPrerender;
-  if (experimentalPPR && appDir) {
+  if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ && 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)) {
@@ -11797,7 +11805,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
           // be from the prefetch data route. If this isn't enabled
           // for ppr, the only way to get the data is from the data
           // route.
-          experimentalPPR ? prefetchDataRoute : dataRoute
+          renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ ? prefetchDataRoute : dataRoute
         ) : routeFileNoExt + ".json"}`
       )
     })
@@ -11839,7 +11847,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       );
     }
     outputPathPrefetchData = normalizeDataRoute(prefetchDataRoute);
-  } else if (experimentalPPR) {
+  } else if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */) {
     throw new Error("Invariant: expected to find prefetch data route PPR");
   }
   if (isSharedLambdas) {
@@ -11881,7 +11889,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       if (outputPathPrefetchData) {
         prerenders[outputPathPrefetchData] = jsonFsRef;
       }
-      if (outputPathData && !experimentalPPR) {
+      if (outputPathData && renderingMode !== "PARTIALLY_STATIC" /* PARTIALLY_STATIC */) {
         prerenders[outputPathData] = jsonFsRef;
       }
     }
@@ -11923,26 +11931,34 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     if (`/${outputPathPage}` !== srcRoute && srcRoute) {
       sourcePath = srcRoute;
     }
+    let chain;
     let experimentalStreamingLambdaPath;
-    if (experimentalPPR) {
-      if (!experimentalStreamingLambdaPaths) {
-        throw new Error(
-          "Invariant: experimentalStreamingLambdaPaths doesn't exist"
-        );
-      }
-      experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths.get(
+    if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ && experimentalStreamingLambdaPaths) {
+      let paths = experimentalStreamingLambdaPaths.get(
         pathnameToOutputName(entryDirectory, routeKey)
       );
-      if (!experimentalStreamingLambdaPath && srcRoute) {
-        experimentalStreamingLambdaPath = experimentalStreamingLambdaPaths.get(
+      if (!paths && srcRoute) {
+        paths = experimentalStreamingLambdaPaths.get(
           pathnameToOutputName(entryDirectory, srcRoute)
         );
       }
-      if (!experimentalStreamingLambdaPath) {
+      if (!paths) {
         throw new Error(
           `Invariant: experimentalStreamingLambdaPath is undefined for routeKey=${routeKey} and srcRoute=${srcRoute ?? "null"}`
         );
       }
+      experimentalStreamingLambdaPath = paths.output;
+      if (routesManifest?.ppr?.chain?.headers) {
+        chain = {
+          outputPath: pathnameToOutputName(entryDirectory, routeKey),
+          headers: routesManifest.ppr.chain.headers
+        };
+      } else {
+        chain = {
+          outputPath: paths.output,
+          headers: { "x-matched-path": paths.pathname }
+        };
+      }
     }
     prerenders[outputPathPage] = new import_build_utils.Prerender({
       expiration: initialRevalidate,
@@ -11956,6 +11972,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       initialHeaders,
       sourcePath,
       experimentalStreamingLambdaPath,
+      chain,
       ...isNotFound ? {
         initialStatus: 404
       } : {},
@@ -12004,7 +12021,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       if (outputPathPrefetchData) {
         prerenders[normalizePathData(outputPathPrefetchData)] = prerender;
       }
-      if (outputPathData && !experimentalPPR) {
+      if (outputPathData && renderingMode !== "PARTIALLY_STATIC" /* PARTIALLY_STATIC */) {
         prerenders[normalizePathData(outputPathData)] = prerender;
       }
     }
@@ -12127,7 +12144,12 @@ function pathnameToOutputName(entryDirectory, pathname) {
   }
   return import_path2.default.posix.join(entryDirectory, pathname);
 }
-function getPostponeResumePathname(entryDirectory, pathname) {
+function getPostponeResumePathname(pathname) {
+  if (pathname === "/")
+    pathname = "/index";
+  return import_path2.default.posix.join("_next/postponed/resume", pathname);
+}
+function getPostponeResumeOutput(entryDirectory, pathname) {
   if (pathname === "/")
     pathname = "/index";
   return import_path2.default.posix.join(entryDirectory, "_next/postponed/resume", pathname);
@@ -13901,25 +13923,28 @@ ${JSON.stringify(
           }
           lambdas[outputName] = lambda;
           if (!omittedPrerenderRoutes.has(pagePathname)) {
-            const key = getPostponeResumePathname(entryDirectory, pageName);
-            lambdas[key] = lambda;
-            experimentalStreamingLambdaPaths.set(outputName, key);
+            const output = getPostponeResumeOutput(entryDirectory, pageName);
+            lambdas[output] = lambda;
+            experimentalStreamingLambdaPaths.set(outputName, {
+              pathname: getPostponeResumePathname(pageName),
+              output
+            });
           }
           for (const [
             routePathname,
-            { srcRoute, experimentalPPR }
+            { srcRoute, renderingMode }
           ] of Object.entries(prerenderManifest.staticRoutes)) {
-            if (srcRoute !== pagePathname || !experimentalPPR)
+            if (srcRoute !== pagePathname || renderingMode !== "PARTIALLY_STATIC" /* PARTIALLY_STATIC */)
               continue;
             if (routePathname === pagePathname)
               continue;
-            const key = getPostponeResumePathname(
-              entryDirectory,
-              routePathname
-            );
-            lambdas[key] = lambda;
+            const output = getPostponeResumePathname(routePathname);
+            lambdas[output] = lambda;
             outputName = import_path4.default.posix.join(entryDirectory, routePathname);
-            experimentalStreamingLambdaPaths.set(outputName, key);
+            experimentalStreamingLambdaPaths.set(outputName, {
+              pathname: getPostponeResumePathname(routePathname),
+              output
+            });
           }
           continue;
         }
@@ -14202,10 +14227,10 @@ ${JSON.stringify(
     throw new Error("Invariant: cannot use PPR without 'rsc.prefetchHeader'");
   }
   if (isAppPPREnabled) {
-    for (const { srcRoute, dataRoute, experimentalPPR } of Object.values(
+    for (const { srcRoute, dataRoute, renderingMode } of Object.values(
       prerenderManifest.staticRoutes
     )) {
-      if (!experimentalPPR || !dataRoute || !srcRoute)
+      if (renderingMode !== "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ || !dataRoute || !srcRoute)
         continue;
       if (!omittedPrerenderRoutes.has(srcRoute))
         continue;
@@ -14263,6 +14288,18 @@ ${JSON.stringify(
       ...i18n ? [
         // Handle auto-adding current default locale to path based on
         // $wildcard
+        // This is split into two rules to avoid matching the `/index` route as it causes issues with trailing slash redirect
+        {
+          src: `^${import_path4.default.posix.join(
+            "/",
+            entryDirectory,
+            "/"
+          )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp2.default)(locale)).join("|")})(?:/.*|$))$`,
+          // we aren't able to ensure trailing slash mode here
+          // so ensure this comes after the trailing slash redirect
+          dest: `${entryDirectory !== "." ? import_path4.default.posix.join("/", entryDirectory) : ""}$wildcard${trailingSlash ? "/" : ""}`,
+          continue: true
+        },
         {
           src: `^${import_path4.default.posix.join(
             "/",
@@ -15296,6 +15333,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
             message: 'image-manifest.json "images.remotePatterns" must be an array. Contact support if this continues to happen'
           });
         }
+        if (images.localPatterns && !Array.isArray(images.localPatterns)) {
+          throw new import_build_utils3.NowBuildError({
+            code: "NEXT_IMAGES_LOCALPATTERNS",
+            message: 'image-manifest.json "images.localPatterns" must be an array. Contact support if this continues to happen'
+          });
+        }
         if (images.minimumCacheTTL && !Number.isInteger(images.minimumCacheTTL)) {
           throw new import_build_utils3.NowBuildError({
             code: "NEXT_IMAGES_MINIMUMCACHETTL",
@@ -15704,13 +15747,13 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       }
     }
     const experimentalPPRRoutes = /* @__PURE__ */ new Set();
-    for (const [route, { experimentalPPR }] of [
+    for (const [route, { renderingMode }] of [
       ...Object.entries(prerenderManifest.staticRoutes),
       ...Object.entries(prerenderManifest.blockingFallbackRoutes),
       ...Object.entries(prerenderManifest.fallbackRoutes),
       ...Object.entries(prerenderManifest.omittedRoutes)
     ]) {
-      if (!experimentalPPR)
+      if (renderingMode !== "PARTIALLY_STATIC" /* PARTIALLY_STATIC */)
         continue;
       experimentalPPRRoutes.add(route);
     }
@@ -16499,6 +16542,18 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       ...i18n ? [
         // Handle auto-adding current default locale to path based on
         // $wildcard
+        // This is split into two rules to avoid matching the `/index` route as it causes issues with trailing slash redirect
+        {
+          src: `^${import_path5.default.posix.join(
+            "/",
+            entryDirectory,
+            "/"
+          )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})(?:/.*|$))$`,
+          // we aren't able to ensure trailing slash mode here
+          // so ensure this comes after the trailing slash redirect
+          dest: `${entryDirectory !== "." ? import_path5.default.posix.join("/", entryDirectory) : ""}$wildcard${trailingSlash ? "/" : ""}`,
+          continue: true
+        },
         {
           src: `^${import_path5.default.join(
             "/",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.3.10",
+  "version": "4.3.12",
   "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": "8.4.2",
+    "@vercel/build-utils": "8.4.6",
     "@vercel/routing-utils": "3.1.0",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",