@netlify/plugin-nextjs 5.12.0 → 5.13.0

package/dist/build/content/prerendered.js

@@ -7,7 +7,7 @@
 import {
   trace,
   wrapTracer
-} from "../../esm-chunks/chunk-FKDTZJRV.js";
+} from "../../esm-chunks/chunk-5V5HA6YA.js";
 import {
   require_out
 } from "../../esm-chunks/chunk-YUXQHOYO.js";
@@ -190,23 +190,39 @@ var buildPagesCacheValue = async (path, initialRevalidateSeconds, shouldUseEnumK
   status: void 0,
   revalidate: initialRevalidateSeconds
 });
+var RSC_SEGMENTS_DIR_SUFFIX = ".segments";
+var RSC_SEGMENT_SUFFIX = ".segment.rsc";
 var buildAppCacheValue = async (path, shouldUseAppPageKind) => {
   const meta = JSON.parse(await readFile(`${path}.meta`, "utf-8"));
   const html = await readFile(`${path}.html`, "utf-8");
   if (shouldUseAppPageKind) {
+    let segmentData;
+    if (meta.segmentPaths) {
+      const segmentsDir = path + RSC_SEGMENTS_DIR_SUFFIX;
+      segmentData = Object.fromEntries(
+        await Promise.all(
+          meta.segmentPaths.map(async (segmentPath) => {
+            const segmentDataFilePath = segmentsDir + segmentPath + RSC_SEGMENT_SUFFIX;
+            const segmentContent = await readFile(segmentDataFilePath, "base64");
+            return [segmentPath, segmentContent];
+          })
+        )
+      );
+    }
     return {
       kind: "APP_PAGE",
       html,
       rscData: await readFile(`${path}.rsc`, "base64").catch(
         () => readFile(`${path}.prefetch.rsc`, "base64")
       ),
+      segmentData,
       ...meta
     };
   }
   const rsc = await readFile(`${path}.rsc`, "utf-8").catch(
     () => readFile(`${path}.prefetch.rsc`, "utf-8")
   );
-  if (!meta.status && rsc.includes("NEXT_NOT_FOUND") && !meta.headers["x-next-cache-tags"].includes("/@")) {
+  if (!meta.status && rsc.includes("NEXT_NOT_FOUND") && !(typeof meta.headers?.["x-next-cache-tags"] === "string" && meta.headers?.["x-next-cache-tags"].includes("/@"))) {
     meta.status = 404;
   }
   return {
@@ -280,17 +296,29 @@ var copyPrerenderedContent = async (ctx) => {
             await writeCacheEntry(key, value, lastModified, ctx);
           })
         ),
-        ...ctx.getFallbacks(manifest).map(async (route) => {
-          const key = routeToFilePath(route);
-          const value = await buildPagesCacheValue(
-            join(ctx.publishDir, "server/pages", key),
-            void 0,
-            shouldUseEnumKind,
-            true
-            // there is no corresponding json file for fallback, so we are skipping it for this entry
-          );
-          await writeCacheEntry(key, value, Date.now(), ctx);
-        })
+        ...ctx.getFallbacks(manifest).map(
+          (route) => limitConcurrentPrerenderContentHandling(async () => {
+            const key = routeToFilePath(route);
+            const value = await buildPagesCacheValue(
+              join(ctx.publishDir, "server/pages", key),
+              void 0,
+              shouldUseEnumKind,
+              true
+              // there is no corresponding json file for fallback, so we are skipping it for this entry
+            );
+            await writeCacheEntry(key, value, Date.now(), ctx);
+          })
+        ),
+        ...ctx.getShells(manifest).map(
+          (route) => limitConcurrentPrerenderContentHandling(async () => {
+            const key = routeToFilePath(route);
+            const value = await buildAppCacheValue(
+              join(ctx.publishDir, "server/app", key),
+              shouldUseAppPageKind
+            );
+            await writeCacheEntry(key, value, Date.now(), ctx);
+          })
+        )
       ]);
       if (existsSync(join(ctx.publishDir, `server/app/_not-found.html`))) {
         const lastModified = Date.now();

package/dist/build/content/server.js

@@ -7,7 +7,7 @@
 import {
   trace,
   wrapTracer
-} from "../../esm-chunks/chunk-FKDTZJRV.js";
+} from "../../esm-chunks/chunk-5V5HA6YA.js";
 import {
   require_out
 } from "../../esm-chunks/chunk-YUXQHOYO.js";
