@vercel/next 4.11.2 → 4.12.0

package/dist/index.js

@@ -11144,7 +11144,9 @@ async function getDynamicRoutes({
   isServerMode,
   dynamicMiddlewareRouteMap,
   isAppPPREnabled,
-  isAppClientSegmentCacheEnabled
+  isAppClientSegmentCacheEnabled,
+  isAppClientParamParsingEnabled,
+  prerenderManifest
 }) {
   if (routesManifest) {
     switch (routesManifest.version) {
@@ -11197,6 +11199,8 @@ async function getDynamicRoutes({
             src: namedRegex || regex,
             dest: `${!isDev ? import_path2.default.posix.join("/", entryDirectory, page) : page}${routeKeys ? `?${Object.keys(routeKeys).map((key) => `${routeKeys[key]}=$${key}`).join("&")}` : ""}`
           };
+          const { renderingMode, prefetchDataRoute } = prerenderManifest.fallbackRoutes[page] ?? prerenderManifest.blockingFallbackRoutes[page] ?? prerenderManifest.omittedRoutes[page] ?? {};
+          const isRoutePPREnabled = renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */;
           if (!isServerMode) {
             route.check = true;
           }
@@ -11233,14 +11237,15 @@ async function getDynamicRoutes({
             }
           }
           if (isAppPPREnabled || isAppClientSegmentCacheEnabled) {
+            const shouldSkipSuffixes = hasFallbackRootParams || isRoutePPREnabled && isAppClientParamParsingEnabled && !prefetchDataRoute;
             routes2.push({
               src: route.src.replace(
                 new RegExp((0, import_escape_string_regexp.default)("(?:/)?$")),
-                hasFallbackRootParams ? "\\.rsc(?:/)?$" : "(?<rscSuffix>\\.rsc|\\.prefetch\\.rsc|\\.segments/.+\\.segment\\.rsc)(?:/)?$"
+                shouldSkipSuffixes ? "\\.rsc(?:/)?$" : "(?<rscSuffix>\\.rsc|\\.prefetch\\.rsc|\\.segments/.+\\.segment\\.rsc)(?:/)?$"
               ),
               dest: route.dest?.replace(
                 /($|\?)/,
-                hasFallbackRootParams ? ".rsc$1" : "$rscSuffix$1"
+                shouldSkipSuffixes ? ".rsc$1" : "$rscSuffix$1"
               ),
               check: true,
               override: true
@@ -11883,6 +11888,9 @@ async function getSourceFilePathFromPage({
   if (page === "/_not-found/page") {
     return "";
   }
+  if (page === "/_global-error/page") {
+    return "";
+  }
   if (!INTERNAL_PAGES.includes(page)) {
     console.log(
       `WARNING: Unable to find source file for page ${page} with extensions: ${extensionsToTry.join(
@@ -12222,7 +12230,8 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     isCorrectNotFoundRoutes,
     isEmptyAllowQueryForPrendered,
     isAppPPREnabled,
-    isAppClientSegmentCacheEnabled
+    isAppClientSegmentCacheEnabled,
+    isAppClientParamParsingEnabled
   } = prerenderRouteArgs;
   if (isBlocking && isFallback) {
     throw new import_build_utils.NowBuildError({
@@ -12335,7 +12344,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     isAppPathRoute = true;
   }
   const isOmittedOrNotFound = isOmitted || isNotFound;
-  let htmlFsRef = null;
+  let htmlFallbackFsRef = null;
   let postponedPrerender;
   let postponedState = null;
   let didPostpone = false;
@@ -12355,34 +12364,27 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
         didPostpone = false;
       }
     }
-    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 (postponedPrerender) {
     const contentType = initialHeaders?.["content-type"];
     if (!contentType) {
       throw new Error("Invariant: contentType can't be undefined");
     }
-    htmlFsRef = new import_build_utils.FileBlob({ contentType, data: postponedPrerender });
+    htmlFallbackFsRef = new import_build_utils.FileBlob({
+      contentType,
+      data: postponedPrerender
+    });
   } else if (appDir && !dataRoute && !prefetchDataRoute && isAppPathRoute && !(isBlocking || isFallback)) {
     const contentType = initialHeaders?.["content-type"];
     const fsPath = import_path2.default.join(appDir, `${routeFileNoExt}.body`);
     if (import_fs_extra3.default.existsSync(fsPath)) {
-      htmlFsRef = new import_build_utils.FileFsRef({
+      htmlFallbackFsRef = new import_build_utils.FileFsRef({
         fsPath,
         contentType: contentType || "text/html;charset=utf-8"
       });
     }
   } else {
-    htmlFsRef = isBlocking || isNotFound && !static404Page ? (
+    htmlFallbackFsRef = isBlocking || isNotFound && !static404Page ? (
       // Blocking pages do not have an HTML fallback
       null
     ) : new import_build_utils.FileFsRef({
@@ -12403,11 +12405,12 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       )
     });
   }
-  const jsonFsRef = (
-    // JSON data does not exist for fallback or blocking pages
-    isFallback || isBlocking || isNotFound && !static404Page || !dataRoute ? null : new import_build_utils.FileFsRef({
+  let dataFallbackFsRef = null;
+  if (!isFallback && !isBlocking && (!isNotFound || static404Page) && dataRoute && (!isAppClientParamParsingEnabled || prefetchDataRoute)) {
+    const basePath = isAppPathRoute && !isOmittedOrNotFound && appDir ? appDir : pagesDir;
+    dataFallbackFsRef = new import_build_utils.FileFsRef({
       fsPath: import_path2.default.join(
-        isAppPathRoute && !isOmittedOrNotFound && appDir ? appDir : pagesDir,
+        basePath,
         `${isOmittedOrNotFound ? localePrefixed404 ? addLocaleOrDefault("/404.html", routesManifest, locale) : "/404.html" : isAppPathRoute ? (
           // When experimental PPR is enabled, we expect that the data
           // that should be served as a part of the prerender should
@@ -12417,8 +12420,8 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
           renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ ? prefetchDataRoute : dataRoute
         ) : routeFileNoExt + ".json"}`
       )
-    })
-  );
+    });
+  }
   if (isOmittedOrNotFound) {
     initialStatus = 404;
   }
@@ -12456,7 +12459,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       );
     }
     outputPathPrefetchData = normalizeDataRoute(prefetchDataRoute);
-  } else if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */) {
+  } else if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ && !isAppClientParamParsingEnabled) {
     throw new Error("Invariant: expected to find prefetch data route PPR");
   }
   if (isSharedLambdas) {
@@ -12486,20 +12489,20 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     lambda = lambdas[outputSrcPathPage];
   }
   if (!isAppPathRoute && !isNotFound && initialRevalidate === false) {
-    if (htmlFsRef == null || jsonFsRef == null) {
+    if (htmlFallbackFsRef == null || dataFallbackFsRef == null) {
       throw new import_build_utils.NowBuildError({
         code: "NEXT_HTMLFSREF_JSONFSREF",
         message: `invariant: htmlFsRef != null && jsonFsRef != null ${routeFileNoExt}`
       });
     }
     if (!canUsePreviewMode || routeKey === "/404" && !lambdas[outputPathPage]) {
-      htmlFsRef.contentType = htmlContentType;
-      prerenders[outputPathPage] = htmlFsRef;
+      htmlFallbackFsRef.contentType = htmlContentType;
+      prerenders[outputPathPage] = htmlFallbackFsRef;
       if (outputPathPrefetchData) {
-        prerenders[outputPathPrefetchData] = jsonFsRef;
+        prerenders[outputPathPrefetchData] = dataFallbackFsRef;
       }
       if (outputPathData && renderingMode !== "PARTIALLY_STATIC" /* PARTIALLY_STATIC */) {
-        prerenders[outputPathData] = jsonFsRef;
+        prerenders[outputPathData] = dataFallbackFsRef;
       }
     }
   }
@@ -12570,7 +12573,11 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     let htmlAllowQuery = allowQuery;
     if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ && (isFallback || isBlocking)) {
       const { fallbackRootParams, fallback } = isFallback ? prerenderManifest.fallbackRoutes[routeKey] : prerenderManifest.blockingFallbackRoutes[routeKey];
-      if (fallback && typeof fallback === "string" && fallbackRootParams && fallbackRootParams.length > 0) {
+      if (
+        // We only want to vary on the shell contents if there is a fallback
+        // present and able to be served.
+        fallback && typeof fallback === "string" && fallbackRootParams && fallbackRootParams.length > 0
+      ) {
         htmlAllowQuery = fallbackRootParams;
       } else if (postponedPrerender) {
         htmlAllowQuery = [];
@@ -12581,7 +12588,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       staleExpiration: initialExpire,
       lambda,
       allowQuery: htmlAllowQuery,
-      fallback: htmlFsRef,
+      fallback: htmlFallbackFsRef,
       group: prerenderGroup,
       bypassToken: prerenderManifest.bypassToken,
       experimentalBypassFor,
@@ -12617,7 +12624,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
         staleExpiration: initialExpire,
         lambda,
         allowQuery,
-        fallback: jsonFsRef,
+        fallback: dataFallbackFsRef,
         group: prerenderGroup,
         bypassToken: prerenderManifest.bypassToken,
         experimentalBypassFor,
@@ -12690,13 +12697,17 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
             appDir,
             routeFileNoExt + prefetchSegmentDirSuffix
           );
+          let segmentAllowQuery = allowQuery;
+          if (isAppClientParamParsingEnabled && (isFallback || isBlocking)) {
+            segmentAllowQuery = [];
+          }
           for (const segmentPath of meta.segmentPaths) {
             const outputSegmentPath = import_path2.default.join(
               outputPathPage + prefetchSegmentDirSuffix,
               segmentPath
             ) + prefetchSegmentSuffix;
             let fallback = null;
-            if (!isFallback) {
+            if (segmentAllowQuery && segmentAllowQuery.length === 0) {
               const fsPath = import_path2.default.join(
                 segmentsDir,
                 segmentPath + prefetchSegmentSuffix
@@ -12707,7 +12718,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
               expiration: initialRevalidate,
               staleExpiration: initialExpire,
               lambda,
-              allowQuery,
+              allowQuery: segmentAllowQuery,
               fallback,
               // Use the same prerender group as the JSON/data prerender.
               group: prerenderGroup,
@@ -13472,6 +13483,55 @@ function getHTMLPostponedState({
   }
   return meta.postponed;
 }
+async function getServerActionMetaRoutes(distDir) {
+  const manifestPath = import_path2.default.join(
+    distDir,
+    "server",
+    "server-reference-manifest.json"
+  );
+  try {
+    const manifestContent = await import_fs_extra3.default.readFile(manifestPath, "utf8");
+    const manifest = JSON.parse(manifestContent);
+    const routes = [];
+    for (const runtimeType of ["node", "edge"]) {
+      const runtime = manifest[runtimeType];
+      if (!runtime)
+        continue;
+      for (const [id, entry] of Object.entries(runtime)) {
+        if (!entry.filename || !entry.exportedName)
+          continue;
+        let exportedName = entry.exportedName;
+        if (exportedName === "$$RSC_SERVER_ACTION_0") {
+          exportedName = "anonymous_fn";
+        }
+        const route = {
+          src: "/(.*)",
+          has: [
+            {
+              type: "header",
+              key: "next-action",
+              value: id
+            }
+          ],
+          transforms: [
+            {
+              type: "request.headers",
+              op: "append",
+              target: {
+                key: "x-server-action-name"
+              },
+              args: `${entry.filename}#${exportedName}`
+            }
+          ]
+        };
+        routes.push(route);
+      }
+    }
+    return routes;
+  } catch (error) {
+    return [];
+  }
+}
 
 // src/create-serverless-config.ts
 function getCustomData(importName, target) {
@@ -13966,7 +14026,10 @@ async function serverBuild({
   variantsManifest,
   experimentalPPRRoutes,
   isAppPPREnabled,
-  isAppClientSegmentCacheEnabled
+  isAppFullPPREnabled,
+  isAppClientSegmentCacheEnabled,
+  isAppClientParamParsingEnabled,
+  clientParamParsingOrigins
 }) {
   if (isAppPPREnabled) {
     (0, import_build_utils2.debug)(
@@ -13975,6 +14038,7 @@ async function serverBuild({
     );
   }
   lambdaPages = Object.assign({}, lambdaPages, lambdaAppPaths);
+  const shouldSkipPrefetchRSCHandling = isAppFullPPREnabled && isAppClientParamParsingEnabled && isAppClientSegmentCacheEnabled;
   const experimentalAllowBundling = Boolean(
     process.env.NEXT_EXPERIMENTAL_FUNCTION_BUNDLING
   );
@@ -13984,7 +14048,6 @@ async function serverBuild({
   const lambdas = {};
   const prerenders = {};
   const lambdaPageKeys = Object.keys(lambdaPages);
-  const internalPages = [...INTERNAL_PAGES];
   const pageBuildTraces = await (0, import_build_utils2.glob)("**/*.js.nft.json", pagesDir);
   const isEmptyAllowQueryForPrendered = import_semver3.default.gte(
     nextVersion,
@@ -14023,6 +14086,23 @@ async function serverBuild({
         } else if (rewrite.dest.startsWith("https://")) {
           protocol = "https://";
         }
+        let origin = null;
+        if (protocol) {
+          const urlWithoutProtocol = rewrite.dest.substring(protocol.length);
+          const delimiters = ["/", "?", "#"];
+          let endIndex = -1;
+          for (const delimiter of delimiters) {
+            const index = urlWithoutProtocol.indexOf(delimiter);
+            if (index !== -1) {
+              endIndex = endIndex === -1 ? index : Math.min(endIndex, index);
+            }
+          }
+          if (endIndex === -1) {
+            origin = rewrite.dest;
+          } else {
+            origin = protocol + urlWithoutProtocol.substring(0, endIndex);
+          }
+        }
         let pathname = null;
         let query = null;
         if (!protocol) {
@@ -14065,7 +14145,10 @@ async function serverBuild({
         const { rewriteHeaders } = routesManifest;
         if (!rewriteHeaders)
           continue;
-        if (protocol || !pathname && !query)
+        const isAllowedOrigin = origin && clientParamParsingOrigins ? clientParamParsingOrigins.some(
+          (allowedOrigin) => new RegExp(allowedOrigin).test(origin)
+        ) : false;
+        if (origin && !isAllowedOrigin)
           continue;
         rewrite.headers = {
           ...rewrite.headers,
@@ -14116,6 +14199,9 @@ async function serverBuild({
   const lstatResults = {};
   const nonLambdaSsgPages = /* @__PURE__ */ new Set();
   const static404Pages = new Set(static404Page ? [static404Page] : []);
+  const internalPages = [...INTERNAL_PAGES].filter((page) => {
+    return lambdaPages[page];
+  });
   Object.keys(prerenderManifest.staticRoutes).forEach((route) => {
     const result = onPrerenderRouteInitial(
       prerenderManifest,
@@ -14472,7 +14558,7 @@ ${JSON.stringify(
     for (const page of mergedPageKeys) {
       const originalPagePath = getOriginalPagePath(page);
       const pageBuildTrace = getBuildTraceFile(originalPagePath);
-      let fileList;
+      let fileList = [];
       let reasons;
       if (pageBuildTrace) {
         const { files } = JSON.parse(
@@ -14510,16 +14596,10 @@ ${JSON.stringify(
         });
         reasons = /* @__PURE__ */ new Map();
       } else {
+        const lambdaPage = lambdaPages[page];
         fileList = Array.from(
-          parentFilesMap?.get(
-            import_path4.default.relative(baseDir, lambdaPages[page].fsPath)
-          ) || []
+          parentFilesMap?.get(import_path4.default.relative(baseDir, lambdaPage.fsPath)) || []
         );
-        if (!fileList) {
-          throw new Error(
-            `Invariant: Failed to trace ${page}, missing fileList`
-          );
-        }
         reasons = traceResult?.reasons || /* @__PURE__ */ new Map();
       }
       const tracedFiles = Object.fromEntries(
@@ -14986,7 +15066,8 @@ ${JSON.stringify(
     isCorrectNotFoundRoutes,
     isEmptyAllowQueryForPrendered,
     isAppPPREnabled,
-    isAppClientSegmentCacheEnabled
+    isAppClientSegmentCacheEnabled,
+    isAppClientParamParsingEnabled
   });
   await Promise.all(
     Object.keys(prerenderManifest.staticRoutes).map(
@@ -15042,7 +15123,9 @@ ${JSON.stringify(
     isServerMode: true,
     dynamicMiddlewareRouteMap: middleware.dynamicRouteMap,
     isAppPPREnabled,
-    isAppClientSegmentCacheEnabled
+    isAppClientSegmentCacheEnabled,
+    isAppClientParamParsingEnabled,
+    prerenderManifest
   }).then(
     (arr) => localizeDynamicRoutes(
       arr,
@@ -15216,7 +15299,13 @@ ${JSON.stringify(
     }
   }
   const shouldHandleSegmentToRsc = Boolean(
-    isAppClientSegmentCacheEnabled && rscPrefetchHeader && prefetchSegmentHeader && prefetchSegmentDirSuffix && prefetchSegmentSuffix
+    isAppClientSegmentCacheEnabled && rscPrefetchHeader && prefetchSegmentHeader && prefetchSegmentDirSuffix && prefetchSegmentSuffix && // When the entire application has PPR enabled (all the routes) and both
+    // client param parsing and client segment cache are enabled we do not
+    // need the .prefetch.rsc rewrite.
+    !shouldSkipPrefetchRSCHandling
+  );
+  const serverActionMetaRoutes = await getServerActionMetaRoutes(
+    import_path4.default.join(entryPath, outputDirectory)
   );
   return {
     wildcard: wildcardConfig,
@@ -15374,6 +15463,7 @@ ${JSON.stringify(
       ] : [],
       ...headers,
       ...redirects,
+      ...serverActionMetaRoutes,
       // middleware comes directly after redirects but before
       // beforeFiles rewrites as middleware is not a "file" route
       ...routesManifest?.skipMiddlewareUrlNormalize ? denormalizeNextDataRoute(true) : [],
@@ -15491,9 +15581,7 @@ ${JSON.stringify(
             override: true
           }
         ] : [],
-        ...rscPrefetchHeader && isAppPPREnabled && // when client segment cache is enabled we do not need
-        // the .prefetch.rsc routing
-        !isAppClientSegmentCacheEnabled ? [
+        ...rscPrefetchHeader && isAppPPREnabled && !shouldSkipPrefetchRSCHandling ? [
           {
             src: `^${import_path4.default.posix.join("/", entryDirectory, "/")}$`,
             has: [
@@ -15609,28 +15697,34 @@ ${JSON.stringify(
       ...afterFilesRewrites,
       // ensure non-normalized /.rsc from rewrites is handled
       ...appPathRoutesManifest ? [
-        {
-          src: import_path4.default.posix.join("/", entryDirectory, "/\\.prefetch\\.rsc$"),
-          dest: import_path4.default.posix.join(
-            "/",
-            entryDirectory,
-            `/__index${RSC_PREFETCH_SUFFIX}`
-          ),
-          check: true
-        },
-        {
-          src: import_path4.default.posix.join(
-            "/",
-            entryDirectory,
-            "(.+)/\\.prefetch\\.rsc$"
-          ),
-          dest: import_path4.default.posix.join(
-            "/",
-            entryDirectory,
-            `$1${RSC_PREFETCH_SUFFIX}`
-          ),
-          check: true
-        },
+        ...shouldSkipPrefetchRSCHandling ? [] : [
+          {
+            src: import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              "/\\.prefetch\\.rsc$"
+            ),
+            dest: import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              `/__index${RSC_PREFETCH_SUFFIX}`
+            ),
+            check: true
+          },
+          {
+            src: import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              "(.+)/\\.prefetch\\.rsc$"
+            ),
+            dest: import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              `$1${RSC_PREFETCH_SUFFIX}`
+            ),
+            check: true
+          }
+        ],
         {
           src: import_path4.default.posix.join("/", entryDirectory, "/\\.rsc$"),
           dest: import_path4.default.posix.join("/", entryDirectory, `/index.rsc`),
@@ -15714,7 +15808,7 @@ ${JSON.stringify(
       ] : [],
       // If it didn't match any of the static routes or dynamic ones, then we
       // should fallback to either prefetch or normal RSC request
-      ...shouldHandleSegmentToRsc && prefetchSegmentDirSuffix && prefetchSegmentSuffix ? [
+      ...shouldHandleSegmentToRsc ? [
         {
           src: "^/(?<path>.+)(?<rscSuffix>\\.segments/.+\\.segment\\.rsc)(?:/)?$",
           dest: `/$path${isAppPPREnabled ? ".prefetch.rsc" : ".rsc"}`,
@@ -16928,7 +17022,10 @@ 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" || requiredServerFilesManifest.config.experimental?.cacheComponents === true : false;
+    const isAppFullPPREnabled = requiredServerFilesManifest ? requiredServerFilesManifest?.config.experimental?.ppr === true || requiredServerFilesManifest.config.experimental?.cacheComponents === true : false;
     const isAppClientSegmentCacheEnabled = requiredServerFilesManifest ? requiredServerFilesManifest.config.experimental?.clientSegmentCache === true : false;
+    const isAppClientParamParsingEnabled = routesManifest?.rsc?.clientParamParsing ?? false;
+    const clientParamParsingOrigins = requiredServerFilesManifest ? requiredServerFilesManifest.config.experimental?.clientParamParsingOrigins : void 0;
     if (requiredServerFilesManifest) {
       if (!routesManifest) {
         throw new Error(
@@ -16978,7 +17075,10 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         variantsManifest,
         experimentalPPRRoutes,
         isAppPPREnabled,
-        isAppClientSegmentCacheEnabled
+        isAppFullPPREnabled,
+        isAppClientSegmentCacheEnabled,
+        isAppClientParamParsingEnabled,
+        clientParamParsingOrigins
       });
     }
     const pageKeys = Object.keys(pages);
@@ -17369,7 +17469,10 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       canUsePreviewMode,
       bypassToken: prerenderManifest.bypassToken || "",
       isServerMode,
-      isAppPPREnabled: false
+      isAppPPREnabled: false,
+      isAppClientParamParsingEnabled,
+      isAppClientSegmentCacheEnabled,
+      prerenderManifest
     }).then(
       (arr) => localizeDynamicRoutes(
         arr,
@@ -17395,7 +17498,10 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         canUsePreviewMode,
         bypassToken: prerenderManifest.bypassToken || "",
         isServerMode,
-        isAppPPREnabled: false
+        isAppPPREnabled: false,
+        isAppClientParamParsingEnabled: false,
+        isAppClientSegmentCacheEnabled: false,
+        prerenderManifest
       }).then(
         (arr) => arr.map((route) => {
           route.src = route.src.replace("^", `^${dynamicPrefix}`);
@@ -17574,8 +17680,10 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       appPathRoutesManifest,
       isSharedLambdas,
       canUsePreviewMode,
+      // The following flags are not supported in this version of the builder.
       isAppPPREnabled: false,
-      isAppClientSegmentCacheEnabled: false
+      isAppClientSegmentCacheEnabled: false,
+      isAppClientParamParsingEnabled: false
     });
     await Promise.all(
       Object.keys(prerenderManifest.staticRoutes).map(

package/package.json

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