@netlify/plugin-nextjs 5.0.0-beta.0 → 5.0.0-beta.2

package/dist/build/content/prerendered.js

@@ -7,7 +7,7 @@
 import {
   copyFetchContent,
   copyPrerenderedContent
-} from "../../esm-chunks/chunk-G3GM7JNF.js";
+} from "../../esm-chunks/chunk-S5JXJCXP.js";
 import "../../esm-chunks/chunk-AVWFCGVE.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {

package/dist/build/content/server.js

@@ -8,7 +8,7 @@ import {
   copyNextDependencies,
   copyNextServerCode,
   writeTagsManifest
-} from "../../esm-chunks/chunk-G2VRYWGL.js";
+} from "../../esm-chunks/chunk-5SZ5JD6J.js";
 import "../../esm-chunks/chunk-AVWFCGVE.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {

package/dist/build/content/static.js

@@ -9,7 +9,7 @@ import {
   copyStaticContent,
   publishStaticDir,
   unpublishStaticDir
-} from "../../esm-chunks/chunk-62KDS27E.js";
+} from "../../esm-chunks/chunk-Z7ZMLVTM.js";
 import "../../esm-chunks/chunk-AVWFCGVE.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {

package/dist/build/functions/edge.js

@@ -6,8 +6,8 @@
     
 import {
   createEdgeHandlers
-} from "../../esm-chunks/chunk-XD5TSLZO.js";
-import "../../esm-chunks/chunk-HPGTYMVD.js";
+} from "../../esm-chunks/chunk-3PTPU5GO.js";
+import "../../esm-chunks/chunk-TJKO3X6O.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {
   createEdgeHandlers

package/dist/build/functions/server.js

@@ -6,10 +6,10 @@
     
 import {
   createServerHandler
-} from "../../esm-chunks/chunk-PEBUKFKH.js";
-import "../../esm-chunks/chunk-G2VRYWGL.js";
+} from "../../esm-chunks/chunk-ALO2SSMH.js";
+import "../../esm-chunks/chunk-5SZ5JD6J.js";
 import "../../esm-chunks/chunk-AVWFCGVE.js";
-import "../../esm-chunks/chunk-HPGTYMVD.js";
+import "../../esm-chunks/chunk-TJKO3X6O.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {
   createServerHandler

package/dist/build/image-cdn.js

@@ -0,0 +1,13 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  setImageConfig
+} from "../esm-chunks/chunk-H46DW7YI.js";
+import "../esm-chunks/chunk-RSKIKBZH.js";
+export {
+  setImageConfig
+};

package/dist/build/plugin-context.js

@@ -8,7 +8,7 @@ import {
   EDGE_HANDLER_NAME,
   PluginContext,
   SERVER_HANDLER_NAME
-} from "../esm-chunks/chunk-HPGTYMVD.js";
+} from "../esm-chunks/chunk-TJKO3X6O.js";
 import "../esm-chunks/chunk-RSKIKBZH.js";
 export {
   EDGE_HANDLER_NAME,

package/dist/esm-chunks/{chunk-XD5TSLZO.js → chunk-3PTPU5GO.js}

@@ -6,7 +6,7 @@
     
 import {
   EDGE_HANDLER_NAME
-} from "./chunk-HPGTYMVD.js";
+} from "./chunk-TJKO3X6O.js";
 
 // src/build/functions/edge.ts
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
@@ -15,15 +15,16 @@ var writeEdgeManifest = async (ctx, manifest) => {
   await mkdir(ctx.edgeFunctionsDir, { recursive: true });
   await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
 };
