@netlify/plugin-nextjs 5.0.0-beta.8 → 5.0.0-rc.0

package/dist/esm-chunks/{package-2CI3IXK3.js → package-5SG7C3OT.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-rc.0";
 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,21 +51,22 @@ 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.36.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",
   "@opentelemetry/resources": "^1.21.0",
-  "@opentelemetry/semantic-conventions": "^1.21.0",
+  "@opentelemetry/sdk-node": "^0.48.0",
   "@opentelemetry/sdk-trace-node": "^1.21.0",
+  "@opentelemetry/semantic-conventions": "^1.21.0",
   "@playwright/test": "^1.40.0",
   "@types/node": "^20.9.2",
+  "@types/picomatch": "^2.3.3",
   "@types/uuid": "^9.0.6",
   "@vercel/nft": "^0.26.0",
   cheerio: "^1.0.0-rc.12",
@@ -76,15 +78,18 @@ 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",
   outdent: "^0.8.0",
   "p-limit": "^4.0.0",
+  picomatch: "^3.0.1",
+  "regexp-tree": "^0.1.27",
   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,34 +5,34 @@
       })();
     
 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,
   publishStaticDir,
   unpublishStaticDir
-} from "./esm-chunks/chunk-ZWFKLYLH.js";
+} from "./esm-chunks/chunk-WQIG4U66.js";
 import {
   createEdgeHandlers
-} from "./esm-chunks/chunk-ETPYUOBQ.js";
+} from "./esm-chunks/chunk-UX4JCTAE.js";
 import {
-  PluginContext
-} from "./esm-chunks/chunk-IZ2AVCVF.js";
+  createServerHandler
+} from "./esm-chunks/chunk-FTCARYDZ.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-XXBTIYSL.js";
+import {
+  PluginContext
+} from "./esm-chunks/chunk-PGQNT7XM.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) {
@@ -2522,6 +2556,16 @@ var NetlifyCacheHandler = class {
         lastModified,
         value: data
       });
+      if (data?.kind === "PAGE") {
+        const requestContext = (0, import_request_context.getRequestContext)();
+        if (requestContext?.didPagesRouterOnDemandRevalidate) {
+          const tag = `_N_T_${key === "/index" ? "/" : key}`;
+          console.debug("Purging CDN cache for:", [tag]);
+          (0, import_functions.purgeCache)({ tags: [tag] }).catch((error) => {
+            console.error(`[NetlifyCacheHandler]: Purging the cache for tag ${tag} failed`, error);
+          });
+        }
+      }
       span.end();
     });
   }
@@ -2540,27 +2584,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;

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

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/request-context.cts
+var request_context_exports = {};
+__export(request_context_exports, {
+  createRequestContext: () => createRequestContext,
+  getRequestContext: () => getRequestContext,
+  runWithRequestContext: () => runWithRequestContext
+});
+module.exports = __toCommonJS(request_context_exports);
+var import_node_async_hooks = require("node:async_hooks");
+function createRequestContext() {
+  return {};
+}
+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];
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+function runWithRequestContext(requestContext, fn) {
+  return getRequestContextAsyncLocalStorage().run(requestContext, fn);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestContext,
+  getRequestContext,
+  runWithRequestContext
+});

package/dist/run/handlers/server.js

@@ -7,24 +7,24 @@
 import {
   require_src
 } from "../../esm-chunks/chunk-VDDK7MXY.js";