@@ -109,6 +109,14 @@ var copyNextServerCode = async (ctx) => {
           }
           return;
         }
+        if (path === "server/functions-config-manifest.json") {
+          try {
+            await replaceFunctionsConfigManifest(srcPath, destPath);
+          } catch (error) {
+            throw new Error("Could not patch functions config manifest file", { cause: error });
+          }
+          return;
+        }
         await cp(srcPath, destPath, { recursive: true, force: true });
       })
     );
@@ -246,6 +254,35 @@ var replaceMiddlewareManifest = async (sourcePath, destPath) => {
   const newData = JSON.stringify(newManifest);
   await writeFile(destPath, newData);
 };
+var replaceFunctionsConfigManifest = async (sourcePath, destPath) => {
+  const data = await readFile(sourcePath, "utf8");
+  const manifest = JSON.parse(data);
+  if (manifest?.functions?.["/_middleware"]?.matchers) {
+    const newManifest = {
+      ...manifest,
+      functions: {
+        ...manifest.functions,
+        "/_middleware": {
+          ...manifest.functions["/_middleware"],
+          matchers: manifest.functions["/_middleware"].matchers.map((matcher) => {
+            return {
+              ...matcher,
+              // matcher that won't match on anything
+              // this is meant to disable actually running middleware in the server handler,
+              // while still allowing next server to enable some middleware specific handling
+              // such as _next/data normalization ( https://github.com/vercel/next.js/blob/7bb72e508572237fe0d4aac5418546d4b4b3a363/packages/next/src/server/lib/router-utils/resolve-routes.ts#L395 )
+              regexp: "(?!.*)"
+            };
+          })
+        }
+      }
+    };
+    const newData = JSON.stringify(newManifest);
+    await writeFile(destPath, newData);
+  } else {
+    await cp(sourcePath, destPath, { recursive: true, force: true });
+  }
+};
 var verifyHandlerDirStructure = async (ctx) => {
   const { nextConfig } = JSON.parse(
     await readFile(join(ctx.serverHandlerDir, RUN_CONFIG_FILE), "utf-8")

package/dist/build/content/static.js

@@ -7,7 +7,7 @@
 import {
   trace,
   wrapTracer
-} from "../../esm-chunks/chunk-FKDTZJRV.js";
+} from "../../esm-chunks/chunk-5V5HA6YA.js";
 import {
   require_out
 } from "../../esm-chunks/chunk-YUXQHOYO.js";

package/dist/build/functions/edge.js

@@ -406,8 +406,11 @@ var require_dist = __commonJS({
 var import_fast_glob = __toESM(require_out(), 1);
 var import_path_to_regexp = __toESM(require_dist(), 1);
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, relative } from "node:path/posix";
 import { EDGE_HANDLER_NAME } from "../plugin-context.js";
+function nodeMiddlewareDefinitionHasMatcher(definition) {
+  return Array.isArray(definition.matchers);
+}
 var writeEdgeManifest = async (ctx, manifest) => {
   await mkdir(ctx.edgeFunctionsDir, { recursive: true });
   await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
@@ -487,11 +490,11 @@ var writeHandlerFile = async (ctx, { matchers, name }) => {
     `
   );
 };
-var copyHandlerDependencies = async (ctx, { name, env, files, wasm }) => {
+var copyHandlerDependenciesForEdgeMiddleware = async (ctx, { name, env, files, wasm }) => {
   const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
   const destDir = join(ctx.edgeFunctionsDir, getHandlerName({ name }));
   const edgeRuntimeDir = join(ctx.pluginDir, "edge-runtime");
-  const shimPath = join(edgeRuntimeDir, "shim/index.js");
+  const shimPath = join(edgeRuntimeDir, "shim/edge.js");
   const shim = await readFile(shimPath, "utf8");
   const parts = [shim];
   const outputFile = join(destDir, `server/${name}.js`);
@@ -520,17 +523,87 @@ var copyHandlerDependencies = async (ctx, { name, env, files, wasm }) => {
   await mkdir(dirname(outputFile), { recursive: true });
   await writeFile(outputFile, parts.join("\n"));
 };
+var NODE_MIDDLEWARE_NAME = "node-middleware";
+var copyHandlerDependenciesForNodeMiddleware = async (ctx) => {
+  const name = NODE_MIDDLEWARE_NAME;
+  const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
+  const destDir = join(ctx.edgeFunctionsDir, getHandlerName({ name }));
+  const edgeRuntimeDir = join(ctx.pluginDir, "edge-runtime");
+  const shimPath = join(edgeRuntimeDir, "shim/node.js");
+  const shim = await readFile(shimPath, "utf8");
+  const parts = [shim];
+  const entry = "server/middleware.js";
+  const nft = `${entry}.nft.json`;
+  const nftFilesPath = join(process.cwd(), ctx.nextDistDir, nft);
+  const nftManifest = JSON.parse(await readFile(nftFilesPath, "utf8"));
+  const files = nftManifest.files.map((file) => join("server", file));
+  files.push(entry);
+  const { maxParentDirectoriesPath, unsupportedDotNodeModules } = files.reduce(
+    (acc, file) => {
+      let dirsUp = 0;
+      let parentDirectoriesPath = "";
+      for (const part of file.split("/")) {
+        if (part === "..") {
+          dirsUp += 1;
+          parentDirectoriesPath += "../";
+        } else {
+          break;
+        }
+      }
+      if (file.endsWith(".node")) {
+        acc.unsupportedDotNodeModules.push(join(srcDir, file));
+      }
+      if (dirsUp > acc.maxDirsUp) {
+        return {
+          ...acc,
+          maxDirsUp: dirsUp,
+          maxParentDirectoriesPath: parentDirectoriesPath
+        };
+      }
+      return acc;
+    },
+    { maxDirsUp: 0, maxParentDirectoriesPath: "", unsupportedDotNodeModules: [] }
+  );
+  if (unsupportedDotNodeModules.length !== 0) {
+    throw new Error(
+      `Usage of unsupported C++ Addon(s) found in Node.js Middleware:
+${unsupportedDotNodeModules.map((file) => `- ${file}`).join("\n")}
+
+Check https://docs.netlify.com/build/frameworks/framework-setup-guides/nextjs/overview/#limitations for more information.`
+    );
+  }
+  const commonPrefix = relative(join(srcDir, maxParentDirectoriesPath), srcDir);
+  parts.push(`const virtualModules = new Map();`);
+  for (const file of files) {
+    const srcPath = join(srcDir, file);
+    const content = await readFile(srcPath, "utf8");
+    parts.push(
+      `virtualModules.set(${JSON.stringify(join(commonPrefix, file))}, ${JSON.stringify(content)});`
+    );
+  }
+  parts.push(`registerCJSModules(import.meta.url, virtualModules);
+
+    const require = createRequire(import.meta.url);
+    const handlerMod = require("./${join(commonPrefix, entry)}");
+    const handler = handlerMod.default || handlerMod;
+
+    export default handler
+    `);
+  const outputFile = join(destDir, `server/${name}.js`);
+  await mkdir(dirname(outputFile), { recursive: true });
+  await writeFile(outputFile, parts.join("\n"));
+};
 var createEdgeHandler = async (ctx, definition) => {
-  await copyHandlerDependencies(ctx, definition);
+  await (definition.runtime === "edge" ? copyHandlerDependenciesForEdgeMiddleware(ctx, definition.functionDefinition) : copyHandlerDependenciesForNodeMiddleware(ctx));
   await writeHandlerFile(ctx, definition);
 };
 var getHandlerName = ({ name }) => `${EDGE_HANDLER_NAME}-${name.replace(/\W/g, "-")}`;
-var buildHandlerDefinition = (ctx, { name, matchers, page }) => {
-  const functionHandlerName = getHandlerName({ name });
-  const functionName = name.endsWith("middleware") ? "Next.js Middleware Handler" : `Next.js Edge Handler: ${page}`;
-  const cache = name.endsWith("middleware") ? void 0 : "manual";
+var buildHandlerDefinition = (ctx, def) => {
+  const functionHandlerName = getHandlerName({ name: def.name });
+  const functionName = "Next.js Middleware Handler";
+  const cache = def.name.endsWith("middleware") ? void 0 : "manual";
   const generator = `${ctx.pluginName}@${ctx.pluginVersion}`;
-  return augmentMatchers(matchers, ctx).map((matcher) => ({
+  return augmentMatchers(def.matchers, ctx).map((matcher) => ({
     function: functionHandlerName,
     name: functionName,
     pattern: matcher.regexp,
@@ -543,9 +616,29 @@ var clearStaleEdgeHandlers = async (ctx) => {
 };
 var createEdgeHandlers = async (ctx) => {
   const nextManifest = await ctx.getMiddlewareManifest();
-  const nextDefinitions = [...Object.values(nextManifest.middleware)];
-  await Promise.all(nextDefinitions.map((def) => createEdgeHandler(ctx, def)));
-  const netlifyDefinitions = nextDefinitions.flatMap((def) => buildHandlerDefinition(ctx, def));
+  const middlewareDefinitions = [
+    ...Object.values(nextManifest.middleware)
+  ].map((edgeDefinition) => {
+    return {
+      runtime: "edge",
+      functionDefinition: edgeDefinition,
+      name: edgeDefinition.name,
+      matchers: edgeDefinition.matchers
+    };
+  });
+  const functionsConfigManifest = await ctx.getFunctionsConfigManifest();
+  if (functionsConfigManifest?.functions?.["/_middleware"] && nodeMiddlewareDefinitionHasMatcher(functionsConfigManifest?.functions?.["/_middleware"])) {
+    middlewareDefinitions.push({
+      runtime: "nodejs",
+      functionDefinition: functionsConfigManifest?.functions?.["/_middleware"],
+      name: NODE_MIDDLEWARE_NAME,
+      matchers: functionsConfigManifest?.functions?.["/_middleware"]?.matchers
+    });
+  }
+  await Promise.all(middlewareDefinitions.map((def) => createEdgeHandler(ctx, def)));
+  const netlifyDefinitions = middlewareDefinitions.flatMap(
+    (def) => buildHandlerDefinition(ctx, def)
+  );
   const netlifyManifest = {
     version: 1,
     functions: netlifyDefinitions

package/dist/build/functions/server.js

@@ -7,7 +7,7 @@
 import {
   trace,
   wrapTracer
-} from "../../esm-chunks/chunk-FKDTZJRV.js";
+} from "../../esm-chunks/chunk-5V5HA6YA.js";
 import {
   require_out
 } from "../../esm-chunks/chunk-YUXQHOYO.js";

package/dist/build/image-cdn.js

@@ -92,6 +92,7 @@ var require_constants = __commonJS({
       REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
       // Replace globs with equivalent patterns to reduce parsing time.
       REPLACEMENTS: {
+        __proto__: null,
         "***": "*",
         "**/**": "**",
         "**/**/**": "**"

package/dist/build/plugin-context.js

@@ -200,6 +200,19 @@ var PluginContext = class {
       await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
     );
   }
+  /**
+   * Get Next.js Functions Config Manifest config if it exists from the build output
+   */
+  async getFunctionsConfigManifest() {
+    const functionsConfigManifestPath = join(
+      this.publishDir,
+      "server/functions-config-manifest.json"
+    );
+    if (existsSync(functionsConfigManifestPath)) {
+      return JSON.parse(await readFile(functionsConfigManifestPath, "utf-8"));
+    }
+    return null;
+  }
   // don't make private as it is handy inside testing to override the config
   _requiredServerFiles = null;
   /** Get RequiredServerFiles manifest from build output **/
@@ -268,7 +281,7 @@ var PluginContext = class {
   }
   #fallbacks = null;
   /**
-   * Get an array of localized fallback routes
+   * Get an array of localized fallback routes for Pages Router
    *
    * Example return value for non-i18n site: `['blog/[slug]']`
    *
@@ -279,7 +292,7 @@ var PluginContext = class {
       const locales = this.buildConfig.i18n?.locales ?? [""];
       this.#fallbacks = Object.entries(prerenderManifest.dynamicRoutes).reduce(
         (fallbacks, [route, meta]) => {
-          if (typeof meta.fallback === "string") {
+          if (typeof meta.fallback === "string" && meta.renderingMode !== "PARTIALLY_STATIC") {
             for (const locale of locales) {
               const localizedRoute = posixJoin(locale, route.replace(/^\/+/g, ""));
               fallbacks.push(localizedRoute);
@@ -315,6 +328,24 @@ var PluginContext = class {
     }
     return this.#fullyStaticHtmlPages;
   }
+  #shells = null;
+  /**
+   * Get an array of static shells for App Router's PPR dynamic routes
+   */
+  getShells(prerenderManifest) {
+    if (!this.#shells) {
+      this.#shells = Object.entries(prerenderManifest.dynamicRoutes).reduce(
+        (shells, [route, meta]) => {
+          if (typeof meta.fallback === "string" && meta.renderingMode === "PARTIALLY_STATIC") {
+            shells.push(route);
+          }
+          return shells;
+        },
+        []
+      );
+    }
+    return this.#shells;
+  }
   /** Fails a build with a message and an optional error */
   failBuild(message, error) {
     return this.utils.build.failBuild(message, error instanceof Error ? { error } : void 0);

package/dist/esm-chunks/{chunk-FKDTZJRV.js → chunk-5V5HA6YA.js}

@@ -126,7 +126,7 @@ function createContextKey(description) {
 }
 var BaseContext = (
   /** @class */
-  /* @__PURE__ */ function() {
+  /* @__PURE__ */ (function() {
     function BaseContext2(parentContext) {
       var self = this;
       self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
@@ -145,7 +145,7 @@ var BaseContext = (
       };
     }
     return BaseContext2;
-  }()
+  })()
 );
 var ROOT_CONTEXT = new BaseContext();
 
@@ -178,7 +178,7 @@ var __spreadArray = function(to, from, pack) {
 };
 var NoopContextManager = (
   /** @class */
-  function() {
+  (function() {
     function NoopContextManager2() {
     }
     NoopContextManager2.prototype.active = function() {
@@ -201,7 +201,7 @@ var NoopContextManager = (
       return this;
     };
     return NoopContextManager2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
@@ -233,7 +233,7 @@ var __spreadArray2 = function(to, from, pack) {
 };
 var DiagComponentLogger = (
   /** @class */
-  function() {
+  (function() {
     function DiagComponentLogger2(props) {
       this._namespace = props.namespace || "DiagComponentLogger";
     }
@@ -273,7 +273,7 @@ var DiagComponentLogger = (
       return logProxy("verbose", this._namespace, args);
     };
     return DiagComponentLogger2;
-  }()
+  })()
 );
 function logProxy(funcName, namespace, args) {
   var logger = getGlobal("diag");
@@ -351,7 +351,7 @@ var __spreadArray3 = function(to, from, pack) {
 var API_NAME = "diag";
 var DiagAPI = (
   /** @class */
-  function() {
+  (function() {
     function DiagAPI2() {
       function _logProxy(funcName) {
         return function() {
@@ -410,7 +410,7 @@ var DiagAPI = (
       return this._instance;
     };
     return DiagAPI2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/api/context.js
@@ -444,7 +444,7 @@ var API_NAME2 = "context";
 var NOOP_CONTEXT_MANAGER = new NoopContextManager();
 var ContextAPI = (
   /** @class */
-  function() {
+  (function() {
     function ContextAPI2() {
     }
     ContextAPI2.getInstance = function() {
@@ -478,7 +478,7 @@ var ContextAPI = (
       unregisterGlobal(API_NAME2, DiagAPI.instance());
     };
     return ContextAPI2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
@@ -500,7 +500,7 @@ var INVALID_SPAN_CONTEXT = {
 // node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
 var NonRecordingSpan = (
   /** @class */
-  function() {
+  (function() {
     function NonRecordingSpan2(_spanContext) {
       if (_spanContext === void 0) {
         _spanContext = INVALID_SPAN_CONTEXT;
@@ -533,7 +533,7 @@ var NonRecordingSpan = (
     NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
     };
     return NonRecordingSpan2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
@@ -578,7 +578,7 @@ function wrapSpanContext(spanContext) {
 var contextApi = ContextAPI.getInstance();
 var NoopTracer = (
   /** @class */
-  function() {
+  (function() {
     function NoopTracer2() {
     }
     NoopTracer2.prototype.startSpan = function(name, options, context2) {
@@ -618,7 +618,7 @@ var NoopTracer = (
       return contextApi.with(contextWithSpanSet, fn, void 0, span);
     };
     return NoopTracer2;
-  }()
+  })()
 );
 function isSpanContext(spanContext) {
   return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
@@ -628,7 +628,7 @@ function isSpanContext(spanContext) {
 var NOOP_TRACER = new NoopTracer();
 var ProxyTracer = (
   /** @class */
-  function() {
+  (function() {
     function ProxyTracer2(_provider, name, version, options) {
       this._provider = _provider;
       this.name = name;
@@ -654,27 +654,27 @@ var ProxyTracer = (
       return this._delegate;
     };
     return ProxyTracer2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
 var NoopTracerProvider = (
   /** @class */
-  function() {
+  (function() {
     function NoopTracerProvider2() {
     }
     NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
       return new NoopTracer();
     };
     return NoopTracerProvider2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
 var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
 var ProxyTracerProvider = (
   /** @class */
-  function() {
+  (function() {
     function ProxyTracerProvider2() {
     }
     ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
@@ -693,14 +693,14 @@ var ProxyTracerProvider = (
       return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
     };
     return ProxyTracerProvider2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/api/trace.js
 var API_NAME3 = "trace";
 var TraceAPI = (
   /** @class */
-  function() {
+  (function() {
     function TraceAPI2() {
       this._proxyTracerProvider = new ProxyTracerProvider();
       this.wrapSpanContext = wrapSpanContext;
@@ -736,7 +736,7 @@ var TraceAPI = (
       this._proxyTracerProvider = new ProxyTracerProvider();
     };
     return TraceAPI2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace-api.js
@@ -765,7 +765,7 @@ function wrapTracer(tracer) {
 }
 var SugaredTracer = (
   /** @class */
-  function() {
+  (function() {
     function SugaredTracer2(tracer) {
       this._tracer = tracer;
       this.startSpan = tracer.startSpan.bind(this._tracer);
@@ -783,7 +783,7 @@ var SugaredTracer = (
       return handleFn(span, opts, fn);
     };
     return SugaredTracer2;
-  }()
+  })()
 );
 function massageParams(arg, arg2, arg3) {
   var opts;

package/dist/index.js

@@ -7,7 +7,7 @@
 import {
   trace,
   wrapTracer
-} from "./esm-chunks/chunk-FKDTZJRV.js";
+} from "./esm-chunks/chunk-5V5HA6YA.js";
 import "./esm-chunks/chunk-6BT4RYQJ.js";
 
 // src/index.ts

package/dist/run/config.js

@@ -30,6 +30,7 @@ var setRunConfig = (config) => {
     config.cacheMaxMemorySize ?? config.experimental?.isrMemoryCacheSize
   );
   process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
+  return config;
 };
 export {
   getRunConfig,

package/dist/run/handlers/cache.cjs

@@ -265,14 +265,20 @@ var NetlifyCacheHandler = class {
           if (requestContext && blob.value?.kind === "APP_PAGE") {
             requestContext.isCacheableAppPage = true;
           }
-          const { revalidate, rscData, ...restOfPageValue } = blob.value;
+          const { revalidate, rscData, segmentData, ...restOfPageValue } = blob.value;
           span.addEvent(blob.value?.kind, { lastModified: blob.lastModified, revalidate, ttl });
           await this.injectEntryToPrerenderManifest(key, blob.value);
           return {
             lastModified: blob.lastModified,
             value: {
               ...restOfPageValue,
-              rscData: rscData ? import_node_buffer.Buffer.from(rscData, "base64") : void 0
+              rscData: rscData ? import_node_buffer.Buffer.from(rscData, "base64") : void 0,
+              segmentData: segmentData ? new Map(
+                Object.entries(segmentData).map(([segmentPath, base64EncodedSegment]) => [
+                  segmentPath,
+                  import_node_buffer.Buffer.from(base64EncodedSegment, "base64")
+                ])
+              ) : void 0
             }
           };
         }
@@ -306,7 +312,13 @@ var NetlifyCacheHandler = class {
         ...data,
         revalidate: context.revalidate ?? context.cacheControl?.revalidate,
         cacheControl: context.cacheControl,
-        rscData: data.rscData?.toString("base64")
+        rscData: data.rscData?.toString("base64"),
+        segmentData: data.segmentData ? Object.fromEntries(
+          [...data.segmentData.entries()].map(([segmentPath, base64EncodedSegment]) => [
+            segmentPath,
+            base64EncodedSegment.toString("base64")
+          ])
+        ) : void 0
       };
     }
     return data;