@netlify/plugin-nextjs 5.10.1 → 5.10.3

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2023 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/esm-chunks/{package-UN6EVEHD.js → package-AKXSA3EX.js}

@@ -8,7 +8,7 @@ import "./chunk-OEQOKJGE.js";
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.10.1";
+var version = "5.10.3";
 var description = "Run Next.js seamlessly on Netlify";
 var main = "./dist/index.js";
 var type = "module";
@@ -56,15 +56,15 @@ var bugs = {
 };
 var homepage = "https://opennext.js.org/netlify";
 var devDependencies = {
-  "@fastly/http-compute-js": "1.1.4",
-  "@netlify/blobs": "^8.1.0",
-  "@netlify/build": "^29.55.4",
-  "@netlify/edge-bundler": "^12.2.3",
-  "@netlify/edge-functions": "^2.11.0",
+  "@fastly/http-compute-js": "1.1.5",
+  "@netlify/blobs": "^8.1.2",
+  "@netlify/build": "^30.1.1",
+  "@netlify/edge-bundler": "^12.4.0",
+  "@netlify/edge-functions": "^2.11.1",
   "@netlify/eslint-config-node": "^7.0.1",
-  "@netlify/functions": "^3.0.0",
-  "@netlify/serverless-functions-api": "^1.30.1",
-  "@netlify/zip-it-and-ship-it": "^9.41.0",
+  "@netlify/functions": "^3.0.4",
+  "@netlify/serverless-functions-api": "^1.36.0",
+  "@netlify/zip-it-and-ship-it": "^10.0.4",
   "@opentelemetry/api": "^1.8.0",
   "@opentelemetry/exporter-trace-otlp-http": "^0.51.0",
   "@opentelemetry/resources": "^1.24.0",
@@ -84,10 +84,11 @@ var devDependencies = {
   "fs-monkey": "^1.0.6",
   "get-port": "^7.1.0",
   "lambda-local": "^2.2.0",
+  "lru-cache": "^10.4.3",
   memfs: "^4.9.2",
   "mock-require": "^3.0.3",
   msw: "^2.0.7",
-  "netlify-cli": "^17.37.1",
+  "netlify-cli": "^19.1.5",
   next: "^15.0.0-canary.28",
   os: "^0.1.2",
   outdent: "^0.8.0",

package/dist/run/config.js

@@ -11,6 +11,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { PLUGIN_DIR, RUN_CONFIG } from "./constants.js";
+import { setInMemoryCacheMaxSizeFromNextConfig } from "./storage/storage.cjs";
 var getRunConfig = async () => {
   return JSON.parse(await readFile(resolve(PLUGIN_DIR, RUN_CONFIG), "utf-8"));
 };
@@ -21,12 +22,13 @@ var setRunConfig = (config) => {
   }
   config.experimental = {
     ...config.experimental,
-    // @ts-expect-error incrementalCacheHandlerPath was removed from config type
-    // but we still need to set it for older Next.js versions
+    // Before Next.js 14.1.0 path to the cache handler was in experimental section, see NextConfigForMultipleVersions type
     incrementalCacheHandlerPath: cacheHandler
   };
   config.cacheHandler = cacheHandler;
-  config.cacheMaxMemorySize = 0;
+  setInMemoryCacheMaxSizeFromNextConfig(
+    config.cacheMaxMemorySize ?? config.experimental?.isrMemoryCacheSize
+  );
   process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
 };
 export {

package/dist/run/handlers/cache.cjs

@@ -102,7 +102,7 @@ var init_builder = __esm({
   }
 });
 
-// node_modules/@netlify/functions/dist/chunk-SURWFFYE.mjs
+// node_modules/@netlify/functions/dist/chunk-EZL2F32K.mjs
 var import_process = require("process");
 var purgeCache;
 var init_purge_cache = __esm({
@@ -113,28 +113,37 @@ var init_purge_cache = __esm({
           "`fetch` is not available. Please ensure you're using Node.js version 18.0.0 or above. Refer to https://ntl.fyi/functions-runtime for more information."
         );
       }
+      const { siteID } = options;
+      const { siteSlug } = options;
+      const { domain } = options;
+      if (siteID && siteSlug || siteID && domain || siteSlug && domain) {
+        throw new Error('Can only pass one of either "siteID", "siteSlug", or "domain"');
+      }
       const payload = {
-        cache_tags: options.tags,
-        deploy_alias: options.deployAlias
+        cache_tags: options.tags
       };
+      if ("deployAlias" in options) {
+        payload.deploy_alias = options.deployAlias;
+      } else if (!import_process.env.NETLIFY_LOCAL) {
+        payload.deploy_alias = import_process.env.NETLIFY_BRANCH;
+      }
       const token = import_process.env.NETLIFY_PURGE_API_TOKEN || options.token;
       if (import_process.env.NETLIFY_LOCAL && !token) {
         const scope = options.tags?.length ? ` for tags ${options.tags?.join(", ")}` : "";
         console.log(`Skipping purgeCache${scope} in local development.`);
         return;
       }
-      if ("siteSlug" in options) {
-        payload.site_slug = options.siteSlug;
-      } else if ("domain" in options) {
-        payload.domain = options.domain;
+      if (siteSlug) {
+        payload.site_slug = siteSlug;
+      } else if (domain) {
+        payload.domain = domain;
       } else {
-        const siteID = options.siteID || import_process.env.SITE_ID;
-        if (!siteID) {
+        payload.site_id = siteID || import_process.env.SITE_ID;
+        if (!payload.site_id) {
           throw new Error(
             "The Netlify site ID was not found in the execution environment. Please supply it manually using the `siteID` property."
           );
         }
-        payload.site_id = siteID;
       }
       if (!token) {
         throw new Error(
@@ -155,7 +164,18 @@ var init_purge_cache = __esm({
         body: JSON.stringify(payload)
       });
       if (!response.ok) {
-        throw new Error(`Cache purge API call returned an unexpected status code: ${response.status}`);
+        let text;
+        try {
+          text = await response.text();
+        } catch {
+        }
+        if (text) {
+          throw new Error(`Cache purge API call was unsuccessful.
+Status: ${response.status}
+Body: ${text}`);
+        }
+        throw new Error(`Cache purge API call was unsuccessful.
+Status: ${response.status}`);
       }
     };
   }
@@ -175,29 +195,23 @@ var import_constants = require("next/dist/lib/constants.js");
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.10.1";
+var version = "5.10.3";
 
 // src/run/handlers/cache.cts
 var import_cache_types = require("../../shared/cache-types.cjs");
-var import_regional_blob_store = require("../regional-blob-store.cjs");
+var import_storage = require("../storage/storage.cjs");
 var import_request_context = require("./request-context.cjs");
 var import_tracer = require("./tracer.cjs");
 var purgeCacheUserAgent = `${name}@${version}`;
 var NetlifyCacheHandler = class {
   options;
   revalidatedTags;
-  blobStore;
+  cacheStore;
   tracer = (0, import_tracer.getTracer)();
-  tagManifestsFetchedFromBlobStoreInCurrentRequest;
   constructor(options) {
     this.options = options;
     this.revalidatedTags = options.revalidatedTags;
-    this.blobStore = (0, import_regional_blob_store.getRegionalBlobStore)({ consistency: "strong" });
-    this.tagManifestsFetchedFromBlobStoreInCurrentRequest = {};
-  }
-  async encodeBlobKey(key) {
-    const { encodeBlobKey } = await import("../../shared/blobkey.js");
-    return await encodeBlobKey(key);
+    this.cacheStore = (0, import_storage.getMemoizedKeyValueStoreBackedByRegionalBlobStore)({ consistency: "strong" });
   }
   getTTL(blob) {
     if (blob.value?.kind === "FETCH" || blob.value?.kind === "ROUTE" || blob.value?.kind === "APP_ROUTE" || blob.value?.kind === "PAGE" || blob.value?.kind === "PAGES" || blob.value?.kind === "APP_PAGE") {
@@ -218,26 +232,17 @@ var NetlifyCacheHandler = class {
     }
     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
-      });
+      (0, import_tracer.recordWarning)(new Error("CacheHandler was called without a request context"), getCacheKeySpan);
       return;
     }
     if (requestContext.responseCacheKey && requestContext.responseCacheKey !== key) {
       requestContext.responseCacheGetLastModified = void 0;
-      getCacheKeySpan.recordException(
+      (0, import_tracer.recordWarning)(
         new Error(
           `Multiple response cache keys used in single request: ["${requestContext.responseCacheKey}, "${key}"]`
-        )
+        ),
+        getCacheKeySpan
       );
-      getCacheKeySpan.setAttributes({
-        severity: "alert",
-        warning: true
-      });
       return;
     }
     requestContext.responseCacheKey = key;
@@ -254,9 +259,6 @@ var NetlifyCacheHandler = class {
     return restOfRouteValue;
   }
   captureCacheTags(cacheValue, key) {
-    if (!cacheValue) {
-      return;
-    }
     const requestContext = (0, import_request_context.getRequestContext)();
     if (!requestContext) {
       return;
@@ -264,6 +266,11 @@ var NetlifyCacheHandler = class {
     if (requestContext.responseCacheTags) {
       return;
     }
+    if (!cacheValue) {
+      const cacheTags = [`_N_T_${key === "/index" ? "/" : encodeURI(key)}`];
+      requestContext.responseCacheTags = cacheTags;
+      return;
+    }
     if (cacheValue.kind === "PAGE" || cacheValue.kind === "PAGES" || cacheValue.kind === "APP_PAGE" || cacheValue.kind === "ROUTE" || cacheValue.kind === "APP_ROUTE") {
       if (cacheValue.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]) {
         const cacheTags = cacheValue.headers[import_constants.NEXT_CACHE_TAGS_HEADER].split(/,|%2c/gi);
@@ -313,25 +320,18 @@ var NetlifyCacheHandler = class {
   }
   async get(...args) {
     return this.tracer.withActiveSpan("get cache key", async (span) => {
-      const [key, ctx = {}] = args;
+      const [key, context = {}] = args;
       (0, import_request_context.getLogger)().debug(`[NetlifyCacheHandler.get]: ${key}`);
-      const blobKey = await this.encodeBlobKey(key);
-      span.setAttributes({ key, blobKey });
-      const blob = await this.tracer.withActiveSpan("blobStore.get", async (blobGetSpan) => {
-        blobGetSpan.setAttributes({ key, blobKey });
-        return await this.blobStore.get(blobKey, {
-          type: "json"
-        });
-      });
+      span.setAttributes({ key });
+      const blob = await this.cacheStore.get(key, "blobStore.get");
       if (!blob) {
-        span.addEvent("Cache miss", { key, blobKey });
+        span.addEvent("Cache miss", { key });
         return null;
       }
       const ttl = this.getTTL(blob);
       if ((0, import_request_context.getRequestContext)()?.isBackgroundRevalidation && typeof ttl === "number" && ttl < 0) {
         span.addEvent("Discarding stale entry due to SWR background revalidation request", {
           key,
-          blobKey,
           ttl
         });
         (0, import_request_context.getLogger)().withFields({
@@ -342,18 +342,25 @@ var NetlifyCacheHandler = class {
         );
         return null;
       }
-      const staleByTags = await this.checkCacheEntryStaleByTags(blob, ctx.tags, ctx.softTags);
+      const staleByTags = await this.checkCacheEntryStaleByTags(
+        blob,
+        context.tags,
+        context.softTags
+      );
       if (staleByTags) {
-        span.addEvent("Stale", { staleByTags, key, blobKey, ttl });
+        span.addEvent("Stale", { staleByTags, key, ttl });
         return null;
       }
       this.captureResponseCacheLastModified(blob, key, span);
-      this.captureCacheTags(blob.value, key);
+      const isDataRequest = Boolean(context.fetchUrl);
+      if (!isDataRequest) {
+        this.captureCacheTags(blob.value, key);
+      }
       switch (blob.value?.kind) {
         case "FETCH":
           span.addEvent("FETCH", {
             lastModified: blob.lastModified,
-            revalidate: ctx.revalidate,
+            revalidate: context.revalidate,
             ttl
           });
           return {
@@ -441,17 +448,16 @@ var NetlifyCacheHandler = class {
   async set(...args) {
     return this.tracer.withActiveSpan("set cache key", async (span) => {
       const [key, data, context] = args;
-      const blobKey = await this.encodeBlobKey(key);
       const lastModified = Date.now();
-      span.setAttributes({ key, lastModified, blobKey });
+      span.setAttributes({ key, lastModified });
       (0, import_request_context.getLogger)().debug(`[NetlifyCacheHandler.set]: ${key}`);
       const value = this.transformToStorableObject(data, context);
-      this.captureCacheTags(value, key);
-      await this.blobStore.setJSON(blobKey, {
-        lastModified,
-        value
-      });
-      if (data?.kind === "PAGE" || data?.kind === "PAGES") {
+      const isDataReq = Boolean(context.fetchUrl);
+      if (!isDataReq) {
+        this.captureCacheTags(value, key);
+      }
+      await this.cacheStore.set(key, { lastModified, value }, "blobStore.set");
+      if (!data && !isDataReq || data?.kind === "PAGE" || data?.kind === "PAGES") {
         const requestContext = (0, import_request_context.getRequestContext)();
         if (requestContext?.didPagesRouterOnDemandRevalidate) {
           const tag = `_N_T_${key === "/index" ? "/" : encodeURI(key)}`;
@@ -491,7 +497,7 @@ var NetlifyCacheHandler = class {
     await Promise.all(
       tags.map(async (tag) => {
         try {
-          await this.blobStore.setJSON(await this.encodeBlobKey(tag), data);
+          await this.cacheStore.set(tag, data, "tagManifest.set");
         } catch (error) {
           (0, import_request_context.getLogger)().withError(error).log(`Failed to update tag manifest for ${tag}`);
         }
@@ -502,7 +508,6 @@ var NetlifyCacheHandler = class {
     });
   }
   resetRequestCache() {
-    this.tagManifestsFetchedFromBlobStoreInCurrentRequest = {};
   }
   /**
    * Checks if a cache entry is stale through on demand revalidated tags
@@ -526,19 +531,16 @@ var NetlifyCacheHandler = class {
     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.withActiveSpan(`get tag manifest`, async (span) => {
-              span.setAttributes({ tag, blobKey });
-              return this.blobStore.get(blobKey, { type: "json" });
-            });
-          });
-          this.tagManifestsFetchedFromBlobStoreInCurrentRequest[tag] = tagManifestPromise;
-        }
+        const tagManifestPromise = this.cacheStore.get(
+          tag,
+          "tagManifest.get"
+        );
         tagManifestPromises.push(
           tagManifestPromise.then((tagManifest) => {
-            const isStale = tagManifest?.revalidatedAt >= (cacheEntry.lastModified || Date.now());
+            if (!tagManifest) {
+              return false;
+            }
+            const isStale = tagManifest.revalidatedAt >= (cacheEntry.lastModified || Date.now());
             if (isStale) {
               resolve(true);
               return true;

package/dist/run/handlers/request-context.cjs

@@ -121,6 +121,14 @@ var init_internal = __esm({
 init_internal();
 
 // src/run/handlers/request-context.cts
+var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
+var REQUEST_COUNTER_KEY = Symbol.for("nf-request-counter");
+var extendedGlobalThis = globalThis;
+function getFallbackRequestID() {
+  const requestNumber = extendedGlobalThis[REQUEST_COUNTER_KEY] ?? 0;
+  extendedGlobalThis[REQUEST_COUNTER_KEY] = requestNumber + 1;
+  return `#${requestNumber}`;
+}
 function createRequestContext(request, context) {
   const backgroundWorkPromises = [];
   const isDebugRequest = request?.headers.has("x-nf-debug-logging") || request?.headers.has("x-next-debug-logging");
@@ -142,16 +150,15 @@ function createRequestContext(request, context) {
     get backgroundWorkPromise() {
       return Promise.allSettled(backgroundWorkPromises);
     },
-    logger
+    logger,
+    requestID: request?.headers.get("x-nf-request-id") ?? getFallbackRequestID()
   };
 }
-var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
 var requestContextAsyncLocalStorage;
 function getRequestContextAsyncLocalStorage() {
   if (requestContextAsyncLocalStorage) {
     return requestContextAsyncLocalStorage;
   }
-  const extendedGlobalThis = globalThis;
   if (extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY]) {
     return extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY];
   }

package/dist/run/handlers/server.js

@@ -3098,8 +3098,8 @@ import {
   setCacheTagsHeaders,
   setVaryHeaders
 } from "../headers.js";
-import { setFetchBeforeNextPatchedIt } from "../regional-blob-store.cjs";
 import { nextResponseProxy } from "../revalidate.js";
+import { setFetchBeforeNextPatchedIt } from "../storage/storage.cjs";
 import { getLogger } from "./request-context.cjs";
 import { getTracer } from "./tracer.cjs";
 import { setupWaitUntil } from "./wait-until.cjs";
@@ -3174,11 +3174,10 @@ var server_default = async (request, _context, topLevelSpan, requestContext) =>
         headers: response.headers,
         request,
         span,
-        tracer,
         requestContext
       });
     }
-    setCacheControlHeaders(response, request, requestContext, nextConfig);
+    setCacheControlHeaders(response, request, requestContext);
     setCacheTagsHeaders(response.headers, requestContext);
     setVaryHeaders(response.headers, request, nextConfig);
     setCacheStatusHeader(response.headers, nextCache);

package/dist/run/handlers/tracer.cjs

@@ -20,7 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/run/handlers/tracer.cts
 var tracer_exports = {};
 __export(tracer_exports, {
-  getTracer: () => getTracer
+  getTracer: () => getTracer,
+  recordWarning: () => recordWarning
 });
 module.exports = __toCommonJS(tracer_exports);
 
@@ -897,7 +898,19 @@ function getTracer() {
   }
   return tracer;
 }
+function recordWarning(warning, span) {
+  const spanToRecordWarningOn = span ?? trace.getActiveSpan();
+  if (!spanToRecordWarningOn) {
+    return;
+  }
+  spanToRecordWarningOn.recordException(warning);
+  spanToRecordWarningOn.setAttributes({
+    severity: "alert",
+    warning: true
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getTracer
+  getTracer,
+  recordWarning
 });

package/dist/run/handlers/tracing.js

@@ -68866,7 +68866,7 @@ var import_semantic_conventions = __toESM(require_src(), 1);
 import { getLogger } from "./request-context.cjs";
 var {
   default: { version, name }
-} = await import("../../esm-chunks/package-UN6EVEHD.js");
+} = await import("../../esm-chunks/package-AKXSA3EX.js");
 var sdk = new import_sdk_node.NodeSDK({
   resource: new import_resources.Resource({
     [import_semantic_conventions.SEMRESATTRS_SERVICE_NAME]: name,

package/dist/run/headers.js

@@ -7,9 +7,8 @@
 import "../esm-chunks/chunk-OEQOKJGE.js";
 
 // src/run/headers.ts
-import { encodeBlobKey } from "../shared/blobkey.js";
-import { getLogger } from "./handlers/request-context.cjs";
-import { getRegionalBlobStore } from "./regional-blob-store.cjs";
+import { recordWarning } from "./handlers/tracer.cjs";
+import { getMemoizedKeyValueStoreBackedByRegionalBlobStore } from "./storage/storage.cjs";
 var ALL_VARIATIONS = Symbol.for("ALL_VARIATIONS");
 var NetlifyVaryKeys = /* @__PURE__ */ new Set(["header", "language", "cookie", "query", "country"]);
 var isNetlifyVaryKey = (key) => NetlifyVaryKeys.has(key);
@@ -88,7 +87,6 @@ var adjustDateHeader = async ({
   headers,
   request,
   span,
-  tracer,
   requestContext
 }) => {
   const key = new URL(request.url).pathname;
@@ -96,38 +94,24 @@ var adjustDateHeader = async ({
   if (requestContext.responseCacheGetLastModified) {
     lastModified = requestContext.responseCacheGetLastModified;
   } else {
-    span.recordException(
-      new Error("lastModified not found in requestContext, falling back to trying blobs")
+    recordWarning(
+      new Error("lastModified not found in requestContext, falling back to trying blobs"),
+      span
     );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
-    const blobStore = getRegionalBlobStore({ consistency: "strong" });
-    const blobKey = await encodeBlobKey(key);
-    lastModified = await tracer.withActiveSpan(
-      "get cache to calculate date header",
-      async (getBlobForDateSpan) => {
-        getBlobForDateSpan.setAttributes({
-          key,
-          blobKey
-        });
-        const blob = await blobStore.get(blobKey, { type: "json" }) ?? {};
-        getBlobForDateSpan.addEvent(blob ? "Cache hit" : "Cache miss");
-        return blob.lastModified;
-      }
+    const cacheStore = getMemoizedKeyValueStoreBackedByRegionalBlobStore({ consistency: "strong" });
+    const cacheEntry = await cacheStore.get(
+      key,
+      "get cache to calculate date header"
     );
+    lastModified = cacheEntry?.lastModified;
   }
   if (!lastModified) {
-    span.recordException(
+    recordWarning(
       new Error(
         "lastModified not found in either requestContext or blobs, date header for cached response is not set"
-      )
+      ),
+      span
     );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
     return;
   }
   const lastModifiedDate = new Date(lastModified);
@@ -141,15 +125,11 @@ function setCacheControlFromRequestContext(headers, revalidate) {
   );
   headers.set("netlify-cdn-cache-control", cdnCacheControl);
 }
-var setCacheControlHeaders = ({ headers, status }, request, requestContext, nextConfig) => {
+var setCacheControlHeaders = ({ headers, status }, request, requestContext) => {
   if (typeof requestContext.routeHandlerRevalidate !== "undefined" && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
     setCacheControlFromRequestContext(headers, requestContext.routeHandlerRevalidate);
     return;
   }
-  if (status === 308 && request.url.endsWith("/") !== nextConfig.trailingSlash) {
-    getLogger().withFields({ trailingSlash: nextConfig.trailingSlash, location: headers.get("location") }).log("NetlifyHeadersHandler.trailingSlashRedirect");
-  }
-  const cacheControl = headers.get("cache-control");
   if (status === 404) {
     if (request.url.endsWith(".php")) {
       headers.set("cache-control", "public, max-age=0, must-revalidate");
@@ -161,6 +141,7 @@ var setCacheControlHeaders = ({ headers, status }, request, requestContext, next
       return;
     }
   }
+  const cacheControl = headers.get("cache-control");
   if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
     const browserCacheControl = omitHeaderValues(cacheControl, [
       "s-maxage",
@@ -179,13 +160,16 @@ var setCacheControlHeaders = ({ headers, status }, request, requestContext, next
     headers.set("netlify-cdn-cache-control", cdnCacheControl);
     return;
   }
-  if (cacheControl === null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control") && requestContext.usedFsReadForNonFallback) {
+  if (cacheControl === null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control") && requestContext.usedFsReadForNonFallback && !requestContext.didPagesRouterOnDemandRevalidate) {
     headers.set("cache-control", "public, max-age=0, must-revalidate");
     headers.set("netlify-cdn-cache-control", `max-age=31536000, durable`);
   }
 };
 var setCacheTagsHeaders = (headers, requestContext) => {
-  if (requestContext.responseCacheTags && (headers.has("cache-control") || headers.has("netlify-cdn-cache-control"))) {
+  if (!headers.has("cache-control") && !headers.has("netlify-cdn-cache-control")) {
+    return;
+  }
+  if (requestContext.responseCacheTags) {
     headers.set("netlify-cache-tag", requestContext.responseCacheTags.join(","));
   }
 };

package/dist/run/next.cjs

@@ -493,7 +493,7 @@ var import_path = require("path");
 var import_fs_monkey = __toESM(require_lib());
 var import_request_context = require("./handlers/request-context.cjs");
 var import_tracer = require("./handlers/tracer.cjs");
-var import_regional_blob_store = require("./regional-blob-store.cjs");
+var import_storage = require("./storage/storage.cjs");
 process.env.NODE_ENV = "production";
 var { getRequestHandlers } = require("next/dist/server/lib/start-server.js");
 var ResponseCache = require("next/dist/server/response-cache/index.js").default;
@@ -543,18 +543,15 @@ async function getMockedRequestHandler(...args) {
   const tracer = (0, import_tracer.getTracer)();
   return tracer.withActiveSpan("mocked request handler", async () => {
     const ofs = { ...import_promises.default };
-    const { encodeBlobKey } = await import("../shared/blobkey.js");
     async function readFileFallbackBlobStore(...fsargs) {
       const [path, options] = fsargs;
       try {
         return await ofs.readFile(path, options);
       } catch (error) {
         if (typeof path === "string" && path.endsWith(".html")) {
-          const store = (0, import_regional_blob_store.getRegionalBlobStore)();
+          const cacheStore = (0, import_storage.getMemoizedKeyValueStoreBackedByRegionalBlobStore)();
           const relPath = (0, import_path.relative)((0, import_path.resolve)(".next/server/pages"), path);
-          const file = await store.get(await encodeBlobKey(relPath), {
-            type: "json"
-          });
+          const file = await cacheStore.get(relPath, "staticHtml.get");
           if (file !== null) {
             if (!file.isFallback) {
               const requestContext = (0, import_request_context.getRequestContext)();

package/dist/run/revalidate.js

@@ -11,8 +11,8 @@ import { isPromise } from "node:util/types";
 function isRevalidateMethod(key, nextResponseField) {
   return key === "revalidate" && typeof nextResponseField === "function";
 }
-var nextResponseProxy = (res, requestContext) => {
-  return new Proxy(res, {
+var nextResponseProxy = (response, requestContext) => {
+  return new Proxy(response, {
     get(target, key) {
       const originalValue = Reflect.get(target, key);
       if (isRevalidateMethod(key, originalValue)) {