@netlify/plugin-nextjs 5.0.0-beta.8 → 5.0.0-beta.9

package/dist/esm-chunks/{chunk-IZ2AVCVF.js → chunk-DWC6JSN7.js}

@@ -4,17 +4,15 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  encodeBlobKey
-} from "./chunk-TYCYFZ22.js";
 
 // src/build/plugin-context.ts
 import { readFileSync } from "node:fs";
-import { mkdir, readFile, writeFile, stat } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
 var PLUGIN_DIR = join(MODULE_DIR, "../..");
+var DEFAULT_PUBLISH_DIR = ".next";
 var SERVER_HANDLER_NAME = "___netlify-server-handler";
 var EDGE_HANDLER_NAME = "___netlify-edge-handler";
 var PluginContext = class {
@@ -26,9 +24,12 @@ var PluginContext = class {
   packageJSON;
   /** Absolute path of the next runtime plugin directory */
   pluginDir = PLUGIN_DIR;
+  get relPublishDir() {
+    return this.constants.PUBLISH_DIR ?? join(this.packagePath, DEFAULT_PUBLISH_DIR);
+  }
   /** Absolute path of the publish directory */
   get publishDir() {
-    return resolve(this.constants.PUBLISH_DIR);
+    return resolve(this.relPublishDir);
   }
   /**
    * Relative package path in non monorepo setups this is an empty string
@@ -38,15 +39,38 @@ var PluginContext = class {
   get packagePath() {
     return this.constants.PACKAGE_PATH || "";
   }
+  /**
+   * The working directory inside the lambda that is used for monorepos to execute the serverless function
+   */
+  get lambdaWorkingDirectory() {
+    return join("/var/task", this.distFolder);
+  }
   /**
    * Retrieves the root of the `.next/standalone` directory
    */
   get standaloneRootDir() {
     return join(this.publishDir, "standalone");
   }
+  /**
+   * The resolved relative next dist directory defaults to `.next`,
+   * but can be configured through the next.config.js. For monorepos this will include the packagePath
+   * If we need just the plain dist dir use the `nextDistDir`
+   */
+  get distDir() {
+    const dir = this.buildConfig.distDir ?? DEFAULT_PUBLISH_DIR;
+    return relative(process.cwd(), resolve(this.packagePath, dir));
+  }
+  /** The dist folder represents the parent directory of the .next folder or custom distDir */
+  get distFolder() {
+    return join(this.distDir, "..");
+  }
+  /** The `.next` folder or what the custom dist dir is set to */
+  get nextDistDir() {
+    return relative(this.distFolder, this.distDir);
+  }
   /** Retrieves the `.next/standalone/` directory monorepo aware */
   get standaloneDir() {
-    return join(this.standaloneRootDir, this.constants.PACKAGE_PATH || "");
+    return join(this.standaloneRootDir, this.distFolder);
   }
   /**
    * Absolute path of the directory that is published and deployed to the Netlify CDN
@@ -75,10 +99,16 @@ var PluginContext = class {
     return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
   }
   get serverHandlerDir() {
-    return join(this.serverHandlerRootDir, this.constants.PACKAGE_PATH || "");
+    if (this.packagePath.length === 0) {
+      return this.serverHandlerRootDir;
+    }
+    return join(this.serverHandlerRootDir, this.distFolder);
   }
   get nextServerHandler() {
-    return join(this.constants.PACKAGE_PATH || "", "dist/run/handlers/server.js");
+    if (this.packagePath.length !== 0) {
+      return join(this.lambdaWorkingDirectory, ".netlify/dist/run/handlers/server.js");
+    }
+    return "./.netlify/dist/run/handlers/server.js";
   }
   /**
    * Absolute path of the directory containing the files for deno edge functions
@@ -115,9 +145,16 @@ var PluginContext = class {
       await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
     );
   }
+  // don't make private as it is handy inside testing to override the config
+  _buildConfig = null;
   /** Get Next Config from build output **/
-  async getBuildConfig() {
-    return JSON.parse(await readFile(join(this.publishDir, "required-server-files.json"), "utf-8")).config;
+  get buildConfig() {
+    if (!this._buildConfig) {
+      this._buildConfig = JSON.parse(
+        readFileSync(join(this.publishDir, "required-server-files.json"), "utf-8")
+      ).config;
+    }
+    return this._buildConfig;
   }
   /**
    * Get Next.js routes manifest from the build output
@@ -125,19 +162,6 @@ var PluginContext = class {
   async getRoutesManifest() {
     return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "utf-8"));
   }
-  /**
-   * Write a cache entry to the blob upload directory.
-   */
-  async writeCacheEntry(route, value, filePath) {
-    const { mtime } = await stat(filePath);
-    const path = join(this.blobDir, await encodeBlobKey(route));
-    const entry = JSON.stringify({
-      lastModified: mtime.getTime(),
-      value
-    });
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, entry, "utf-8");
-  }
   /** 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-XIP2W57K.js → chunk-NL5YH5N6.js}

@@ -5,18 +5,19 @@
       })();
     
 import {
-  PLUGIN_DIR
-} from "./chunk-K233JI4O.js";
+  PLUGIN_DIR,
+  RUN_CONFIG
+} from "./chunk-UYKENJEU.js";
 
 // src/run/config.ts
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 var getRunConfig = async () => {
-  return JSON.parse(await readFile(resolve(".next/required-server-files.json"), "utf-8")).config;
+  return JSON.parse(await readFile(resolve(RUN_CONFIG), "utf-8"));
 };
 var setRunConfig = (config) => {
-  const cacheHandler = join(PLUGIN_DIR, "dist/run/handlers/cache.cjs");
+  const cacheHandler = join(PLUGIN_DIR, ".netlify/dist/run/handlers/cache.cjs");
   if (!existsSync(cacheHandler)) {
     throw new Error(`Cache handler not found at ${cacheHandler}`);
   }

package/dist/esm-chunks/{chunk-WSPFUAK4.js → chunk-T6AZTXZF.js}

@@ -8,13 +8,13 @@ import {
   copyNextDependencies,
   copyNextServerCode,
   writeTagsManifest
-} from "./chunk-YMFYCTRI.js";
-import {
-  SERVER_HANDLER_NAME
-} from "./chunk-IZ2AVCVF.js";
+} from "./chunk-4J4A5OE2.js";
 import {
   require_out
 } from "./chunk-VZNKO4OO.js";
+import {
+  SERVER_HANDLER_NAME
+} from "./chunk-DWC6JSN7.js";
 import {
   __toESM
 } from "./chunk-5JVNISGM.js";
@@ -27,7 +27,7 @@ var copyHandlerDependencies = async (ctx) => {
   const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
   await Promise.all(
     [...fileList].map(
-      (path) => cp(join(ctx.pluginDir, path), join(ctx.serverHandlerDir, path), {
+      (path) => cp(join(ctx.pluginDir, path), join(ctx.serverHandlerDir, ".netlify", path), {
         recursive: true,
         force: true
       })
@@ -61,7 +61,7 @@ var getHandlerFile = async (ctx) => {
   const templatesDir = join(ctx.pluginDir, "dist/build/templates");
   if (ctx.packagePath.length !== 0) {
     const template = await readFile(join(templatesDir, "handler-monorepo.tmpl.js"), "utf-8");
-    return template.replaceAll("{{cwd}}", join("/var/task", ctx.packagePath)).replace("{{nextServerHandler}}", ctx.nextServerHandler);
+    return template.replaceAll("{{cwd}}", ctx.lambdaWorkingDirectory).replace("{{nextServerHandler}}", ctx.nextServerHandler);
   }
   return await readFile(join(templatesDir, "handler.tmpl.js"), "utf-8");
 };

package/dist/esm-chunks/{chunk-EPSI5TTB.js → chunk-TOK7TKP3.js}

@@ -9,7 +9,7 @@
 var setImageConfig = async (ctx) => {
   const {
     images: { path: imageEndpointPath, loader: imageLoader }
-  } = await ctx.getBuildConfig();
+  } = ctx.buildConfig;
   if (imageLoader === "default") {
     ctx.netlifyConfig.redirects.push({
       from: imageEndpointPath,

package/dist/esm-chunks/{chunk-K233JI4O.js → chunk-UYKENJEU.js}

@@ -9,9 +9,11 @@
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
-var PLUGIN_DIR = resolve(`${MODULE_DIR}../..`);
+var PLUGIN_DIR = resolve(`${MODULE_DIR}../../..`);
+var RUN_CONFIG = "run-config.json";
 
 export {
   MODULE_DIR,
-  PLUGIN_DIR
+  PLUGIN_DIR,
+  RUN_CONFIG
 };

package/dist/esm-chunks/{chunk-ETPYUOBQ.js → chunk-YIE34LVX.js}

@@ -4,12 +4,12 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  EDGE_HANDLER_NAME
-} from "./chunk-IZ2AVCVF.js";
 import {
   require_out
 } from "./chunk-VZNKO4OO.js";
+import {
+  EDGE_HANDLER_NAME
+} from "./chunk-DWC6JSN7.js";
 import {
   __toESM
 } from "./chunk-5JVNISGM.js";
@@ -35,7 +35,7 @@ var copyRuntime = async (ctx, handlerDirectory) => {
   );
 };
 var writeHandlerFile = async (ctx, { matchers, name }) => {
-  const nextConfig = await ctx.getBuildConfig();
+  const nextConfig = ctx.buildConfig;
   const handlerName = getHandlerName({ name });
   const handlerDirectory = join(ctx.edgeFunctionsDir, handlerName);
   const handlerRuntimeDirectory = join(handlerDirectory, "edge-runtime");
@@ -60,7 +60,7 @@ var writeHandlerFile = async (ctx, { matchers, name }) => {
   );
 };
 var copyHandlerDependencies = async (ctx, { name, files, wasm }) => {
-  const srcDir = join(ctx.standaloneDir, ".next");
+  const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
   const destDir = join(ctx.edgeFunctionsDir, getHandlerName({ name }));
   await Promise.all(
     files.map(async (file) => {

package/dist/esm-chunks/{package-2CI3IXK3.js → package-6DFWHFJA.js}

@@ -8,7 +8,7 @@ import "./chunk-5JVNISGM.js";
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.0.0-beta.8";
+var version = "5.0.0-beta.9";
 var description = "Run Next.js seamlessly on Netlify";
 var main = "./dist/index.js";
 var type = "module";
@@ -26,9 +26,10 @@ var scripts = {
   pretest: "node tests/prepare.mjs",
   build: "node ./tools/build.js",
   "build:watch": "node ./tools/build.js --watch",
-  lint: "eslint --cache --format=codeframe --max-warnings=0 src/**/*.ts",
+  lint: "eslint --cache --format=codeframe --max-warnings=0 --ext .ts,.cts,.js src",
   test: "vitest",
   "test:ci": "vitest run --reporter=default --retry=3",
+  typecheck: "tsc --noEmit",
   e2e: "playwright test",
   "e2e:ci": "playwright test"
 };
@@ -50,13 +51,13 @@ var homepage = "https://github.com/netlify/next-runtime-minimal#readme";
 var devDependencies = {
   "@fastly/http-compute-js": "1.1.4",
   "@netlify/blobs": "^6.5.0",
-  "@netlify/build": "^29.33.5",
+  "@netlify/build": "^29.35.1",
   "@netlify/edge-bundler": "^11.2.2",
-  "@netlify/edge-functions": "^2.3.0",
+  "@netlify/edge-functions": "^2.3.1",
   "@netlify/eslint-config-node": "^7.0.1",
   "@netlify/functions": "^2.5.1",
   "@netlify/serverless-functions-api": "^1.10.1",
-  "@netlify/zip-it-and-ship-it": "^9.29.1",
+  "@netlify/zip-it-and-ship-it": "^9.29.2",
   "@opentelemetry/api": "^1.7.0",
   "@opentelemetry/sdk-node": "^0.48.0",
   "@opentelemetry/exporter-trace-otlp-http": "^0.48.0",
@@ -76,6 +77,7 @@ var devDependencies = {
   "get-port": "^7.0.0",
   "lambda-local": "^2.1.2",
   memfs: "^4.6.0",
+  "mock-require": "^3.0.3",
   msw: "^2.0.7",
   next: "^14.0.4",
   os: "^0.1.2",
@@ -84,7 +86,7 @@ var devDependencies = {
   typescript: "^5.1.6",
   unionfs: "^4.5.1",
   uuid: "^9.0.1",
-  vitest: "^0.34.6"
+  vitest: "^1.2.2"
 };
 var clean_package = {
   indent: 2,

package/dist/index.js

@@ -5,13 +5,8 @@
       })();
     
 import {
-  createServerHandler
-} from "./esm-chunks/chunk-WSPFUAK4.js";
-import {
-  copyFetchContent,
   copyPrerenderedContent
-} from "./esm-chunks/chunk-XFDUV7DP.js";
-import "./esm-chunks/chunk-YMFYCTRI.js";
+} from "./esm-chunks/chunk-67EWAGDQ.js";
 import {
   copyStaticAssets,
   copyStaticContent,
@@ -20,19 +15,24 @@ import {
 } from "./esm-chunks/chunk-ZWFKLYLH.js";
 import {
   createEdgeHandlers
-} from "./esm-chunks/chunk-ETPYUOBQ.js";
+} from "./esm-chunks/chunk-YIE34LVX.js";
 import {
-  PluginContext
-} from "./esm-chunks/chunk-IZ2AVCVF.js";
+  createServerHandler
+} from "./esm-chunks/chunk-T6AZTXZF.js";
+import "./esm-chunks/chunk-4J4A5OE2.js";
 import "./esm-chunks/chunk-VZNKO4OO.js";