-var writeHandlerFile = async (ctx, { name }) => {
+var writeHandlerFile = async (ctx, { matchers, name }) => {
   const handlerName = getHandlerName({ name });
-  await cp(
-    join(ctx.pluginDir, "edge-runtime"),
-    join(ctx.edgeFunctionsDir, handlerName, "edge-runtime"),
-    { recursive: true }
-  );
+  const handlerDirectory = join(ctx.edgeFunctionsDir, handlerName);
+  const handlerRuntimeDirectory = join(handlerDirectory, "edge-runtime");
+  await cp(join(ctx.pluginDir, "edge-runtime"), handlerRuntimeDirectory, {
+    recursive: true
+  });
+  await writeFile(join(handlerRuntimeDirectory, "matchers.json"), JSON.stringify(matchers));
   await writeFile(
-    join(ctx.edgeFunctionsDir, handlerName, `${handlerName}.js`),
+    join(handlerDirectory, `${handlerName}.js`),
     `
     import {handleMiddleware} from './edge-runtime/middleware.ts';
     import handler from './server/${name}.js';

package/dist/esm-chunks/{chunk-G2VRYWGL.js → chunk-5SZ5JD6J.js}

@@ -19,19 +19,26 @@ import { dirname, join } from "node:path";
 var copyNextServerCode = async (ctx) => {
   const srcDir = join(ctx.publishDir, "standalone/.next");
   const destDir = join(ctx.serverHandlerDir, ".next");
-  const paths = await (0, import_fast_glob.default)([`*`, `server/*`, `server/chunks/*`, `server/+(app|pages)/**/*.js`], {
-    cwd: srcDir,
-    extglob: true
-  });
+  const paths = await (0, import_fast_glob.default)(
+    [`*`, `server/*`, `server/chunks/*`, `server/edge-chunks/*`, `server/+(app|pages)/**/*.js`],
+    {
+      cwd: srcDir,
+      extglob: true
+    }
+  );
   await Promise.all(
     paths.map(async (path) => {
+      const srcPath = join(srcDir, path);
       const destPath = join(destDir, path);
       if (path === "server/middleware-manifest.json") {
-        await mkdir(dirname(destPath), { recursive: true });
-        await writeFile(destPath, getEmptyMiddlewareManifest());
+        try {
+          await replaceMiddlewareManifest(srcPath, destPath);
+        } catch (error) {
+          throw new Error("Could not patch middleware manifest file", { cause: error });
+        }
         return;
       }
-      await cp(join(srcDir, path), destPath, { recursive: true });
+      await cp(srcPath, destPath, { recursive: true });
     })
   );
 };
@@ -73,7 +80,9 @@ var writeTagsManifest = async (ctx) => {
         const meta = JSON.parse(file);
         tags = meta.headers["x-next-cache-tags"];
       } catch {
-        console.log(`Unable to read cache tags for: ${path}`);
+        if (!definition.dataRoute?.endsWith("/default.rsc")) {
+          console.log(`Unable to read cache tags for: ${path}`);
+        }
       }
     }
     if (definition.dataRoute?.endsWith(".json")) {
@@ -90,14 +99,16 @@ var writeTagsManifest = async (ctx) => {
     "utf-8"
   );
 };
-var getEmptyMiddlewareManifest = () => {
-  const manifest = {
-    sortedMiddleware: [],
-    middleware: {},
-    functions: {},
-    version: 2
+var replaceMiddlewareManifest = async (sourcePath, destPath) => {
+  await mkdir(dirname(destPath), { recursive: true });
+  const data = await readFile(sourcePath, "utf8");
+  const manifest = JSON.parse(data);
+  const newManifest = {
+    ...manifest,
+    middleware: {}
   };
-  return JSON.stringify(manifest);
+  const newData = JSON.stringify(newManifest);
+  await writeFile(destPath, newData);
 };
 
 export {

package/dist/esm-chunks/{chunk-PEBUKFKH.js → chunk-ALO2SSMH.js}

@@ -8,13 +8,13 @@ import {
   copyNextDependencies,
   copyNextServerCode,
   writeTagsManifest
-} from "./chunk-G2VRYWGL.js";
+} from "./chunk-5SZ5JD6J.js";
 import {
   require_out
 } from "./chunk-AVWFCGVE.js";
 import {
   SERVER_HANDLER_NAME
-} from "./chunk-HPGTYMVD.js";
+} from "./chunk-TJKO3X6O.js";
 import {
   __toESM
 } from "./chunk-RSKIKBZH.js";

package/dist/esm-chunks/chunk-H46DW7YI.js

@@ -0,0 +1,28 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/build/image-cdn.ts
+var setImageConfig = async (ctx) => {
+  const {
+    images: { path: imageEndpointPath, loader: imageLoader }
+  } = await ctx.getBuildConfig();
+  if (imageLoader === "default") {
+    ctx.netlifyConfig.redirects.push({
+      from: imageEndpointPath,
+      // w and q are too short to be used as params with id-length rule
+      // but we are forced to do so because of the next/image loader decides on their names
+      // eslint-disable-next-line id-length
+      query: { url: ":url", w: ":width", q: ":quality" },
+      to: "/.netlify/images?url=:url&w=:width&q=:quality",
+      status: 200
+    });
+  }
+};
+
+export {
+  setImageConfig
+};

package/dist/esm-chunks/{chunk-G3GM7JNF.js → chunk-S5JXJCXP.js}

@@ -45,6 +45,8 @@ var copyPrerenderedContent = async (ctx) => {
         const key = routeToFilePath(route);
         let value;
         switch (true) {
+          case (meta.dataRoute?.endsWith("/default.rsc") && !existsSync(join(ctx.publishDir, "server/app", `${key}.html`))):
+            return;
           case meta.dataRoute?.endsWith(".json"):
             value = await buildPagesCacheValue(join(ctx.publishDir, "server/pages", key));
             break;

package/dist/esm-chunks/{chunk-ZBX3SNQG.js → chunk-SMSOJ2OS.js}

@@ -13,6 +13,8 @@ import { Buffer } from "buffer";
 import { env } from "process";
 import { Buffer as Buffer2 } from "buffer";
 import { Buffer as Buffer3 } from "buffer";
+import stream from "stream";
+import { promisify } from "util";
 var getEnvironmentContext = () => {
   const context = globalThis.netlifyBlobsContext || env.NETLIFY_BLOBS_CONTEXT;
   if (typeof context !== "string" || !context) {
@@ -382,6 +384,9 @@ var Store = class _Store {
     };
   }
   static validateKey(key) {
+    if (key === "") {
+      throw new Error("Blob key must not be empty.");
+    }
     if (key.startsWith("/") || key.startsWith("%2F")) {
       throw new Error("Blob key must not start with forward slash (/).");
     }
@@ -466,6 +471,7 @@ var getDeployStore = (options = {}) => {
   const client = new Client(clientOptions);
   return new Store({ client, deployID });
 };
+var pipeline = promisify(stream.pipeline);
 
 // src/run/headers.ts
 var generateNetlifyVaryValues = ({ headers, languages, cookies }) => {
@@ -532,9 +538,9 @@ var adjustDateHeader = async (headers, request) => {
   headers.set("x-nextjs-date", headers.get("date") ?? lastModifiedDate.toUTCString());
   headers.set("date", lastModifiedDate.toUTCString());
 };
-var setCacheControlHeaders = (headers) => {
+var setCacheControlHeaders = (headers, request) => {
   const cacheControl = headers.get("cache-control");
-  if (cacheControl !== null && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
+  if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
     const privateCacheControl = omitHeaderValues(cacheControl, [
       "s-maxage",
       "stale-while-revalidate"
@@ -552,10 +558,25 @@ var setCacheTagsHeaders = (headers, request, manifest) => {
   const tags = manifest[path];
   headers.set("cache-tag", tags);
 };
+var NEXT_CACHE_TO_CACHE_STATUS = {
+  HIT: `hit`,
+  MISS: `miss,`
+};
+var handleNextCacheHeader = (headers) => {
+  const nextCache = headers.get("x-nextjs-cache");
+  if (typeof nextCache === "string") {
+    if (nextCache in NEXT_CACHE_TO_CACHE_STATUS) {
+      const cacheStatus = NEXT_CACHE_TO_CACHE_STATUS[nextCache];
+      headers.set("cache-status", `"Next.js"; ${cacheStatus}`);
+    }
+    headers.delete("x-nextjs-cache");
+  }
+};
 
 export {
   setVaryHeaders,
   adjustDateHeader,
   setCacheControlHeaders,
-  setCacheTagsHeaders
+  setCacheTagsHeaders,
+  handleNextCacheHeader
 };

package/dist/esm-chunks/{chunk-HPGTYMVD.js → chunk-TJKO3X6O.js}

@@ -17,6 +17,7 @@ var SERVER_HANDLER_NAME = "___netlify-server-handler";
 var EDGE_HANDLER_NAME = "___netlify-edge-handler";
 var PluginContext = class {
   utils;
+  netlifyConfig;
   pluginName;
   pluginVersion;
   constants;
@@ -70,6 +71,7 @@ var PluginContext = class {
     this.pluginVersion = this.packageJSON.version;
     this.constants = options.constants;
     this.utils = options.utils;
+    this.netlifyConfig = options.netlifyConfig;
   }
   /** Resolves a path correctly with mono repository awareness  */
   resolve(...args) {
@@ -87,6 +89,16 @@ var PluginContext = class {
       await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
     );
   }
+  /** Get Next Config from build output **/
+  async getBuildConfig() {
+    return JSON.parse(await readFile(join(this.publishDir, "required-server-files.json"), "utf-8")).config;
+  }
+  /**
+   * Get Next.js routes manifest from the build output
+   */
+  async getRoutesManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "utf-8"));
+  }
   /**
    * Write a cache entry to the blob upload directory using
    * base64 keys to avoid collisions with directories

package/dist/esm-chunks/chunk-YZXA5QBC.js

@@ -0,0 +1,60 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/systemlog.ts
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var StructuredLogger = class _StructuredLogger {
+  fields;
+  message;
+  constructor(message, fields) {
+    this.fields = fields ?? {};
+    this.message = message ?? "";
+  }
+  // TODO: add sampling
+  doLog(logger2, message) {
+    logger2(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    this.doLog(console.log, message);
+  }
+  info(message) {
+    this.doLog(console.info, message);
+  }
+  debug(message) {
+    this.doLog(console.debug, message);
+  }
+  warn(message) {
+    this.doLog(console.warn, message);
+  }
+  error(message) {
+    this.doLog(console.error, message);
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+  withFields(fields) {
+    return new _StructuredLogger(this.message, {
+      ...this.fields,
+      ...fields
+    });
+  }
+};
+var logger = new StructuredLogger();
+
+export {
+  StructuredLogger,
+  logger
+};

package/dist/esm-chunks/{chunk-62KDS27E.js → chunk-Z7ZMLVTM.js}

@@ -38,11 +38,12 @@ var copyStaticContent = async (ctx) => {
 var copyStaticAssets = async (ctx) => {
   try {
     await rm(ctx.staticDir, { recursive: true, force: true });
+    const { basePath } = await ctx.getRoutesManifest();
     if (existsSync(ctx.resolve("public"))) {
-      await cp(ctx.resolve("public"), ctx.staticDir, { recursive: true });
+      await cp(ctx.resolve("public"), join(ctx.staticDir, basePath), { recursive: true });
     }
     if (existsSync(join(ctx.publishDir, "static"))) {
-      await cp(join(ctx.publishDir, "static"), join(ctx.staticDir, "_next/static"), {
+      await cp(join(ctx.publishDir, "static"), join(ctx.staticDir, basePath, "_next/static"), {
         recursive: true
       });
     }

package/dist/index.js

@@ -4,31 +4,34 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  createServerHandler
-} from "./esm-chunks/chunk-PEBUKFKH.js";
 import {
   copyFetchContent,
   copyPrerenderedContent
-} from "./esm-chunks/chunk-G3GM7JNF.js";
-import "./esm-chunks/chunk-G2VRYWGL.js";
+} from "./esm-chunks/chunk-S5JXJCXP.js";
 import {
   copyStaticAssets,
   copyStaticContent,
   publishStaticDir,
   unpublishStaticDir
-} from "./esm-chunks/chunk-62KDS27E.js";
+} from "./esm-chunks/chunk-Z7ZMLVTM.js";
+import {
+  createEdgeHandlers
+} from "./esm-chunks/chunk-3PTPU5GO.js";
+import {
+  createServerHandler
+} from "./esm-chunks/chunk-ALO2SSMH.js";
+import "./esm-chunks/chunk-5SZ5JD6J.js";
 import "./esm-chunks/chunk-AVWFCGVE.js";
 import {
   restoreBuildCache,
   saveBuildCache
 } from "./esm-chunks/chunk-GGHAQM5D.js";
 import {
-  createEdgeHandlers
-} from "./esm-chunks/chunk-XD5TSLZO.js";
+  setImageConfig
+} from "./esm-chunks/chunk-H46DW7YI.js";
 import {
   PluginContext
-} from "./esm-chunks/chunk-HPGTYMVD.js";
+} from "./esm-chunks/chunk-TJKO3X6O.js";
 import "./esm-chunks/chunk-RSKIKBZH.js";
 
 // src/index.ts
@@ -42,6 +45,7 @@ var onBuild = async (options) => {
   if (!existsSync(ctx.publishDir)) {
     ctx.failBuild("Publish directory not found, please check your netlify.toml");
   }
+  await setImageConfig(ctx);
   await saveBuildCache(ctx);
   await Promise.all([
     copyStaticAssets(ctx),

package/dist/run/handlers/cache.cjs

@@ -174,8 +174,8 @@ var require_stream = __commonJS({
     exports2.stream = void 0;
     var node_stream_1 = require("node:stream");
     var node_util_1 = require("node:util");
-    var pipeline = (0, node_util_1.promisify)(node_stream_1.pipeline);
-    var stream = (handler) => awslambda.streamifyResponse(async (event, responseStream, context) => {
+    var pipeline2 = (0, node_util_1.promisify)(node_stream_1.pipeline);
+    var stream2 = (handler) => awslambda.streamifyResponse(async (event, responseStream, context) => {
       const { body, ...httpResponseMetadata } = await handler(event, context);
       const responseBody = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
       if (typeof body === "undefined") {
@@ -184,10 +184,10 @@ var require_stream = __commonJS({
         responseBody.write(body);
         responseBody.end();
       } else {
-        await pipeline(body, responseBody);
+        await pipeline2(body, responseBody);
       }
     });
-    exports2.stream = stream;
+    exports2.stream = stream2;
   }
 });
 
@@ -249,7 +249,6 @@ var require_main = __commonJS({
 var cache_exports = {};
 __export(cache_exports, {
   NetlifyCacheHandler: () => NetlifyCacheHandler,
-  blobStore: () => blobStore,
   default: () => cache_default
 });
 module.exports = __toCommonJS(cache_exports);
@@ -262,6 +261,8 @@ var import_buffer = require("buffer");
 var import_process = require("process");
 var import_buffer2 = require("buffer");
 var import_buffer3 = require("buffer");
+var import_stream = __toESM(require("stream"), 1);
+var import_util = require("util");
 var getEnvironmentContext = () => {
   const context = globalThis.netlifyBlobsContext || import_process.env.NETLIFY_BLOBS_CONTEXT;
   if (typeof context !== "string" || !context) {
@@ -631,6 +632,9 @@ var Store = class _Store {
     };
   }
   static validateKey(key) {
+    if (key === "") {
+      throw new Error("Blob key must not be empty.");
+    }
     if (key.startsWith("/") || key.startsWith("%2F")) {
       throw new Error("Blob key must not start with forward slash (/).");
     }
@@ -715,11 +719,11 @@ var getDeployStore = (options = {}) => {
   const client = new Client(clientOptions);
   return new Store({ client, deployID });
 };
+var pipeline = (0, import_util.promisify)(import_stream.default.pipeline);
 
 // src/run/handlers/cache.cts
 var import_functions = __toESM(require_main());
 var import_constants = require("next/dist/lib/constants.js");
-var blobStore = getDeployStore();
 var prerenderManifest = JSON.parse(
   (0, import_node_fs.readFileSync)((0, import_posix.join)(process.cwd(), ".next/prerender-manifest.json"), "utf-8")
 );
@@ -729,17 +733,20 @@ function toRoute(cacheKey) {
 function encodeBlobKey(key) {
   return import_node_buffer.Buffer.from(key.replace(/^\//, "")).toString("base64");
 }
+var fetchBeforeNextPatchedIt = globalThis.fetch;
 var NetlifyCacheHandler = class {
   options;
   revalidatedTags;
+  blobStore;
   constructor(options) {
     this.options = options;
     this.revalidatedTags = options.revalidatedTags;
+    this.blobStore = getDeployStore({ fetch: fetchBeforeNextPatchedIt });
   }
   async get(...args) {
     const [key, ctx = {}] = args;
     console.debug(`[NetlifyCacheHandler.get]: ${key}`);
-    const blob = await blobStore.get(encodeBlobKey(key), {
+    const blob = await this.blobStore.get(encodeBlobKey(key), {
       type: "json"
     });
     if (!blob) {
@@ -783,7 +790,7 @@ var NetlifyCacheHandler = class {
   async set(...args) {
     const [key, data] = args;
     console.debug(`[NetlifyCacheHandler.set]: ${key}`);
-    await blobStore.setJSON(encodeBlobKey(key), {
+    await this.blobStore.setJSON(encodeBlobKey(key), {
       lastModified: Date.now(),
       value: data
     });
@@ -795,7 +802,7 @@ var NetlifyCacheHandler = class {
       revalidatedAt: Date.now()
     };
     try {
-      await blobStore.setJSON(encodeBlobKey(tag), data);
+      await this.blobStore.setJSON(encodeBlobKey(tag), data);
     } catch (error) {
       console.warn(`Failed to update tag manifest for ${tag}`, error);
     }
@@ -811,7 +818,7 @@ var NetlifyCacheHandler = class {
     const cacheTags = [...tags, ...softTags];
     const allManifests = await Promise.all(
       cacheTags.map(async (tag) => {
-        const res = await blobStore.get(encodeBlobKey(tag), { type: "json" }).then((value) => ({ [tag]: value })).catch(console.error);
+        const res = await this.blobStore.get(encodeBlobKey(tag), { type: "json" }).then((value) => ({ [tag]: value })).catch(console.error);
         return res || { [tag]: null };
       })
     );
@@ -844,6 +851,5 @@ var NetlifyCacheHandler = class {
 var cache_default = NetlifyCacheHandler;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  NetlifyCacheHandler,
-  blobStore
+  NetlifyCacheHandler
 });

package/dist/run/handlers/server.js

@@ -4,16 +4,20 @@
         return createRequire(import.meta.url);
       })();
     
+import {
+  logger
+} from "../../esm-chunks/chunk-YZXA5QBC.js";
 import {
   getTagsManifest
 } from "../../esm-chunks/chunk-R4NHZWGU.js";
 import "../../esm-chunks/chunk-4AJYXTWN.js";
 import {
   adjustDateHeader,
+  handleNextCacheHeader,
   setCacheControlHeaders,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../../esm-chunks/chunk-ZBX3SNQG.js";
+} from "../../esm-chunks/chunk-SMSOJ2OS.js";
 import {
   nextResponseProxy
 } from "../../esm-chunks/chunk-B6QMRLBH.js";
@@ -3260,9 +3264,10 @@ var server_default = async (request) => {
     setRunConfig(nextConfig);
     tagsManifest = await getTagsManifest();
     const { getMockedRequestHandlers } = await import("../next.cjs");
+    const url = new URL(request.url);
     [nextHandler] = await getMockedRequestHandlers({
-      port: 3e3,
-      hostname: "localhost",
+      port: Number(url.port) || 443,
+      hostname: url.hostname,
       dir: process.cwd(),
       isDev: false
     });
@@ -3273,15 +3278,21 @@ var server_default = async (request) => {
   try {
     await nextHandler(req, resProxy);
   } catch (error) {
+    logger.withError(error).error("next handler error");
     console.error(error);
     resProxy.statusCode = 500;
     resProxy.end("Internal Server Error");
   }
   const response = await toComputeResponse(resProxy);
   await adjustDateHeader(response.headers, request);
-  setCacheControlHeaders(response.headers);
+  setCacheControlHeaders(response.headers, request);
   setCacheTagsHeaders(response.headers, request, tagsManifest);
   setVaryHeaders(response.headers, request, nextConfig);
+  handleNextCacheHeader(response.headers);
+  if (response.status > 300 && response.status < 400 || response.status >= 500) {
+    const body = await response.text();
+    return new Response(body || null, response);
+  }
   return response;
 };
 export {

package/dist/run/headers.js

@@ -6,13 +6,15 @@
     
 import {
   adjustDateHeader,
+  handleNextCacheHeader,
   setCacheControlHeaders,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../esm-chunks/chunk-ZBX3SNQG.js";
+} from "../esm-chunks/chunk-SMSOJ2OS.js";
 import "../esm-chunks/chunk-RSKIKBZH.js";
 export {
   adjustDateHeader,
+  handleNextCacheHeader,
   setCacheControlHeaders,
   setCacheTagsHeaders,
   setVaryHeaders

package/dist/run/next.cjs

@@ -564,6 +564,8 @@ var import_buffer = require("buffer");
 var import_process = require("process");
 var import_buffer2 = require("buffer");
 var import_buffer3 = require("buffer");
+var import_stream = __toESM(require("stream"), 1);
+var import_util = require("util");
 var getEnvironmentContext = () => {
   const context = globalThis.netlifyBlobsContext || import_process.env.NETLIFY_BLOBS_CONTEXT;
   if (typeof context !== "string" || !context) {
@@ -933,6 +935,9 @@ var Store = class _Store {
     };
   }
   static validateKey(key) {
+    if (key === "") {
+      throw new Error("Blob key must not be empty.");
+    }
     if (key.startsWith("/") || key.startsWith("%2F")) {
       throw new Error("Blob key must not start with forward slash (/).");
     }
@@ -1017,6 +1022,7 @@ var getDeployStore = (options = {}) => {
   const client = new Client(clientOptions);
   return new Store({ client, deployID });
 };
+var pipeline = (0, import_util.promisify)(import_stream.default.pipeline);
 
 // src/run/next.cts
 var import_fs_monkey = __toESM(require_lib());

package/dist/run/systemlog.js

@@ -0,0 +1,15 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  StructuredLogger,
+  logger
+} from "../esm-chunks/chunk-YZXA5QBC.js";
+import "../esm-chunks/chunk-RSKIKBZH.js";
+export {
+  StructuredLogger,
+  logger
+};

package/edge-runtime/lib/response.ts

@@ -139,6 +139,7 @@ export const buildResponse = async ({
   }
 
   if (res.headers.get('x-middleware-next') === '1') {
+    res.headers.delete('x-middleware-next')
     return addMiddlewareHeaders(context.next(), res)
   }
   return res

package/edge-runtime/lib/routing.ts

@@ -0,0 +1,451 @@
+/**
+ * Various router utils ported to Deno from Next.js source
+ * Licence: https://github.com/vercel/next.js/blob/7280c3ced186bb9a7ae3d7012613ef93f20b0fa9/license.md
+ *
+ * Some types have been re-implemented to be more compatible with Deno or avoid chains of dependent files
+ */
+
+import type { Key } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
+
+import { compile, pathToRegexp } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
+import { getCookies } from '../vendor/deno.land/std@0.175.0/http/cookie.ts'
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ Inlined/re-implemented types                                            │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+export interface ParsedUrlQuery {
+  [key: string]: string | string[]
+}
+
+export interface Params {
+  [param: string]: any
+}
+
+export type RouteHas =
+  | {
+      type: 'header' | 'query' | 'cookie'
+      key: string
+      value?: string
+    }
+  | {
+      type: 'host'
+      key?: undefined
+      value: string
+    }
+
+export type Rewrite = {
+  source: string
+  destination: string
+  basePath?: false
+  locale?: false
+  has?: RouteHas[]
+  missing?: RouteHas[]
+  regex: string
+}
+
+export type Header = {
+  source: string
+  basePath?: false
+  locale?: false
+  headers: Array<{ key: string; value: string }>
+  has?: RouteHas[]
+  missing?: RouteHas[]
+  regex: string
+}
+
+export type Redirect = {
+  source: string
+  destination: string
+  basePath?: false
+  locale?: false
+  has?: RouteHas[]
+  missing?: RouteHas[]
+  statusCode?: number
+  permanent?: boolean
+  regex: string
+}
+
+export type DynamicRoute = {
+  page: string
+  regex: string
+  namedRegex?: string
+  routeKeys?: { [key: string]: string }
+}
+
+export type RoutesManifest = {
+  basePath: string
+  redirects: Redirect[]
+  headers: Header[]
+  rewrites: {
+    beforeFiles: Rewrite[]
+    afterFiles: Rewrite[]
+    fallback: Rewrite[]
+  }
+  dynamicRoutes: DynamicRoute[]
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/escape-regexp.ts                           │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+// regexp is based on https://github.com/sindresorhus/escape-string-regexp
+const reHasRegExp = /[|\\{}()[\]^$+*?.-]/
+const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g
+
+export function escapeStringRegexp(str: string) {
+  // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
+  if (reHasRegExp.test(str)) {
+    return str.replace(reReplaceRegExp, '\\$&')
+  }
+
+  return str
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/querystring.ts                │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+export function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrlQuery {
+  const query: ParsedUrlQuery = {}
+
+  searchParams.forEach((value, key) => {
+    if (typeof query[key] === 'undefined') {
+      query[key] = value
+    } else if (Array.isArray(query[key])) {
+      ;(query[key] as string[]).push(value)
+    } else {
+      query[key] = [query[key] as string, value]
+    }
+  })
+
+  return query
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/parse-url.ts                  │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+interface ParsedUrl {
+  hash: string
+  hostname?: string | null
+  href: string
+  pathname: string
+  port?: string | null
+  protocol?: string | null
+  query: ParsedUrlQuery
+  search: string
+}
+
+export function parseUrl(url: string): ParsedUrl {
+  const parsedURL = url.startsWith('/') ? new URL(url, 'http://n') : new URL(url)
+
+  return {
+    hash: parsedURL.hash,
+    hostname: parsedURL.hostname,
+    href: parsedURL.href,
+    pathname: parsedURL.pathname,
+    port: parsedURL.port,
+    protocol: parsedURL.protocol,
+    query: searchParamsToUrlQuery(parsedURL.searchParams),
+    search: parsedURL.search,
+  }
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/prepare-destination.ts        │
+  │ — Changed to use WHATWG Fetch `Request` instead of                      │
+  │ `http.IncomingMessage`.                                                 │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+export function matchHas(
+  req: Pick<Request, 'headers' | 'url'>,
+  query: Params,
+  has: RouteHas[] = [],
+  missing: RouteHas[] = [],
+): false | Params {
+  const params: Params = {}
+  const cookies = getCookies(req.headers)
+  const url = new URL(req.url)
+  const hasMatch = (hasItem: RouteHas) => {
+    let value: undefined | string | null
+    let key = hasItem.key
+
+    switch (hasItem.type) {
+      case 'header': {
+        key = hasItem.key.toLowerCase()
+        value = req.headers.get(key)
+        break
+      }
+      case 'cookie': {
+        value = cookies[hasItem.key]
+        break
+      }
+      case 'query': {
+        value = query[hasItem.key]
+        break
+      }
+      case 'host': {
+        value = url.hostname
+        break
+      }
+      default: {
+        break
+      }
+    }
+    if (!hasItem.value && value && key) {
+      params[getSafeParamName(key)] = value
+
+      return true
+    } else if (value) {
+      const matcher = new RegExp(`^${hasItem.value}$`)
+      const matches = Array.isArray(value)
+        ? value.slice(-1)[0].match(matcher)
+        : value.match(matcher)
+
+      if (matches) {
+        if (Array.isArray(matches)) {
+          if (matches.groups) {
+            Object.keys(matches.groups).forEach((groupKey) => {
+              params[groupKey] = matches.groups![groupKey]
+            })
+          } else if (hasItem.type === 'host' && matches[0]) {
+            params.host = matches[0]
+          }
+        }
+        return true
+      }
+    }
+    return false
+  }
+
+  const allMatch = has.every((item) => hasMatch(item)) && !missing.some((item) => hasMatch(item))
+
+  if (allMatch) {
+    return params
+  }
+  return false
+}
+
+export function compileNonPath(value: string, params: Params): string {
+  if (!value.includes(':')) {
+    return value
+  }
+
+  for (const key of Object.keys(params)) {
+    if (value.includes(`:${key}`)) {
+      value = value
+        .replace(new RegExp(`:${key}\\*`, 'g'), `:${key}--ESCAPED_PARAM_ASTERISKS`)
+        .replace(new RegExp(`:${key}\\?`, 'g'), `:${key}--ESCAPED_PARAM_QUESTION`)
+        .replace(new RegExp(`:${key}\\+`, 'g'), `:${key}--ESCAPED_PARAM_PLUS`)
+        .replace(new RegExp(`:${key}(?!\\w)`, 'g'), `--ESCAPED_PARAM_COLON${key}`)
+    }
+  }
+  value = value
+    .replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, '\\$1')
+    .replace(/--ESCAPED_PARAM_PLUS/g, '+')
+    .replace(/--ESCAPED_PARAM_COLON/g, ':')
+    .replace(/--ESCAPED_PARAM_QUESTION/g, '?')
+    .replace(/--ESCAPED_PARAM_ASTERISKS/g, '*')
+  // the value needs to start with a forward-slash to be compiled
+  // correctly
+  return compile(`/${value}`, { validate: false })(params).slice(1)
+}
+
+export function prepareDestination(args: {
+  appendParamsToQuery: boolean
+  destination: string
+  params: Params
+  query: ParsedUrlQuery
+}) {
+  const query = Object.assign({}, args.query)
+  delete query.__nextLocale
+  delete query.__nextDefaultLocale
+  delete query.__nextDataReq
+
+  let escapedDestination = args.destination
+
+  for (const param of Object.keys({ ...args.params, ...query })) {
+    escapedDestination = escapeSegment(escapedDestination, param)
+  }
+
+  const parsedDestination: ParsedUrl = parseUrl(escapedDestination)
+  const destQuery = parsedDestination.query
+  const destPath = unescapeSegments(`${parsedDestination.pathname!}${parsedDestination.hash || ''}`)
+  const destHostname = unescapeSegments(parsedDestination.hostname || '')
+  const destPathParamKeys: Key[] = []
+  const destHostnameParamKeys: Key[] = []
+  pathToRegexp(destPath, destPathParamKeys)
+  pathToRegexp(destHostname, destHostnameParamKeys)
+
+  const destParams: (string | number)[] = []
+
+  destPathParamKeys.forEach((key) => destParams.push(key.name))
+  destHostnameParamKeys.forEach((key) => destParams.push(key.name))
+
+  const destPathCompiler = compile(
+    destPath,
+    // we don't validate while compiling the destination since we should
+    // have already validated before we got to this point and validating
+    // breaks compiling destinations with named pattern params from the source
+    // e.g. /something:hello(.*) -> /another/:hello is broken with validation
+    // since compile validation is meant for reversing and not for inserting
+    // params from a separate path-regex into another
+    { validate: false },
+  )
+
+  const destHostnameCompiler = compile(destHostname, { validate: false })
+
+  // update any params in query values
+  for (const [key, strOrArray] of Object.entries(destQuery)) {
+    // the value needs to start with a forward-slash to be compiled
+    // correctly
+    if (Array.isArray(strOrArray)) {
+      destQuery[key] = strOrArray.map((value) =>
+        compileNonPath(unescapeSegments(value), args.params),
+      )
+    } else {
+      destQuery[key] = compileNonPath(unescapeSegments(strOrArray), args.params)
+    }
+  }
+
+  // add path params to query if it's not a redirect and not
+  // already defined in destination query or path
+  const paramKeys = Object.keys(args.params).filter((name) => name !== 'nextInternalLocale')
+
+  if (args.appendParamsToQuery && !paramKeys.some((key) => destParams.includes(key))) {
+    for (const key of paramKeys) {
+      if (!(key in destQuery)) {
+        destQuery[key] = args.params[key]
+      }
+    }
+  }
+
+  let newUrl
+
+  try {
+    newUrl = destPathCompiler(args.params)
+
+    const [pathname, hash] = newUrl.split('#')
+    parsedDestination.hostname = destHostnameCompiler(args.params)
+    parsedDestination.pathname = pathname
+    parsedDestination.hash = `${hash ? '#' : ''}${hash || ''}`
+    delete (parsedDestination as any).search
+  } catch (err: any) {
+    if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
+      throw new Error(
+        `To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`,
+      )
+    }
+    throw err
+  }
+
+  // Query merge order lowest priority to highest
+  // 1. initial URL query values
+  // 2. path segment values
+  // 3. destination specified query values
+  parsedDestination.query = {
+    ...query,
+    ...parsedDestination.query,
+  }
+
+  return {
+    newUrl,
+    destQuery,
+    parsedDestination,
+  }
+}
+
+/**
+ * Ensure only a-zA-Z are used for param names for proper interpolating
+ * with path-to-regexp
+ */
+function getSafeParamName(paramName: string) {
+  let newParamName = ''
+
+  for (let i = 0; i < paramName.length; i++) {
+    const charCode = paramName.charCodeAt(i)
+
+    if (
+      (charCode > 64 && charCode < 91) || // A-Z
+      (charCode > 96 && charCode < 123) // a-z
+    ) {
+      newParamName += paramName[i]
+    }
+  }
+  return newParamName
+}
+
+function escapeSegment(str: string, segmentName: string) {
+  return str.replace(
+    new RegExp(`:${escapeStringRegexp(segmentName)}`, 'g'),
+    `__ESC_COLON_${segmentName}`,
+  )
+}
+
+function unescapeSegments(str: string) {
+  return str.replace(/__ESC_COLON_/gi, ':')
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/is-dynamic.ts                 │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+// Identify /[param]/ in route string
+const TEST_ROUTE = /\/\[[^/]+?\](?=\/|$)/
+
+export function isDynamicRoute(route: string): boolean {
+  return TEST_ROUTE.test(route)
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/shared/lib/router/utils/middleware-route-matcher.ts       │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+export interface MiddlewareRouteMatch {
+  (
+    pathname: string | null | undefined,
+    request: Pick<Request, 'headers' | 'url'>,
+    query: Params,
+  ): boolean
+}
+
+export interface MiddlewareMatcher {
+  regexp: string
+  locale?: false
+  has?: RouteHas[]
+  missing?: RouteHas[]
+}
+
+export function getMiddlewareRouteMatcher(matchers: MiddlewareMatcher[]): MiddlewareRouteMatch {
+  return (
+    pathname: string | null | undefined,
+    req: Pick<Request, 'headers' | 'url'>,
+    query: Params,
+  ) => {
+    for (const matcher of matchers) {
+      const routeMatch = new RegExp(matcher.regexp).exec(pathname!)
+      if (!routeMatch) {
+        continue
+      }
+
+      if (matcher.has || matcher.missing) {
+        const hasParams = matchHas(req, query, matcher.has, matcher.missing)
+        if (!hasParams) {
+          continue
+        }
+      }
+
+      return true
+    }
+
+    return false
+  }
+}

package/edge-runtime/matchers.json

@@ -0,0 +1 @@
+[]

package/edge-runtime/middleware.ts

@@ -1,11 +1,20 @@
 import type { Context } from '@netlify/edge-functions'
 
+import matchers from './matchers.json' assert { type: 'json' }
+
 import { buildNextRequest, RequestData } from './lib/next-request.ts'
 import { buildResponse } from './lib/response.ts'
 import { FetchEventResult } from './lib/response.ts'
+import {
+  type MiddlewareRouteMatch,
+  getMiddlewareRouteMatcher,
+  searchParamsToUrlQuery,
+} from './lib/routing.ts'
 
 type NextHandler = (params: { request: RequestData }) => Promise<FetchEventResult>
 
+const matchesMiddleware: MiddlewareRouteMatch = getMiddlewareRouteMatcher(matchers || [])
+
 /**
  * Runs a Next.js middleware as a Netlify Edge Function. It translates a web
  * platform Request into a NextRequest instance on the way in, and translates
@@ -20,13 +29,17 @@ export async function handleMiddleware(
   context: Context,
   nextHandler: NextHandler,
 ) {
-  // Don't run in dev
-  if (Netlify.env.has('NETLIFY_DEV')) {
+  const nextRequest = buildNextRequest(request, context)
+  const url = new URL(request.url)
+
+  // While we have already checked the path when mapping to the edge function,
+  // Next.js supports extra rules that we need to check here too, because we
+  // might be running an edge function for a path we should not. If we find
+  // that's the case, short-circuit the execution.
+  if (!matchesMiddleware(url.pathname, request, searchParamsToUrlQuery(url.searchParams))) {
     return
   }
 
-  const nextRequest = buildNextRequest(request, context)
-
   try {
     const result = await nextHandler({ request: nextRequest })
     const response = await buildResponse({ result, request: request, context })

package/edge-runtime/shim/index.js

@@ -2,6 +2,9 @@
 // a Webpack bundle. You should not import this file from anywhere in the
 // application.
 import { AsyncLocalStorage } from 'node:async_hooks'
+import process from 'node:process'
+
+globalThis.process = process
 
 globalThis.AsyncLocalStorage = AsyncLocalStorage
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.0.0-beta.0",
+  "version": "5.0.0-beta.2",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",