@vercel/next 4.10.10 → 4.11.2

package/dist/index.js

@@ -11162,6 +11162,14 @@ async function getDynamicRoutes({
       case 3:
       case 4: {
         const routes2 = [];
+        if (isAppClientSegmentCacheEnabled && !isAppPPREnabled) {
+          routes2.push({
+            src: "^/(?<path>.+)(?<rscSuffix>\\.segments/.+\\.segment\\.rsc)(?:/)?$",
+            dest: `/$path${isAppPPREnabled ? ".prefetch.rsc" : ".rsc"}`,
+            check: true,
+            override: true
+          });
+        }
         for (const dynamicRoute of routesManifest.dynamicRoutes) {
           if (!canUsePreviewMode && omittedRoutes?.has(dynamicRoute.page)) {
             continue;
@@ -11182,7 +11190,8 @@ async function getDynamicRoutes({
             namedRegex,
             regex,
             routeKeys,
-            prefetchSegmentDataRoutes
+            prefetchSegmentDataRoutes,
+            hasFallbackRootParams
           } = params;
           const route = {
             src: namedRegex || regex,
@@ -11191,6 +11200,10 @@ async function getDynamicRoutes({
           if (!isServerMode) {
             route.check = true;
           }
+          if (isAppPPREnabled || isAppClientSegmentCacheEnabled) {
+            route.check = true;
+            route.override = true;
+          }
           if (isServerMode && canUsePreviewMode && omittedRoutes?.has(page)) {
             route.has = [
               {
@@ -11207,7 +11220,6 @@ async function getDynamicRoutes({
           if (isAppClientSegmentCacheEnabled && prefetchSegmentDataRoutes && prefetchSegmentDataRoutes.length > 0) {
             for (const prefetchSegmentDataRoute of prefetchSegmentDataRoutes) {
               routes2.push({
-                ...route,
                 src: prefetchSegmentDataRoute.source,
                 dest: getDestinationForSegmentRoute(
                   isDev === true,
@@ -11215,18 +11227,23 @@ async function getDynamicRoutes({
                   routeKeys,
                   prefetchSegmentDataRoute
                 ),
-                check: true
+                check: true,
+                override: true
               });
             }
           }
           if (isAppPPREnabled || isAppClientSegmentCacheEnabled) {
             routes2.push({
-              ...route,
               src: route.src.replace(
                 new RegExp((0, import_escape_string_regexp.default)("(?:/)?$")),
-                "(?<rscSuffix>\\.rsc|\\.prefetch\\.rsc|\\.segments/.+\\.segment\\.rsc)(?:/)?$"
+                hasFallbackRootParams ? "\\.rsc(?:/)?$" : "(?<rscSuffix>\\.rsc|\\.prefetch\\.rsc|\\.segments/.+\\.segment\\.rsc)(?:/)?$"
               ),
-              dest: route.dest?.replace(/($|\?)/, "$rscSuffix$1")
+              dest: route.dest?.replace(
+                /($|\?)/,
+                hasFallbackRootParams ? ".rsc$1" : "$rscSuffix$1"
+              ),
+              check: true,
+              override: true
             });
           } else {
             routes2.push({
@@ -11621,7 +11638,13 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
         };
       });
       lazyRoutes.forEach((lazyRoute) => {
-        const { routeRegex, fallback, dataRoute, dataRouteRegex } = manifest.dynamicRoutes[lazyRoute];
+        const {
+          routeRegex,
+          fallback,
+          dataRoute,
+          dataRouteRegex,
+          fallbackRootParams
+        } = manifest.dynamicRoutes[lazyRoute];
         if (fallback) {
           ret.fallbackRoutes[lazyRoute] = {
             routeRegex,
@@ -11635,6 +11658,8 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
           ret.blockingFallbackRoutes[lazyRoute] = {
             routeRegex,
             dataRoute,
+            fallback: null,
+            fallbackRootParams,
             dataRouteRegex,
             renderingMode: "STATIC" /* STATIC */,
             allowHeader: void 0
@@ -11750,7 +11775,8 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
             prefetchDataRouteRegex,
             renderingMode,
             allowHeader,
-            fallbackRootParams
+            fallbackRootParams,
+            fallback: null
           };
         } else {
           ret.omittedRoutes[lazyRoute] = {
@@ -11937,6 +11963,30 @@ async function getPageLambdaGroups({
       });
       opts = { ...vercelConfigOpts, ...opts };
     }
+    const isGeneratedSteps = routeName.includes("api/generated/steps");
+    const isGeneratedWorkflows = routeName.includes("api/generated/workflows");
+    if (isGeneratedSteps || isGeneratedWorkflows) {
+      const sourceFile = await getSourceFilePathFromPage({
+        workPath: entryPath,
+        page: normalizeSourceFilePageFromManifest(
+          routeName,
+          page,
+          inversedAppPathManifest
+        ),
+        pageExtensions
+      });
+      const config2 = JSON.parse(
+        await import_fs_extra3.default.readFile(
+          import_path2.default.join(entryPath, import_path2.default.dirname(sourceFile), "../config.json"),
+          "utf8"
+        ).catch(() => "{}")
+      );
+      if (isGeneratedSteps && config2.steps) {
+        Object.assign(opts, config2.steps);
+      } else if (isGeneratedWorkflows && config2.workflows) {
+        Object.assign(opts, config2.workflows);
+      }
+    }
     let matchingGroup = experimentalAllowBundling ? void 0 : groups.find((group) => {
       const matches = group.maxDuration === opts.maxDuration && group.memory === opts.memory && group.isPrerenders === isPrerenderRoute && group.isExperimentalPPR === isExperimentalPPR && JSON.stringify(group.experimentalTriggers) === JSON.stringify(opts.experimentalTriggers);
       if (matches) {
@@ -12519,8 +12569,8 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     }
     let htmlAllowQuery = allowQuery;
     if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ && (isFallback || isBlocking)) {
-      const { fallbackRootParams } = isFallback ? prerenderManifest.fallbackRoutes[routeKey] : prerenderManifest.blockingFallbackRoutes[routeKey];
-      if (fallbackRootParams && fallbackRootParams.length > 0) {
+      const { fallbackRootParams, fallback } = isFallback ? prerenderManifest.fallbackRoutes[routeKey] : prerenderManifest.blockingFallbackRoutes[routeKey];
+      if (fallback && typeof fallback === "string" && fallbackRootParams && fallbackRootParams.length > 0) {
         htmlAllowQuery = fallbackRootParams;
       } else if (postponedPrerender) {
         htmlAllowQuery = [];
@@ -15165,6 +15215,9 @@ ${JSON.stringify(
       lambdas[dataPathname] = lambdas[srcPathname];
     }
   }
+  const shouldHandleSegmentToRsc = Boolean(
+    isAppClientSegmentCacheEnabled && rscPrefetchHeader && prefetchSegmentHeader && prefetchSegmentDirSuffix && prefetchSegmentSuffix
+  );
   return {
     wildcard: wildcardConfig,
     images: getImagesConfig(imagesManifest),
@@ -15183,7 +15236,18 @@ ${JSON.stringify(
       ...nodeMiddleware?.lambdas,
       ...isNextDataServerResolving ? {
         __next_data_catchall: nextDataCatchallOutput
-      } : {}
+      } : {},
+      // When bots crawl a site, they may render the page after awhile (e.g. re-sync),
+      // and the sub-assets may not be available then. In this case, the link to
+      // static assets could be not found, and return a 404 HTML. This behavior can
+      // bait the bots as if they found 404 pages. In Next.js it is handled on the
+      // server to return a plain text "Not Found". However, as we handle the "_next/static/"
+      // routes in Vercel CLI, the Next.js behavior is overwritten. Therefore, create a
+      // ".txt" file with "Not Found" content and rewrite any not found static assets to it.
+      [import_path4.default.posix.join(".", entryDirectory, "_next/static/not-found.txt")]: new import_build_utils2.FileBlob({
+        data: "Not Found",
+        contentType: "text/plain"
+      })
     },
     routes: [
       /*
@@ -15587,14 +15651,17 @@ ${JSON.stringify(
       // We need to make sure to 404 for /_next after handle: miss since
       // handle: miss is called before rewrites and to prevent rewriting /_next
       {
-        src: import_path4.default.posix.join(
+        src: import_path4.default.posix.join("/", entryDirectory, "_next/static/.+"),
+        status: 404,
+        check: true,
+        dest: import_path4.default.posix.join(
           "/",
           entryDirectory,
-          "_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media)/.+"
+          "_next/static/not-found.txt"
         ),
-        status: 404,
-        check: true,
-        dest: "$0"
+        headers: {
+          "content-type": "text/plain; charset=utf-8"
+        }
       },
       // remove locale prefixes to check public files and
       // to allow checking non-prefixed lambda outputs
@@ -15646,19 +15713,11 @@ ${JSON.stringify(
         }
       ] : [],
       // 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 ? [
+      // should fallback to either prefetch or normal RSC request
+      ...shouldHandleSegmentToRsc && 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"
-          ),
+          src: "^/(?<path>.+)(?<rscSuffix>\\.segments/.+\\.segment\\.rsc)(?:/)?$",
+          dest: `/$path${isAppPPREnabled ? ".prefetch.rsc" : ".rsc"}`,
           check: true
         }
       ] : [],
@@ -16559,14 +16618,17 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // /_next
         { handle: "miss" },
         {
-          src: import_path5.default.posix.join(
+          src: import_path5.default.posix.join("/", entryDirectory, "_next/static/.+"),
+          status: 404,
+          check: true,
+          dest: import_path5.default.posix.join(
             "/",
             entryDirectory,
-            "_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media)/.+"
+            "_next/static/not-found.txt"
           ),
-          status: 404,
-          check: true,
-          dest: "$0"
+          headers: {
+            "content-type": "text/plain; charset=utf-8"
+          }
         },
         // Dynamic routes
         // TODO: do we want to do this?: ...dynamicRoutes,
@@ -17807,14 +17869,13 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // handle: miss is called before rewrites and to prevent rewriting /_next
       { handle: "miss" },
       {
-        src: import_path5.default.join(
-          "/",
-          entryDirectory,
-          "_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media)/.+"
-        ),
+        src: import_path5.default.join("/", entryDirectory, "_next/static/.+"),
         status: 404,
         check: true,
-        dest: "$0"
+        dest: import_path5.default.join("/", entryDirectory, "_next/static/not-found.txt"),
+        headers: {
+          "content-type": "text/plain; charset=utf-8"
+        }
       },
       // remove locale prefixes to check public files
       ...i18n ? [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.10.10",
+  "version": "4.11.2",
   "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": "11.0.0",
+    "@vercel/build-utils": "11.0.1",
     "@vercel/routing-utils": "5.1.1",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",