-import "./esm-chunks/chunk-TYCYFZ22.js";
 import {
   restoreBuildCache,
   saveBuildCache
-} from "./esm-chunks/chunk-XA2CZH5Y.js";
+} from "./esm-chunks/chunk-72ZI2IVI.js";
 import {
   setImageConfig
-} from "./esm-chunks/chunk-EPSI5TTB.js";
+} from "./esm-chunks/chunk-TOK7TKP3.js";
+import {
+  PluginContext
+} from "./esm-chunks/chunk-DWC6JSN7.js";
+import "./esm-chunks/chunk-UYKENJEU.js";
+import "./esm-chunks/chunk-TYCYFZ22.js";
 import "./esm-chunks/chunk-5JVNISGM.js";
 
 // src/index.ts
@@ -58,7 +58,6 @@ var onBuild = async (options) => {
     copyStaticAssets(ctx),
     copyStaticContent(ctx),
     copyPrerenderedContent(ctx),
-    copyFetchContent(ctx),
     createServerHandler(ctx),
     createEdgeHandlers(ctx)
   ]);

package/dist/run/config.js

@@ -8,8 +8,8 @@ import {
   getRunConfig,
   getTagsManifest,
   setRunConfig
-} from "../esm-chunks/chunk-XIP2W57K.js";
-import "../esm-chunks/chunk-K233JI4O.js";
+} from "../esm-chunks/chunk-NL5YH5N6.js";
+import "../esm-chunks/chunk-UYKENJEU.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
 export {
   getRunConfig,

package/dist/run/constants.js

@@ -6,10 +6,12 @@
     
 import {
   MODULE_DIR,
-  PLUGIN_DIR
-} from "../esm-chunks/chunk-K233JI4O.js";
+  PLUGIN_DIR,
+  RUN_CONFIG
+} from "../esm-chunks/chunk-UYKENJEU.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
 export {
   MODULE_DIR,
-  PLUGIN_DIR
+  PLUGIN_DIR,
+  RUN_CONFIG
 };