+import {
+  import_internal
+} from "../../esm-chunks/chunk-HYBEXB2Z.js";
 import {
   getTagsManifest
-} 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 {
   adjustDateHeader,
-  handleNextCacheHeader,
   setCacheControlHeaders,
+  setCacheStatusHeader,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../../esm-chunks/chunk-N23TUUXK.js";
+} from "../../esm-chunks/chunk-UTCWWUFW.js";
 import "../../esm-chunks/chunk-TYCYFZ22.js";
 import {
   nextResponseProxy
-} from "../../esm-chunks/chunk-WT2HN3M6.js";
-import {
-  import_internal
-} from "../../esm-chunks/chunk-HYBEXB2Z.js";
+} from "../../esm-chunks/chunk-RL4K4CVH.js";
 import {
   __commonJS,
   __toESM
@@ -3261,6 +3261,7 @@ function toComputeResponse(res) {
 
 // src/run/handlers/server.ts
 var import_api = __toESM(require_src(), 1);
+import { createRequestContext, runWithRequestContext } from "./request-context.cjs";
 var nextHandler;
 var nextConfig;
 var tagsManifest;
@@ -3291,20 +3292,33 @@ var server_default = async (request) => {
   }
   return await tracer.startActiveSpan("generate response", async (span) => {
     const { req, res } = toReqRes(request);
-    const resProxy = nextResponseProxy(res);
-    delete req.headers["accept-encoding"];
-    const nextHandlerPromise = nextHandler(req, resProxy).catch((error) => {
-      import_internal.systemLogger.withError(error).error("next handler error");
-      console.error(error);
-      resProxy.statusCode = 500;
-      resProxy.end("Internal Server Error");
-    });
+    const requestContext = createRequestContext();
+    const resProxy = nextResponseProxy(res, requestContext);
+    const nextHandlerPromise = runWithRequestContext(
+      requestContext,
+      () => nextHandler(req, resProxy).catch((error) => {
+        import_internal.systemLogger.withError(error).error("next handler error");
+        console.error(error);
+        resProxy.statusCode = 500;
+        span.recordException(error);
+        span.setAttribute("http.status_code", 500);
+        span.setStatus({
+          code: import_api.SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        span.end();
+        resProxy.end("Internal Server Error");
+      })
+    );
     const response = await toComputeResponse(resProxy);
-    await adjustDateHeader(response.headers, request, span, tracer);
-    setCacheControlHeaders(response.headers, request);
-    setCacheTagsHeaders(response.headers, request, tagsManifest);
+    if (requestContext.responseCacheKey) {
+      span.setAttribute("responseCacheKey", requestContext.responseCacheKey);
+    }
+    await adjustDateHeader({ headers: response.headers, request, span, tracer, requestContext });
+    setCacheControlHeaders(response.headers, request, requestContext);
+    setCacheTagsHeaders(response.headers, request, tagsManifest, requestContext);
     setVaryHeaders(response.headers, request, nextConfig);
-    handleNextCacheHeader(response.headers);
+    setCacheStatusHeader(response.headers);
     if (response.status > 300 && response.status < 400 || response.status >= 500) {
       const body = await response.text();
       span.end();

package/dist/run/handlers/tracing.js

@@ -52794,7 +52794,7 @@ var import_semantic_conventions = __toESM(require_src2(), 1);
 var import_api = __toESM(require_src(), 1);
 var {
   default: { version, name }
-} = await import("../../esm-chunks/package-2CI3IXK3.js");
+} = await import("../../esm-chunks/package-5SG7C3OT.js");
 var sdk = new import_sdk_node.NodeSDK({
   resource: new import_resources.Resource({
     [import_semantic_conventions.SemanticResourceAttributes.SERVICE_NAME]: name,

package/dist/run/headers.js

@@ -6,17 +6,17 @@
     
 import {
   adjustDateHeader,
-  handleNextCacheHeader,
   setCacheControlHeaders,
+  setCacheStatusHeader,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../esm-chunks/chunk-N23TUUXK.js";
+} from "../esm-chunks/chunk-UTCWWUFW.js";
 import "../esm-chunks/chunk-TYCYFZ22.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
 export {
   adjustDateHeader,
-  handleNextCacheHeader,
   setCacheControlHeaders,
+  setCacheStatusHeader,
   setCacheTagsHeaders,
   setVaryHeaders
 };

package/dist/run/next.cjs

@@ -2734,11 +2734,11 @@ var pipeline = (0, import_util.promisify)(import_stream.default.pipeline);
 // src/run/next.cts
 var import_api = __toESM(require_src());
 var import_fs_monkey = __toESM(require_lib());
+var import_request_context = require("./handlers/request-context.cjs");
 var fetchBeforeNextPatchedIt = globalThis.fetch;
 async function getMockedRequestHandlers(...args) {
   const tracer = import_api.trace.getTracer("Next.js Runtime");
   return tracer.startActiveSpan("mocked request handler", async (span) => {
-    const store = getDeployStore({ fetch: fetchBeforeNextPatchedIt });
     const ofs = { ...import_promises.default };
     const { encodeBlobKey: encodeBlobKey2 } = await Promise.resolve().then(() => (init_blobkey(), blobkey_exports));
     async function readFileFallbackBlobStore(...fsargs) {
@@ -2747,9 +2747,14 @@ async function getMockedRequestHandlers(...args) {
         return await ofs.readFile(path, options);
       } catch (error) {
         if (typeof path === "string" && path.endsWith(".html")) {
+          const store = getDeployStore({ fetch: fetchBeforeNextPatchedIt });
           const relPath = (0, import_path.relative)((0, import_path.resolve)(".next/server/pages"), path);
           const file = await store.get(await encodeBlobKey2(relPath));
           if (file !== null) {
+            const requestContext = (0, import_request_context.getRequestContext)();
+            if (requestContext) {
+              requestContext.usedFsRead = true;
+            }
             return file;
           }
         }

package/dist/run/revalidate.js

@@ -6,7 +6,7 @@
     
 import {
   nextResponseProxy
-} from "../esm-chunks/chunk-WT2HN3M6.js";
+} from "../esm-chunks/chunk-RL4K4CVH.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
 export {
   nextResponseProxy