@vercel/next 4.5.0 → 4.5.2

package/dist/index.js

@@ -820,17 +820,29 @@ var require_superstatic = __commonJS({
       convertRewrites: () => convertRewrites2,
       convertTrailingSlash: () => convertTrailingSlash,
       getCleanUrls: () => getCleanUrls,
+      pathToRegexp: () => pathToRegexp,
       sourceToRegex: () => sourceToRegex
     });
     module2.exports = __toCommonJS2(superstatic_exports);
     var import_url4 = require("url");
     var import_path_to_regexp = require_dist();
     var import_path_to_regexp_updated = require_dist2();
+    function cloneKeys(keys) {
+      if (typeof keys === "undefined") {
+        return void 0;
+      }
+      return keys.slice(0);
+    }
+    function compareKeys(left, right) {
+      const leftSerialized = typeof left === "undefined" ? "undefined" : left.toString();
+      const rightSerialized = typeof right === "undefined" ? "undefined" : right.toString();
+      return leftSerialized === rightSerialized;
+    }
     function pathToRegexp(callerId, path5, keys, options) {
+      const newKeys = cloneKeys(keys);
       const currentRegExp = (0, import_path_to_regexp.pathToRegexp)(path5, keys, options);
       try {
         const currentKeys = keys;
-        const newKeys = [];
         const newRegExp = (0, import_path_to_regexp_updated.pathToRegexp)(path5, newKeys, options);
         const isDiffRegExp = currentRegExp.toString() !== newRegExp.toString();
         if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffRegExp) {
@@ -841,7 +853,7 @@ var require_superstatic = __commonJS({
           });
           console.error(`[vc] PATH TO REGEXP PATH DIFF @ #${callerId}: ${message}`);
         }
-        const isDiffKeys = keys?.toString() !== newKeys?.toString();
+        const isDiffKeys = !compareKeys(keys, newKeys);
         if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffKeys) {
           const message = JSON.stringify({
             isDiffKeys,
@@ -852,7 +864,11 @@ var require_superstatic = __commonJS({
         }
       } catch (err) {
         const error = err;
-        console.error(`[vc] PATH TO REGEXP ERROR @ #${callerId}: ${error.message}`);
+        const message = JSON.stringify({
+          path: path5,
+          error: error.message
+        });
+        console.error(`[vc] PATH TO REGEXP ERROR @ #${callerId}: ${message}`);
       }
       return currentRegExp;
     }
@@ -11107,7 +11123,8 @@ async function getDynamicRoutes({
   bypassToken,
   isServerMode,
   dynamicMiddlewareRouteMap,
-  isAppPPREnabled
+  isAppPPREnabled,
+  isAppClientSegmentCacheEnabled
 }) {
   if (routesManifest) {
     switch (routesManifest.version) {
@@ -11140,7 +11157,13 @@ async function getDynamicRoutes({
             routes2.push(route2);
             continue;
           }
-          const { page, namedRegex, regex, routeKeys } = params;
+          const {
+            page,
+            namedRegex,
+            regex,
+            routeKeys,
+            prefetchSegmentDataRoutes
+          } = params;
           const route = {
             src: namedRegex || regex,
             dest: `${!isDev ? import_path2.default.posix.join("/", entryDirectory, page) : page}${routeKeys ? `?${Object.keys(routeKeys).map((key) => `${routeKeys[key]}=$${key}`).join("&")}` : ""}`
@@ -11161,6 +11184,20 @@ async function getDynamicRoutes({
               }
             ];
           }
+          if (isAppClientSegmentCacheEnabled && prefetchSegmentDataRoutes && prefetchSegmentDataRoutes.length > 0) {
+            for (const prefetchSegmentDataRoute of prefetchSegmentDataRoutes) {
+              routes2.push({
+                ...route,
+                src: prefetchSegmentDataRoute.source,
+                dest: `${!isDev ? import_path2.default.posix.join(
+                  "/",
+                  entryDirectory,
+                  prefetchSegmentDataRoute.destination
+                ) : prefetchSegmentDataRoute.destination}${routeKeys ? `?${Object.entries(routeKeys).map(([key, value]) => `${value}=$${key}`).join("&")}` : ""}`,
+                check: true
+              });
+            }
+          }
           if (isAppPPREnabled) {
             let dest = route.dest?.replace(/($|\?)/, ".prefetch.rsc$1");
             if (page === "/" || page === "/index") {
@@ -11248,6 +11285,7 @@ async function getDynamicRoutes({
 }
 function localizeDynamicRoutes(dynamicRoutes, dynamicPrefix, entryDirectory, staticPages, prerenderManifest, routesManifest, isServerMode, isCorrectLocaleAPIRoutes, inversedAppPathRoutesManifest) {
   const finalDynamicRoutes = [];
+  const nonLocalePrefixedRoutes = [];
   for (const route of dynamicRoutes) {
     if (route.middleware !== void 0 || route.middlewarePath !== void 0) {
       finalDynamicRoutes.push(route);
@@ -11269,11 +11307,13 @@ function localizeDynamicRoutes(dynamicRoutes, dynamicPrefix, entryDirectory, sta
           "^",
           `^${dynamicPrefix || ""}[/]?`
         );
-        finalDynamicRoutes.push(nonLocalePrefixedRoute);
+        nonLocalePrefixedRoutes.push(nonLocalePrefixedRoute);
       }
       route.src = route.src.replace(
         "^",
-        `^${dynamicPrefix ? `${dynamicPrefix}[/]?` : "[/]?"}(?${isLocalePrefixed ? "<nextLocale>" : ":"}${i18n.locales.map((locale) => (0, import_escape_string_regexp.default)(locale)).join("|")})?`
+        `^${dynamicPrefix ? `${dynamicPrefix}[/]?` : "[/]?"}(?${isLocalePrefixed ? "<nextLocale>" : ":"}${i18n.locales.map((locale) => (0, import_escape_string_regexp.default)(locale)).join("|")})${// the locale is not optional on this path with the skip default
+        // locale rewrite flag otherwise can cause double slash in dest
+        skipDefaultLocaleRewrite ? "" : "?"}`
       );
       if (isLocalePrefixed && !(isCorrectLocaleAPIRoutes && isApiRoute) && !isAppRoute) {
         route.dest = route.dest.replace(
@@ -11286,6 +11326,9 @@ function localizeDynamicRoutes(dynamicRoutes, dynamicPrefix, entryDirectory, sta
     }
     finalDynamicRoutes.push(route);
   }
+  if (nonLocalePrefixedRoutes.length > 0) {
+    finalDynamicRoutes.push(...nonLocalePrefixedRoutes);
+  }
   return finalDynamicRoutes;
 }
 async function getImagesManifest(entryPath, outputDirectory) {
@@ -12094,7 +12137,8 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     routesManifest,
     isCorrectNotFoundRoutes,
     isEmptyAllowQueryForPrendered,
-    isAppPPREnabled
+    isAppPPREnabled,
+    isAppClientSegmentCacheEnabled
   } = prerenderRouteArgs;
   if (isBlocking && isFallback) {
     throw new import_build_utils.NowBuildError({
@@ -12211,7 +12255,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     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") {
+      if (typeof meta === "object" && meta !== null && "postponed" in meta && typeof meta.postponed === "string") {
         didPostpone = true;
         postponedPrerender = meta.postponed;
         initialHeaders ??= {};
@@ -12512,6 +12556,53 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
         prerenders[normalizePathData(outputPathData)] = prerender;
       }
     }
+    const prefetchSegmentSuffix = routesManifest?.rsc?.prefetchSegmentSuffix;
+    const prefetchSegmentDirSuffix = routesManifest?.rsc?.prefetchSegmentDirSuffix;
+    if (isAppClientSegmentCacheEnabled && prefetchSegmentSuffix && prefetchSegmentDirSuffix && rscDidPostponeHeader && appDir) {
+      const metaPath = import_path2.default.join(appDir, `${routeFileNoExt}.meta`);
+      if (import_fs_extra3.default.existsSync(metaPath)) {
+        const meta = JSON.parse(await import_fs_extra3.default.readFile(metaPath, "utf8"));
+        if (typeof meta === "object" && meta !== null && "segmentPaths" in meta && typeof meta.segmentPaths === "object" && meta.segmentPaths !== null && Array.isArray(meta.segmentPaths)) {
+          const segmentsDir = import_path2.default.join(
+            appDir,
+            routeFileNoExt + prefetchSegmentDirSuffix
+          );
+          for (const segmentPath of meta.segmentPaths) {
+            const outputSegmentPath = import_path2.default.join(
+              outputPathPage + prefetchSegmentDirSuffix,
+              segmentPath
+            ) + prefetchSegmentSuffix;
+            let fallback = null;
+            if (!isFallback) {
+              const fsPath = import_path2.default.join(
+                segmentsDir,
+                segmentPath + prefetchSegmentSuffix
+              );
+              fallback = new import_build_utils.FileFsRef({ fsPath });
+            }
+            prerenders[outputSegmentPath] = new import_build_utils.Prerender({
+              expiration: initialRevalidate,
+              lambda,
+              allowQuery,
+              fallback,
+              // Use the same prerender group as the JSON/data prerender.
+              group: prerenderGroup,
+              allowHeader,
+              // These routes are always only static, so they should not
+              // permit any bypass unless it's for preview
+              bypassToken: prerenderManifest.bypassToken,
+              experimentalBypassFor: void 0,
+              initialHeaders: {
+                ...initialHeaders,
+                vary: rscVaryHeader,
+                "content-type": rscContentTypeHeader,
+                [rscDidPostponeHeader]: "2"
+              }
+            });
+          }
+        }
+      }
+    }
     if (outputPathData?.endsWith(".json") && appDir) {
       const dummyOutput = new import_build_utils.FileBlob({
         data: "{}",
@@ -13611,7 +13702,8 @@ async function serverBuild({
   requiredServerFilesManifest,
   variantsManifest,
   experimentalPPRRoutes,
-  isAppPPREnabled
+  isAppPPREnabled,
+  isAppClientSegmentCacheEnabled
 }) {
   if (isAppPPREnabled) {
     (0, import_build_utils2.debug)(
@@ -13664,10 +13756,17 @@ async function serverBuild({
           continue;
         const { protocol, pathname, query } = import_url2.default.parse(rewrite.dest);
         if (isAfterFilesRewrite) {
-          const rscSuffix = isAppPPREnabled ? `(\\.prefetch)?\\.rsc` : "\\.rsc";
+          const parts = ["\\.rsc"];
+          if (isAppPPREnabled) {
+            parts.push("\\.prefetch\\.rsc");
+          }
+          if (isAppClientSegmentCacheEnabled) {
+            parts.push("\\.segments/.+\\.segment\\.rsc");
+          }
+          const rscSuffix = parts.join("|");
           rewrite.src = rewrite.src.replace(
             /\/?\(\?:\/\)\?/,
-            `(?<rscsuff>${rscSuffix})?(?:/)?`
+            `(?:/)?(?<rscsuff>${rscSuffix})?`
           );
           let destQueryIndex = rewrite.dest.indexOf("?");
           if (destQueryIndex === -1) {
@@ -14562,7 +14661,8 @@ ${JSON.stringify(
     hasPages404: routesManifest.pages404,
     isCorrectNotFoundRoutes,
     isEmptyAllowQueryForPrendered,
-    isAppPPREnabled
+    isAppPPREnabled,
+    isAppClientSegmentCacheEnabled
   });
   await Promise.all(
     Object.keys(prerenderManifest.staticRoutes).map(
@@ -14627,7 +14727,8 @@ ${JSON.stringify(
     bypassToken: prerenderManifest.bypassToken || "",
     isServerMode: true,
     dynamicMiddlewareRouteMap: middleware.dynamicRouteMap,
-    isAppPPREnabled
+    isAppPPREnabled,
+    isAppClientSegmentCacheEnabled
   }).then(
     (arr) => localizeDynamicRoutes(
       arr,
@@ -14787,6 +14888,9 @@ ${JSON.stringify(
       }
     }
   }
+  const prefetchSegmentHeader = routesManifest?.rsc?.prefetchSegmentHeader;
+  const prefetchSegmentDirSuffix = routesManifest?.rsc?.prefetchSegmentDirSuffix;
+  const prefetchSegmentSuffix = routesManifest?.rsc?.prefetchSegmentSuffix;
   const rscPrefetchHeader = routesManifest.rsc?.prefetchHeader?.toLowerCase();
   const rscVaryHeader = routesManifest?.rsc?.varyHeader || "RSC, Next-Router-State-Tree, Next-Router-Prefetch";
   const appNotFoundPath = import_path4.default.posix.join(".", entryDirectory, "_not-found");
@@ -15020,9 +15124,65 @@ ${JSON.stringify(
       // to prevent a local/deploy mismatch
       ...!isCorrectMiddlewareOrder ? middleware.staticRoutes : [],
       ...appDir ? [
+        ...isAppClientSegmentCacheEnabled && rscPrefetchHeader && prefetchSegmentHeader && prefetchSegmentDirSuffix && prefetchSegmentSuffix ? [
+          {
+            src: import_path4.default.posix.join("/", entryDirectory, "/(?<path>.+)$"),
+            dest: import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              `/$path${prefetchSegmentDirSuffix}/$segmentPath${prefetchSegmentSuffix}`
+            ),
+            has: [
+              {
+                type: "header",
+                key: rscHeader,
+                value: "1"
+              },
+              {
+                type: "header",
+                key: rscPrefetchHeader,
+                value: "1"
+              },
+              {
+                type: "header",
+                key: prefetchSegmentHeader,
+                value: "/(?<segmentPath>.+)"
+              }
+            ],
+            continue: true,
+            override: true
+          },
+          {
+            src: import_path4.default.posix.join("^/", entryDirectory, "$"),
+            dest: import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              `/index${prefetchSegmentDirSuffix}/$segmentPath${prefetchSegmentSuffix}`
+            ),
+            has: [
+              {
+                type: "header",
+                key: rscHeader,
+                value: "1"
+              },
+              {
+                type: "header",
+                key: rscPrefetchHeader,
+                value: "1"
+              },
+              {
+                type: "header",
+                key: prefetchSegmentHeader,
+                value: "/(?<segmentPath>.+)"
+              }
+            ],
+            continue: true,
+            override: true
+          }
+        ] : [],
         ...rscPrefetchHeader && isAppPPREnabled ? [
           {
-            src: `^${import_path4.default.posix.join("/", entryDirectory, "/")}`,
+            src: `^${import_path4.default.posix.join("/", entryDirectory, "/")}$`,
             has: [
               {
                 type: "header",
@@ -15334,6 +15494,23 @@ ${JSON.stringify(
           dest: "__next_data_catchall"
         }
       ] : [],
+      // If it didn't match any of the static routes or dynamic ones, then we
+      // should fallback to the regular RSC request.
+      ...isAppClientSegmentCacheEnabled && rscPrefetchHeader && prefetchSegmentHeader && prefetchSegmentDirSuffix && prefetchSegmentSuffix ? [
+        {
+          src: import_path4.default.posix.join(
+            "/",
+            entryDirectory,
+            `/(?<path>.+)${(0, import_escape_string_regexp2.default)(prefetchSegmentDirSuffix)}/.+${(0, import_escape_string_regexp2.default)(prefetchSegmentSuffix)}$`
+          ),
+          dest: import_path4.default.posix.join(
+            "/",
+            entryDirectory,
+            isAppPPREnabled ? "/$path.prefetch.rsc" : "/$path.rsc"
+          ),
+          check: true
+        }
+      ] : [],
       // routes to call after a file has been matched
       { handle: "hit" },
       // Before we handle static files we need to set proper caching headers
@@ -16384,6 +16561,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       experimentalPPRRoutes.add(route);
     }
     const isAppPPREnabled = requiredServerFilesManifest ? requiredServerFilesManifest.config.experimental?.ppr === true || requiredServerFilesManifest.config.experimental?.ppr === "incremental" : false;
+    const isAppClientSegmentCacheEnabled = requiredServerFilesManifest ? requiredServerFilesManifest.config.experimental?.clientSegmentCache === true : false;
     if (requiredServerFilesManifest) {
       if (!routesManifest) {
         throw new Error(
@@ -16432,7 +16610,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         hasIsr500Page,
         variantsManifest,
         experimentalPPRRoutes,
-        isAppPPREnabled
+        isAppPPREnabled,
+        isAppClientSegmentCacheEnabled
       });
     }
     const pageKeys = Object.keys(pages);
@@ -16828,7 +17007,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       canUsePreviewMode,
       bypassToken: prerenderManifest.bypassToken || "",
       isServerMode,
-      isAppPPREnabled: false
+      isAppPPREnabled: false,
+      isAppClientSegmentCacheEnabled: false
     }).then(
       (arr) => localizeDynamicRoutes(
         arr,
@@ -16854,7 +17034,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         canUsePreviewMode,
         bypassToken: prerenderManifest.bypassToken || "",
         isServerMode,
-        isAppPPREnabled: false
+        isAppPPREnabled: false,
+        isAppClientSegmentCacheEnabled: false
       }).then(
         (arr) => arr.map((route) => {
           route.src = route.src.replace("^", `^${dynamicPrefix}`);
@@ -17033,7 +17214,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       appPathRoutesManifest,
       isSharedLambdas,
       canUsePreviewMode,
-      isAppPPREnabled: false
+      isAppPPREnabled: false,
+      isAppClientSegmentCacheEnabled: false
     });
     await Promise.all(
       Object.keys(prerenderManifest.staticRoutes).map(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -30,8 +30,8 @@
     "@types/semver": "6.0.0",
     "@types/text-table": "0.2.1",
     "@types/webpack-sources": "3.2.0",
-    "@vercel/build-utils": "9.2.0",
-    "@vercel/routing-utils": "5.0.2",
+    "@vercel/build-utils": "9.2.1",
+    "@vercel/routing-utils": "5.0.4",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",
     "bytes": "3.1.2",