package/dist/run/handlers/cache.cjs

@@ -1347,12 +1347,12 @@ var require_status = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.SpanStatusCode = void 0;
-    var SpanStatusCode;
-    (function(SpanStatusCode2) {
-      SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
-      SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
-      SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
-    })(SpanStatusCode = exports2.SpanStatusCode || (exports2.SpanStatusCode = {}));
+    var SpanStatusCode2;
+    (function(SpanStatusCode3) {
+      SpanStatusCode3[SpanStatusCode3["UNSET"] = 0] = "UNSET";
+      SpanStatusCode3[SpanStatusCode3["OK"] = 1] = "OK";
+      SpanStatusCode3[SpanStatusCode3["ERROR"] = 2] = "ERROR";
+    })(SpanStatusCode2 = exports2.SpanStatusCode || (exports2.SpanStatusCode = {}));
   }
 });
 
@@ -2431,81 +2431,115 @@ var pipeline = (0, import_util.promisify)(import_stream.default.pipeline);
 var import_functions = __toESM(require_main());
 var import_api = __toESM(require_src());
 var import_constants = require("next/dist/lib/constants.js");
+var import_request_context = require("./request-context.cjs");
 var fetchBeforeNextPatchedIt = globalThis.fetch;
 var NetlifyCacheHandler = class {
   options;
   revalidatedTags;
   blobStore;
   tracer = import_api.trace.getTracer("Netlify Cache Handler");
+  tagManifestsFetchedFromBlobStoreInCurrentRequest;
   constructor(options) {
     this.options = options;
     this.revalidatedTags = options.revalidatedTags;
-    this.blobStore = getDeployStore({ fetch: fetchBeforeNextPatchedIt });
+    this.blobStore = getDeployStore({ fetch: fetchBeforeNextPatchedIt, consistency: "strong" });
+    this.tagManifestsFetchedFromBlobStoreInCurrentRequest = {};
   }
   async encodeBlobKey(key) {
     const { encodeBlobKey: encodeBlobKey2 } = await Promise.resolve().then(() => (init_blobkey(), blobkey_exports));
     return await encodeBlobKey2(key);
   }
+  captureResponseCacheLastModified(cacheValue, key, getCacheKeySpan) {
+    if (cacheValue.value?.kind === "FETCH") {
+      return;
+    }
+    const requestContext = (0, import_request_context.getRequestContext)();
+    if (!requestContext) {
+      getCacheKeySpan.recordException(
+        new Error("CacheHandler was called without a request context")
+      );
+      getCacheKeySpan.setAttributes({
+        severity: "alert",
+        warning: true
+      });
+      return;
+    }
+    if (requestContext.responseCacheKey && requestContext.responseCacheKey !== key) {
+      requestContext.responseCacheGetLastModified = void 0;
+      getCacheKeySpan.recordException(
+        new Error(
+          `Multiple response cache keys used in single request: ["${requestContext.responseCacheKey}, "${key}"]`
+        )
+      );
+      getCacheKeySpan.setAttributes({
+        severity: "alert",
+        warning: true
+      });
+      return;
+    }
+    requestContext.responseCacheKey = key;
+    if (cacheValue.lastModified) {
+      requestContext.responseCacheGetLastModified = cacheValue.lastModified;
+    }
+  }
   async get(...args) {
     return this.tracer.startActiveSpan("get cache key", async (span) => {
-      const [key, ctx = {}] = args;
-      console.debug(`[NetlifyCacheHandler.get]: ${key}`);
-      const blobKey = await this.encodeBlobKey(key);
-      span.setAttributes({ key, blobKey });
-      const blob = await this.blobStore.get(blobKey, {
-        type: "json"
-      });
-      if (!blob) {
-        span.addEvent("Cache miss", { key, blobKey });
-        span.end();
+      try {
+        const [key, ctx = {}] = args;
+        console.debug(`[NetlifyCacheHandler.get]: ${key}`);
+        const blobKey = await this.encodeBlobKey(key);
+        span.setAttributes({ key, blobKey });
+        const blob = await this.blobStore.get(blobKey, {
+          type: "json"
+        });
+        if (!blob) {
+          span.addEvent("Cache miss", { key, blobKey });
+          return null;
+        }
+        const staleByTags = await this.checkCacheEntryStaleByTags(blob, ctx.tags, ctx.softTags);
+        if (staleByTags) {
+          span.addEvent("Stale", { staleByTags });
+          return null;
+        }
+        this.captureResponseCacheLastModified(blob, key, span);
+        switch (blob.value?.kind) {
+          case "FETCH":
+            span.addEvent("FETCH", { lastModified: blob.lastModified, revalidate: ctx.revalidate });
+            return {
+              lastModified: blob.lastModified,
+              value: blob.value
+            };
+          case "ROUTE":
+            span.addEvent("ROUTE", { lastModified: blob.lastModified, status: blob.value.status });
+            return {
+              lastModified: blob.lastModified,
+              value: {
+                ...blob.value,
+                body: import_node_buffer2.Buffer.from(blob.value.body, "base64")
+              }
+            };
+          case "PAGE":
+            span.addEvent("PAGE", { lastModified: blob.lastModified });
+            return {
+              lastModified: blob.lastModified,
+              value: blob.value
+            };
+          default:
+            span.recordException(new Error(`Unknown cache entry kind: ${blob.value?.kind}`));
+        }
         return null;
-      }
-      const staleByTags = await this.checkCacheEntryStaleByTags(blob, ctx.softTags);
-      if (staleByTags) {
-        span.addEvent("Stale", { staleByTags });
+      } catch (error) {
+        if (error instanceof Error) {
+          span.recordException(error);
+        }
+        span.setStatus({
+          code: import_api.SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      } finally {
         span.end();
-        return null;
       }
-      switch (blob.value.kind) {
-        case "FETCH":
-          span.addEvent("FETCH", { lastModified: blob.lastModified, revalidate: ctx.revalidate });
-          span.end();
-          return {
-            lastModified: blob.lastModified,
-            value: {
-              kind: blob.value.kind,
-              data: blob.value.data,
-              revalidate: blob.value.revalidate
-            }
-          };
-        case "ROUTE":
-          span.addEvent("ROUTE", {
-            lastModified: blob.lastModified,
-            kind: blob.value.kind,
-            status: blob.value.status
-          });
-          span.end();
-          return {
-            lastModified: blob.lastModified,
-            value: {
-              body: import_node_buffer2.Buffer.from(blob.value.body, "base64"),
-              kind: blob.value.kind,
-              status: blob.value.status,
-              headers: blob.value.headers
-            }
-          };
-        case "PAGE":
-          span.addEvent("PAGE", { lastModified: blob.lastModified });
-          span.end();
-          return {
-            lastModified: blob.lastModified,
-            value: blob.value
-          };
-        default:
-          span.recordException(new Error(`Unknown cache entry kind: ${blob.value.kind}`));
-      }
-      span.end();
-      return null;
     });
   }
   async set(...args) {
@@ -2540,27 +2574,69 @@ var NetlifyCacheHandler = class {
       console.error(`[NetlifyCacheHandler]: Purging the cache for tag ${tag} failed`, error);
     });
   }
+  resetRequestCache() {
+    this.tagManifestsFetchedFromBlobStoreInCurrentRequest = {};
+  }
   /**
-   * Checks if a page is stale through on demand revalidated tags
+   * Checks if a cache entry is stale through on demand revalidated tags
    */
-  async checkCacheEntryStaleByTags(cacheEntry, softTags = []) {
-    const tags = "headers" in cacheEntry.value ? cacheEntry.value.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]?.split(",") || [] : [];
-    const cacheTags = [...tags, ...softTags];
-    const allManifests = await Promise.all(
-      cacheTags.map(async (tag) => {
-        const res = await this.blobStore.get(await this.encodeBlobKey(tag), { type: "json" }).then((value) => ({ [tag]: value })).catch(console.error);
-        return res || { [tag]: null };
-      })
-    );
-    const tagsManifest = Object.assign({}, ...allManifests);
-    const isStale = cacheTags.some((tag) => {
-      if (this.revalidatedTags?.includes(tag)) {
-        return true;
+  async checkCacheEntryStaleByTags(cacheEntry, tags = [], softTags = []) {
+    let cacheTags = [];
+    if (cacheEntry.value?.kind === "FETCH") {
+      cacheTags = [...tags, ...softTags];
+    } else if (cacheEntry.value?.kind === "PAGE" || cacheEntry.value?.kind === "ROUTE") {
+      cacheTags = cacheEntry.value.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]?.split(",") || [];
+    } else {
+      return false;
+    }
+    if (this.revalidatedTags && this.revalidatedTags.length !== 0) {
+      for (const tag of this.revalidatedTags) {
+        if (cacheTags.includes(tag)) {
+          return true;
+        }
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const tagManifestPromises = [];
+      for (const tag of cacheTags) {
+        let tagManifestPromise = this.tagManifestsFetchedFromBlobStoreInCurrentRequest[tag];
+        if (!tagManifestPromise) {
+          tagManifestPromise = this.encodeBlobKey(tag).then((blobKey) => {
+            return this.tracer.startActiveSpan(`get tag manifest`, async (span) => {
+              span.setAttributes({ tag, blobKey });
+              try {
+                return await this.blobStore.get(blobKey, { type: "json" });
+              } catch (error) {
+                if (error instanceof Error) {
+                  span.recordException(error);
+                }
+                span.setStatus({
+                  code: import_api.SpanStatusCode.ERROR,
+                  message: error instanceof Error ? error.message : String(error)
+                });
+                throw error;
+              } finally {
+                span.end();
+              }
+            });
+          });
+          this.tagManifestsFetchedFromBlobStoreInCurrentRequest[tag] = tagManifestPromise;
+        }
+        tagManifestPromises.push(
+          tagManifestPromise.then((tagManifest) => {
+            const isStale = tagManifest?.revalidatedAt >= (cacheEntry.lastModified || Date.now());
+            if (isStale) {
+              resolve(true);
+              return true;
+            }
+            return false;
+          })
+        );
       }
-      const { revalidatedAt } = tagsManifest[tag] || {};
-      return revalidatedAt && revalidatedAt >= (cacheEntry.lastModified || Date.now());
+      Promise.all(tagManifestPromises).then((tagManifestAreStale) => {
+        resolve(tagManifestAreStale.some((tagIsStale) => tagIsStale));
+      }).catch(reject);
     });
-    return isStale;
   }
 };
 var cache_default = NetlifyCacheHandler;