@opennextjs/aws 4.1.0 → 4.1.2

package/dist/adapters/cache.js

@@ -1,5 +1,6 @@
-import { getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
+import { getStaleLastModified, getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
+import { CACHE_TAGS_HEADER } from "../utils/cacheHeaders";
 import { compareSemver } from "../utils/semver";
 import { debug, error, warn } from "./logger";
 export const SOFT_TAG_PREFIX = "_N_T_/";
@@ -92,8 +93,12 @@ export default class Cache {
                 : await isStale(key, tags, _lastModified);
             const store = globalThis.__openNextAls.getStore();
             if (store) {
+                // The sentinel is kept as is in the store so that the revalidation queue keeps
+                // deduplicating every stale request for the same path.
                 store.lastModified = _isStale ? 1 : _lastModified;
-                _lastModified = store.lastModified;
+            }
+            if (_isStale) {
+                _lastModified = getStaleLastModified(cacheData.revalidate);
             }
             if (cacheData?.type === "route") {
                 return {
@@ -111,6 +116,16 @@ export default class Cache {
                 };
             }
             if (cacheData?.type === "page" || cacheData?.type === "app") {
+                // Without the html there is no valid value to return, so we report a miss and let
+                // the server render the page. Next.js behaves the same way, its file system cache
+                // reads the `.html` file first and turns a read failure into a miss.
+                //
+                // The check is on `undefined` and not on falsiness because an empty string is a
+                // valid value: a PPR route with an empty static shell has an empty `.html` file.
+                if (cacheData.html === undefined) {
+                    warn("No html in the cache entry", key);
+                    return null;
+                }
                 if (compareSemver(globalThis.nextVersion, ">=", "15.0.0") &&
                     cacheData?.type === "app") {
                     const segmentData = new Map();
@@ -124,7 +139,13 @@ export default class Cache {
                         value: {
                             kind: "APP_PAGE",
                             html: cacheData.html,
-                            rscData: Buffer.from(cacheData.rsc),
+                            // `rsc` is absent when the build collected neither a `.rsc` nor a
+                            // `.prefetch.rsc` file, see `CachedFile`. An undefined value is expected: the
+                            // Next.js file system cache also leaves `rscData` undefined for fallback
+                            // shells, and on 16.2+ for postponed PPR routes.
+                            rscData: cacheData.rsc === undefined
+                                ? undefined
+                                : Buffer.from(cacheData.rsc),
                             status: meta?.status,
                             headers: meta?.headers,
                             postponed: meta?.postponed,
@@ -132,6 +153,13 @@ export default class Cache {
                         },
                     };
                 }
+                const pageData = cacheData.type === "page" ? cacheData.json : cacheData.rsc;
+                // Only reachable for an app page on Next.js < 15, where an absent `rsc` leaves us
+                // without any page data to return.
+                if (pageData === undefined) {
+                    warn("No page data in the cache entry", key);
+                    return null;
+                }
                 return {
                     lastModified: _lastModified,
                     value: {
@@ -139,7 +167,7 @@ export default class Cache {
                             ? "PAGES"
                             : "PAGE",
                         html: cacheData.html,
-                        pageData: cacheData.type === "page" ? cacheData.json : cacheData.rsc,
+                        pageData,
                         status: meta?.status,
                         headers: meta?.headers,
                     },
@@ -232,7 +260,7 @@ export default class Cache {
                         await globalThis.incrementalCache.set(key, {
                             type: "app",
                             html,
-                            rsc: rscData.toString("utf8"),
+                            rsc: rscData?.toString("utf8"),
                             meta: {
                                 status,
                                 headers,
@@ -408,11 +436,18 @@ export default class Cache {
         }
         // Write derivedTags to the tag cache
         // If we use an in house version of getDerivedTags in build we should use it here instead of next's one
+        // `x-next-cache-tags` is always a comma separated string: Next.js sets it from
+        // `metadata.fetchTags`, which is a string. The header type allows an array because it
+        // is shared with headers that can legitimately repeat, so we narrow on `typeof` here.
+        // Next.js guards the same way when it reads the header back.
+        const pageCacheTags = data?.kind === "PAGE" || data?.kind === "APP_PAGE"
+            ? data.headers?.[CACHE_TAGS_HEADER]
+            : undefined;
         const derivedTags = data?.kind === "FETCH"
             ? //@ts-expect-error - On older versions of next, ctx was a number, but for these cases we use data?.data?.tags
                 (ctx?.tags ?? data?.data?.tags ?? []) // before version 14 next.js used data?.data?.tags so we keep it for backward compatibility
-            : data?.kind === "PAGE"
-                ? (data.headers?.["x-next-cache-tags"]?.split(",") ?? [])
+            : typeof pageCacheTags === "string"
+                ? pageCacheTags.split(",")
                 : [];
         debug("derivedTags", derivedTags);
         // Get all tags stored in dynamodb for the given key

package/dist/adapters/middleware.js

@@ -1,3 +1,4 @@
+import { ISR_HEADER } from "../utils/cacheHeaders";
 import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
@@ -21,7 +22,7 @@ const defaultHandler = async (internalEvent, options) => {
     const requestId = Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the external middleware
     return runWithOpenNextRequestContext({
-        isISRRevalidation: internalEvent.headers["x-isr"] === "1",
+        isISRRevalidation: internalEvent.headers[ISR_HEADER] === "1",
         waitUntil: options?.waitUntil,
         requestId,
     }, async () => {

package/dist/adapters/plugins/image-optimization/image-optimization.replacement.js

@@ -17,18 +17,19 @@ export async function optimizeImage(headers, imageParams, nextConfig, handleRequ
      *
      * https://github.com/vercel/next.js/blob/bfe2ab4/packages/next/src/server/image-optimizer.ts#L711
      */
+    // Next 16 rejects upstream hosts resolving to private IPs unless the user
+    // opts out with `images.dangerouslyAllowLocalIP` — forward their setting
+    // instead of always disabling the opt-out.
+    const dangerouslyAllowLocalIP = Boolean(nextConfig.images?.dangerouslyAllowLocalIP);
     const callFetchExternalImage = () => {
         const version = globalThis.nextVersion;
-        // v16.1.5+
         if (compareSemver(version, ">=", "16.1.5")) {
-            return fetchExternalImage(href, false, maximumResponseBody);
+            return fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponseBody);
         }
-        // v16.0.0–v16.1.4
         if (compareSemver(version, ">=", "16")) {
             // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
-            return fetchExternalImage(href, false);
+            return fetchExternalImage(href, dangerouslyAllowLocalIP);
         }
-        // v15.5.10–v15.x
         if (compareSemver(version, ">=", "15.5.10")) {
             // @ts-expect-error - fetchExternalImage signature varies across Next.js versions
             return fetchExternalImage(href, maximumResponseBody);

package/dist/adapters/revalidate.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import https from "node:https";
 import path from "node:path";
 import { createGenericHandler } from "../core/createGenericHandler.js";
+import { ISR_HEADER, NEXTJS_CACHE_HEADER, PRERENDER_REVALIDATE_HEADER, } from "../utils/cacheHeaders.js";
 import { debug, error } from "./logger.js";
 const prerenderManifest = loadPrerenderManifest();
 const ALLOWED_STATUS_CODES = [200, 307, 308, 404];
@@ -23,8 +24,8 @@ const defaultHandler = async (event) => {
                 const req = https.request(`https://${host}${url}`, {
                     method: "HEAD",
                     headers: {
-                        "x-prerender-revalidate": prerenderManifest.preview.previewModeId,
-                        "x-isr": "1",
+                        [PRERENDER_REVALIDATE_HEADER]: prerenderManifest.preview.previewModeId,
+                        [ISR_HEADER]: "1",
                     },
                 }, (res) => {
                     debug("revalidating", {
@@ -34,7 +35,7 @@ const defaultHandler = async (event) => {
                         statusCode: res.statusCode,
                     });
                     if (!ALLOWED_STATUS_CODES.includes(res.statusCode ?? 0) ||
-                        res.headers["x-nextjs-cache"] !== "REVALIDATED") {
+                        res.headers[NEXTJS_CACHE_HEADER] !== "REVALIDATED") {
                         failedRecords.push(record);
                     }
                     resolve(res);

package/dist/build/copyTracedFiles.js

@@ -159,6 +159,15 @@ File ${serverPath} does not exist
     if (existsSync(path.join(dotNextDir, INSTRUMENTATION_TRACE_FILE))) {
         // We still need to copy the nft.json file so that computeCopyFilesForPage doesn't throw
         copyFileAndMakeOwnerWritable(path.join(dotNextDir, INSTRUMENTATION_TRACE_FILE), path.join(standaloneNextDir, INSTRUMENTATION_TRACE_FILE));
+        // Next 16's standalone output no longer includes `server/instrumentation.js`
+        // in the standalone dir, but `computeCopyFilesForPage` asserts it exists
+        // there. Copy it from the build dir (mirroring the .nft.json copy above) so
+        // the assertion passes and the instrumentation file ships in the bundle.
+        const instrumentationServerFile = path.join("server", "instrumentation.js");
+        if (existsSync(path.join(dotNextDir, instrumentationServerFile)) &&
+            !existsSync(path.join(standaloneNextDir, instrumentationServerFile))) {
+            copyFileAndMakeOwnerWritable(path.join(dotNextDir, instrumentationServerFile), path.join(standaloneNextDir, instrumentationServerFile));
+        }
         computeCopyFilesForPage("instrumentation");
         logger.debug("Adding instrumentation trace files");
     }

package/dist/build/createAssets.js

@@ -4,6 +4,7 @@ import { loadConfig } from "../adapters/config/util.js";
 import { safeParseJsonFile } from "../utils/safe-json-parse.js";
 import logger from "../logger.js";
 import { isBinaryContentType } from "../utils/binary.js";
+import { CACHE_TAGS_HEADER } from "../utils/cacheHeaders.js";
 import * as buildHelper from "./helper.js";
 /**
  * Copy the static assets to the output folder
@@ -94,6 +95,13 @@ export function createCacheAssets(options) {
                 case ".json":
                 case ".body":
                 case ".rsc": {
+                    // Stripping `.prefetch` maps both `<page>.rsc` and `<page>.prefetch.rsc` onto
+                    // the same cache entry, so the `rsc` field can hold either payload. When both
+                    // files exist the first one traversed wins, as the spread below keeps the value
+                    // already recorded for that extension.
+                    //
+                    // Next 16.1 removed `.prefetch.rsc`, so the strip is a no-op on Next 16 where
+                    // the `rsc` field always holds a full payload.
                     const newFilePath = path
                         .join(outputCachePath, relativePath)
                         .substring(0, path.join(outputCachePath, relativePath).length - ext.length)
@@ -181,8 +189,8 @@ export function createCacheAssets(options) {
             buildHelper.traverseFiles(sourceDir, ({ absolutePath, relativePath }) => absolutePath.endsWith(".meta") && !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
                 const fileContent = fs.readFileSync(absolutePath, "utf8");
                 const fileData = safeParseJsonFile(fileContent, absolutePath);
-                if (fileData?.headers?.["x-next-cache-tags"]) {
-                    fileData.headers["x-next-cache-tags"]
+                if (fileData?.headers?.[CACHE_TAGS_HEADER]) {
+                    fileData.headers[CACHE_TAGS_HEADER]
                         .split(",")
                         .forEach((tag) => {
                         // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation

package/dist/build/createImageOptimizationBundle.js

@@ -74,7 +74,7 @@ export async function createImageOptimizationBundle(options) {
     // Sharp provides pre-build binaries for all platforms. https://github.com/lovell/sharp/blob/main/docs/install.md#cross-platform
     // Target should be same as used by Lambda, see https://github.com/sst/sst/blob/ca6f763fdfddd099ce2260202d0ce48c72e211ea/packages/sst/src/constructs/NextjsSite.ts#L114
     // For SHARP_IGNORE_GLOBAL_LIBVIPS see: https://github.com/lovell/sharp/blob/main/docs/install.md#aws-lambda
-    const sharpVersion = process.env.SHARP_VERSION ?? "0.32.6";
+    const sharpVersion = process.env.SHARP_VERSION ?? "0.35.3";
     // In development, we want to use the local machine settings
     const isDev = config.imageOptimization?.loader === "fs-dev";
     installDependencies(outputPath, config.imageOptimization?.install ?? {

package/dist/core/requestHandler.js

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
+import { ISR_HEADER } from "../utils/cacheHeaders";
 import { runWithOpenNextRequestContext } from "../utils/promise";
 import { NextConfig } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
@@ -22,7 +23,7 @@ export async function openNextHandler(internalEvent, options) {
         : Math.random().toString(36);
     // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
     return runWithOpenNextRequestContext({
-        isISRRevalidation: initialHeaders["x-isr"] === "1",
+        isISRRevalidation: initialHeaders[ISR_HEADER] === "1",
         waitUntil: options?.waitUntil,
         requestId,
     }, async () => {

package/dist/core/routing/cacheInterceptor.js

@@ -3,7 +3,8 @@ import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { isBinaryContentType } from "../../utils/binary";
 import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache";
-import { debug, error } from "../../adapters/logger";
+import { CACHE_CONTROL_HEADER, NO_STORE_CACHE_CONTROL, OPEN_NEXT_CACHE_HEADER, PRERENDER_REVALIDATE_HEADER, fixCacheControlForError, } from "../../utils/cacheHeaders";
+import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
 import { generateMessageGroupId } from "./queue";
 const CACHE_ONE_YEAR = 60 * 60 * 24 * 365;
@@ -41,8 +42,8 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
     if (revalidate === 0) {
         // This one should never happen
         return {
-            "cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
-            "x-opennext-cache": "ERROR",
+            [CACHE_CONTROL_HEADER]: NO_STORE_CACHE_CONTROL,
+            [OPEN_NEXT_CACHE_HEADER]: "ERROR",
             etag,
         };
     }
@@ -77,53 +78,76 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
             });
         }
         return {
-            "cache-control": `s-maxage=${sMaxAge}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
-            "x-opennext-cache": isStale ? "STALE" : "HIT",
+            [CACHE_CONTROL_HEADER]: `s-maxage=${sMaxAge}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+            [OPEN_NEXT_CACHE_HEADER]: isStale ? "STALE" : "HIT",
             etag,
         };
     }
     return {
-        "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
-        "x-opennext-cache": "HIT",
+        [CACHE_CONTROL_HEADER]: `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+        [OPEN_NEXT_CACHE_HEADER]: "HIT",
         etag,
     };
 }
+/**
+ * Computes the body of an RSC response from a cached app router entry.
+ *
+ * @param event The incoming event, used to read the segment prefetch header
+ * @param cachedValue The cache entry, must be of type `app`
+ * @returns The body and the headers to add to the response, or `undefined` when
+ * the entry can not serve the request - the caller should then fallback to the server.
+ * @throws When `cachedValue` is not of type `app`
+ */
 function getBodyForAppRouter(event, cachedValue) {
     if (cachedValue.type !== "app") {
         throw new Error("getBodyForAppRouter called with non-app cache value");
     }
-    try {
-        const segmentHeader = `${event.headers[NEXT_SEGMENT_PREFETCH_HEADER]}`;
-        const isSegmentResponse = Boolean(segmentHeader) &&
-            segmentHeader in (cachedValue.segmentData || {}) &&
-            !NextConfig.experimental?.prefetchInlining;
-        const body = isSegmentResponse
-            ? cachedValue.segmentData[segmentHeader]
-            : cachedValue.rsc;
+    const segmentHeader = `${event.headers[NEXT_SEGMENT_PREFETCH_HEADER]}`;
+    const isSegmentResponse = Boolean(segmentHeader) &&
+        segmentHeader in (cachedValue.segmentData || {}) &&
+        !NextConfig.experimental?.prefetchInlining;
+    if (isSegmentResponse) {
         return {
-            body,
-            additionalHeaders: isSegmentResponse
-                ? { [NEXT_PRERENDER_HEADER]: "1", [NEXT_POSTPONED_HEADER]: "2" }
-                : {},
+            body: cachedValue.segmentData[segmentHeader],
+            additionalHeaders: {
+                [NEXT_PRERENDER_HEADER]: "1",
+                [NEXT_POSTPONED_HEADER]: "2",
+            },
         };
     }
-    catch (e) {
-        error("Error while getting body for app router from cache:", e);
-        return { body: cachedValue.rsc, additionalHeaders: {} };
+    // `rsc` is absent when the build collected neither a `.rsc` nor a `.prefetch.rsc` file for
+    // this entry - fallback shells, and postponed PPR routes on Next 16.2+, see `CachedFile`.
+    // There is nothing valid to serve, and falling back to an empty payload would break the
+    // router and let the CDN cache the empty response, so let the server generate it.
+    if (cachedValue.rsc === undefined) {
+        return undefined;
     }
+    return { body: cachedValue.rsc, additionalHeaders: {} };
 }
+/**
+ * Generates the response to serve for a cached `app` or `page` entry.
+ *
+ * @param event The incoming event
+ * @param localizedPath The localized path, used to compute the cache control
+ * @param cachedValue The cache entry, must be of type `app` or `page`
+ * @param lastModified Time of the last update to the cache entry
+ * @param isStaleFromTagCache Whether the tag cache reported the entry as stale
+ * @returns The result to serve, or `undefined` when the entry can not serve the
+ * request - the caller should then fallback to the server.
+ * @throws When `cachedValue` is neither of type `app` nor `page`
+ */
 async function generateResult(event, localizedPath, cachedValue, lastModified, isStaleFromTagCache = false) {
     debug("Returning result from experimental cache");
-    let body = "";
+    let body;
     let type = "application/octet-stream";
     let isDataRequest = false;
     let additionalHeaders = {};
     if (cachedValue.type === "app") {
         isDataRequest = event.headers.rsc === "1";
         if (isDataRequest) {
-            const { body: appRouterBody, additionalHeaders: appHeaders } = getBodyForAppRouter(event, cachedValue);
-            body = appRouterBody;
-            additionalHeaders = appHeaders;
+            const appRouterResult = getBodyForAppRouter(event, cachedValue);
+            body = appRouterResult?.body;
+            additionalHeaders = appRouterResult?.additionalHeaders ?? {};
         }
         else {
             body = cachedValue.html;
@@ -138,24 +162,37 @@ async function generateResult(event, localizedPath, cachedValue, lastModified, i
     else {
         throw new Error("generateResult called with unsupported cache value type, only 'app' and 'page' are supported");
     }
+    // Next.js does not write every file for every route at build time, so the entry might
+    // not hold the data needed to serve this particular request.
+    if (body === undefined) {
+        debug("Missing body in the cache entry, falling back to the server");
+        return undefined;
+    }
     const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified, isStaleFromTagCache);
+    // Sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
+    // Also set the status code to the rewriteStatusCode if defined
+    // This can happen in handleMiddleware in routingHandler.
+    // `NextResponse.rewrite(url, { status: xxx})
+    // The rewrite status code should take precedence over the cached one
+    const statusCode = event.rewriteStatusCode ?? cachedValue.meta?.status ?? 200;
+    const headers = {
+        ...cacheControl,
+        "content-type": type,
+        ...cachedValue.meta?.headers,
+        vary: VARY_HEADER,
+        ...additionalHeaders,
+    };
+    // Applied last so that it wins over both the computed cache control and the one
+    // that could be stored in the entry's own headers. This is the same override the
+    // server path applies in `OpenNextNodeResponse.fixHeadersForError`, which the
+    // interceptor bypasses by returning a result directly.
+    fixCacheControlForError(headers, statusCode);
     return {
         type: "core",
-        // Sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
-        // Also set the status code to the rewriteStatusCode if defined
-        // This can happen in handleMiddleware in routingHandler.
-        // `NextResponse.rewrite(url, { status: xxx})
-        // The rewrite status code should take precedence over the cached one
-        statusCode: event.rewriteStatusCode ?? cachedValue.meta?.status ?? 200,
+        statusCode,
         body: toReadableStream(body, false),
         isBase64Encoded: false,
-        headers: {
-            ...cacheControl,
-            "content-type": type,
-            ...cachedValue.meta?.headers,
-            vary: VARY_HEADER,
-            ...additionalHeaders,
-        },
+        headers,
     };
 }
 /**
@@ -180,7 +217,7 @@ function decodePathParams(pathname) {
 }
 export async function cacheInterceptor(event) {
     if (Boolean(event.headers["next-action"]) ||
-        Boolean(event.headers["x-prerender-revalidate"]))
+        Boolean(event.headers[PRERENDER_REVALIDATE_HEADER]))
         return event;
     // Check for Next.js preview mode cookies
     const cookies = event.headers.cookie || "";
@@ -239,8 +276,11 @@ export async function cacheInterceptor(event) {
             const host = event.headers.host;
             switch (cachedData?.value?.type) {
                 case "app":
-                case "page":
-                    return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified, _isStale);
+                case "page": {
+                    const result = await generateResult(event, localizedPath, cachedData.value, cachedData.lastModified, _isStale);
+                    // The cache entry can not serve this request, fallback to the server.
+                    return result ?? event;
+                }
                 case "redirect": {
                     const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified, _isStale);
                     return {
@@ -258,15 +298,19 @@ export async function cacheInterceptor(event) {
                 case "route": {
                     const cacheControl = await computeCacheControl(localizedPath, cachedData.value.body, host, cachedData.value.revalidate, cachedData.lastModified, _isStale);
                     const isBinary = isBinaryContentType(String(cachedData.value.meta?.headers?.["content-type"]));
+                    const statusCode = event.rewriteStatusCode ?? cachedData.value.meta?.status ?? 200;
+                    const headers = {
+                        ...cacheControl,
+                        ...cachedData.value.meta?.headers,
+                        vary: VARY_HEADER,
+                    };
+                    // See the note in `generateResult`.
+                    fixCacheControlForError(headers, statusCode);
                     return {
                         type: "core",
-                        statusCode: event.rewriteStatusCode ?? cachedData.value.meta?.status ?? 200,
+                        statusCode,
                         body: toReadableStream(cachedData.value.body, isBinary),
-                        headers: {
-                            ...cacheControl,
-                            ...cachedData.value.meta?.headers,
-                            vary: VARY_HEADER,
-                        },
+                        headers,
                         isBase64Encoded: isBinary,
                     };
                 }

package/dist/core/routing/middleware.js

@@ -1,4 +1,5 @@
 import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
+import { ISR_HEADER, PRERENDER_REVALIDATE_HEADER } from "../../utils/cacheHeaders.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { getQueryFromSearchParams } from "../../overrides/converters/utils.js";
 import { localizePath } from "./i18n/index.js";
@@ -23,8 +24,8 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
     // We bypass the middleware if the request is internal
     // We should only do that if the request has the correct `x-prerender-revalidate` header
     // The `x-prerender-revalidate` header is set at build time and should be safe to trust
-    if (headers["x-isr"] &&
-        headers["x-prerender-revalidate"] ===
+    if (headers[ISR_HEADER] &&
+        headers[PRERENDER_REVALIDATE_HEADER] ===
             PrerenderManifest?.preview?.previewModeId)
         return internalEvent;
     // We only need the normalizedPath to check if the middleware should run

package/dist/core/routing/util.d.ts

@@ -11,6 +11,16 @@ import { ReadableStream } from "node:stream/web";
 export declare function isExternal(url?: string, host?: string): boolean;
 export declare function convertFromQueryString(query: string): Record<string, string | string[]>;
 /**
+ * Splits an URL into its parts
+ *
+ * The URL is a route destination, i.e. a `path-to-regexp` pattern rather than a
+ * well formed URL, so it can not be parsed with `new URL()` which would percent
+ * encode some of the pattern characters.
+ *
+ * @param url The URL to split
+ * @param isExternal Whether the URL points to an external host
+ * @returns The protocol, hostname, pathname and query string of the URL
+ * @throws When `isExternal` is true and the URL is not an absolute HTTP(S) URL
  *
  * @__PURE__
  */

package/dist/core/routing/util.js

@@ -6,6 +6,7 @@ import { getQueryFromIterator, parseHeaders } from "../../http/util.js";
 import { ReadableStream } from "node:stream/web";
 import { debug, error } from "../../adapters/logger.js";
 import { isBinaryContentType } from "../../utils/binary.js";
+import { CACHE_CONTROL_HEADER, ISR_HEADER, NEXTJS_CACHE_HEADER, NO_STORE_CACHE_CONTROL, fixCacheControlForError, } from "../../utils/cacheHeaders.js";
 import { localizePath } from "./i18n/index.js";
 import { generateMessageGroupId } from "./queue.js";
 /**
@@ -40,6 +41,16 @@ export function convertFromQueryString(query) {
     }));
 }
 /**
+ * Splits an URL into its parts
+ *
+ * The URL is a route destination, i.e. a `path-to-regexp` pattern rather than a
+ * well formed URL, so it can not be parsed with `new URL()` which would percent
+ * encode some of the pattern characters.
+ *
+ * @param url The URL to split
+ * @param isExternal Whether the URL points to an external host
+ * @returns The protocol, hostname, pathname and query string of the URL
+ * @throws When `isExternal` is true and the URL is not an absolute HTTP(S) URL
  *
  * @__PURE__
  */
@@ -49,12 +60,12 @@ export function getUrlParts(url, isExternal) {
         const match = url.match(regex);
         return {
             hostname: "",
-            pathname: match?.[1] ? `/${match[1]}` : url,
+            pathname: url.startsWith("/") ? `/${match?.[1] ?? ""}` : "",
             protocol: "",
             queryString: match?.[2] ?? "",
         };
     }
-    const regex = /^(https?:)\/\/?([^\/\s]+)(\/[^?]*)?(\?.*)?/;
+    const regex = /^(https?:)\/\/?([^\/\s?]+)(\/[^?]*)?(\?.*)?/;
     const match = url.match(regex);
     if (!match) {
         throw new Error(`Invalid external URL: ${url}`);
@@ -195,11 +206,6 @@ export function convertBodyToReadableStream(method, body) {
         },
     });
 }
-var CommonHeaders;
-(function (CommonHeaders) {
-    CommonHeaders["CACHE_CONTROL"] = "cache-control";
-    CommonHeaders["NEXT_CACHE"] = "x-nextjs-cache";
-})(CommonHeaders || (CommonHeaders = {}));
 /**
  *
  * @__PURE__
@@ -207,11 +213,7 @@ var CommonHeaders;
 export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     // We don't want to cache error pages
     if (internalEvent.rawPath === "/404" || internalEvent.rawPath === "/500") {
-        if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
-            return;
-        }
-        headers[CommonHeaders.CACHE_CONTROL] =
-            "private, no-cache, no-store, max-age=0, must-revalidate";
+        fixCacheControlForError(headers, internalEvent.rawPath === "/404" ? 404 : 500);
         return;
     }
     const localizedPath = localizePath(internalEvent);
@@ -220,7 +222,7 @@ export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     // Requests containing an `x-middleware-prefetch` header must not be cached
     if (HtmlPages.includes(localizedPath) &&
         !internalEvent.headers["x-middleware-prefetch"]) {
-        headers[CommonHeaders.CACHE_CONTROL] =
+        headers[CACHE_CONTROL_HEADER] =
             "public, max-age=0, s-maxage=31536000, must-revalidate";
     }
 }
@@ -230,7 +232,7 @@ export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
  */
 export function fixSWRCacheHeader(headers) {
     // WORKAROUND: `NextServer` does not set correct SWR cache headers — https://github.com/sst/open-next#workaround-nextserver-does-not-set-correct-swr-cache-headers
-    let cacheControl = headers[CommonHeaders.CACHE_CONTROL];
+    let cacheControl = headers[CACHE_CONTROL_HEADER];
     if (!cacheControl)
         return;
     if (Array.isArray(cacheControl)) {
@@ -238,7 +240,7 @@ export function fixSWRCacheHeader(headers) {
     }
     if (typeof cacheControl !== "string")
         return;
-    headers[CommonHeaders.CACHE_CONTROL] = cacheControl.replace(/\bstale-while-revalidate(?!=)/, "stale-while-revalidate=2592000");
+    headers[CACHE_CONTROL_HEADER] = cacheControl.replace(/\bstale-while-revalidate(?!=)/, "stale-while-revalidate=2592000");
 }
 /**
  *
@@ -261,7 +263,7 @@ export function addOpenNextHeader(headers) {
  * @__PURE__
  */
 export async function revalidateIfRequired(host, rawPath, headers, req) {
-    if (headers[CommonHeaders.NEXT_CACHE] === "STALE") {
+    if (headers[NEXTJS_CACHE_HEADER] === "STALE") {
         // If the URL is rewritten, revalidation needs to be done on the rewritten URL.
         // - Link to Next.js doc: https://nextjs.org/docs/pages/building-your-application/data-fetching/incremental-static-regeneration#on-demand-revalidation
         // - Link to NextInternalRequestMeta: https://github.com/vercel/next.js/blob/57ab2818b93627e91c937a130fb56a36c41629c3/packages/next/src/server/request-meta.ts#L11
@@ -305,37 +307,35 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
  */
 export function fixISRHeaders(headers) {
     const sMaxAgeRegex = /s-maxage=(\d+)/;
-    const match = headers[CommonHeaders.CACHE_CONTROL]?.match(sMaxAgeRegex);
+    const match = headers[CACHE_CONTROL_HEADER]?.match(sMaxAgeRegex);
     const sMaxAge = match ? Number.parseInt(match[1]) : undefined;
     // We only apply the fix if the cache-control header contains s-maxage
     if (!sMaxAge) {
         return;
     }
-    if (headers[CommonHeaders.NEXT_CACHE] === "REVALIDATED") {
-        headers[CommonHeaders.CACHE_CONTROL] =
-            "private, no-cache, no-store, max-age=0, must-revalidate";
+    if (headers[NEXTJS_CACHE_HEADER] === "REVALIDATED") {
+        headers[CACHE_CONTROL_HEADER] = NO_STORE_CACHE_CONTROL;
         return;
     }
     const _lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
-    if (headers[CommonHeaders.NEXT_CACHE] === "HIT" && _lastModified > 0) {
-        debug("cache-control", headers[CommonHeaders.CACHE_CONTROL], _lastModified, Date.now());
+    if (headers[NEXTJS_CACHE_HEADER] === "HIT" && _lastModified > 0) {
+        debug("cache-control", headers[CACHE_CONTROL_HEADER], _lastModified, Date.now());
         // 31536000 is the default s-maxage value for SSG pages
         if (sMaxAge && sMaxAge !== 31536000) {
             // calculate age
             const age = Math.round((Date.now() - _lastModified) / 1000);
             const remainingTtl = Math.max(sMaxAge - age, 1);
-            headers[CommonHeaders.CACHE_CONTROL] =
+            headers[CACHE_CONTROL_HEADER] =
                 `s-maxage=${remainingTtl}, stale-while-revalidate=2592000`;
         }
     }
-    if (headers[CommonHeaders.NEXT_CACHE] !== "STALE")
+    if (headers[NEXTJS_CACHE_HEADER] !== "STALE")
         return;
     // If the cache is stale, we revalidate in the background
     // In order for CloudFront SWR to work, we set the stale-while-revalidate value to 2 seconds
     // This will cause CloudFront to cache the stale data for a short period of time while we revalidate in the background
     // Once the revalidation is complete, CloudFront will serve the fresh data
-    headers[CommonHeaders.CACHE_CONTROL] =
-        "s-maxage=2, stale-while-revalidate=2592000";
+    headers[CACHE_CONTROL_HEADER] = "s-maxage=2, stale-while-revalidate=2592000";
 }
 /**
  *
@@ -361,9 +361,8 @@ export function createServerResponse(routingResult, headers, responseStream) {
 export async function invalidateCDNOnRequest(params, headers) {
     const { internalEvent, resolvedRoutes, initialURL } = params;
     const initialPath = new URL(initialURL).pathname;
-    const isIsrRevalidation = internalEvent.headers["x-isr"] === "1";
-    if (!isIsrRevalidation &&
-        headers[CommonHeaders.NEXT_CACHE] === "REVALIDATED") {
+    const isIsrRevalidation = internalEvent.headers[ISR_HEADER] === "1";
+    if (!isIsrRevalidation && headers[NEXTJS_CACHE_HEADER] === "REVALIDATED") {
         await globalThis.cdnInvalidationHandler.invalidatePaths([
             {
                 initialPath,

package/dist/core/routingHandler.js

@@ -1,5 +1,6 @@
 import { BuildId, ConfigHeaders, NextConfig, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
 import { debug, error } from "../adapters/logger";
+import { NO_STORE_CACHE_CONTROL } from "../utils/cacheHeaders";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
@@ -169,7 +170,7 @@ export default async function routingHandler(event, { assetResolver }) {
                 url: constructNextUrl(eventOrResult.url, "/404"),
                 headers: {
                     ...eventOrResult.headers,
-                    "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+                    "x-middleware-response-cache-control": NO_STORE_CACHE_CONTROL,
                 },
             };
         }

package/dist/http/openNextResponse.js

@@ -1,5 +1,6 @@
 import { Transform } from "node:stream";
 import { debug } from "../adapters/logger";
+import { fixCacheControlForError } from "../utils/cacheHeaders";
 import { parseHeaders, parseSetCookieHeader } from "./util";
 const SET_COOKIE_HEADER = "set-cookie";
 const CANNOT_BE_USED = "This cannot be used in OpenNext";
@@ -327,16 +328,8 @@ export class OpenNextNodeResponse extends Transform {
     // For some reason, next returns the 500 error page with some cache-control headers
     // We need to fix that
     fixHeadersForError() {
-        if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
-            return;
-        }
-        // We only check for 404 and 500 errors
-        // The rest should be errors that are handled by the user and they should set the cache headers themselves
-        if (this.statusCode === 404 || this.statusCode === 500) {
-            // For some reason calling this.setHeader("Cache-Control", "no-cache, no-store, must-revalidate") does not work here
-            // The function is not even called, i'm probably missing something obvious
-            this.headers["cache-control"] =
-                "private, no-cache, no-store, max-age=0, must-revalidate";
-        }
+        // NOTE: this assigns to `this.headers` directly rather than going through
+        // `this.setHeader()`, because for some reason `setHeader` is not even called from here.
+        fixCacheControlForError(this.headers, this.statusCode);
     }
 }

package/dist/overrides/queue/direct.js

@@ -1,3 +1,4 @@
+import { ISR_HEADER, PRERENDER_REVALIDATE_HEADER } from "../../utils/cacheHeaders.js";
 const queue = {
     name: "dev-queue",
     send: async (message) => {
@@ -9,8 +10,8 @@ const queue = {
         await globalThis.internalFetch(`${protocol}://${host}${url}`, {
             method: "HEAD",
             headers: {
-                "x-prerender-revalidate": revalidateId,
-                "x-isr": "1",
+                [PRERENDER_REVALIDATE_HEADER]: revalidateId,
+                [ISR_HEADER]: "1",
             },
         });
     },

package/dist/types/cache.d.ts

@@ -40,7 +40,7 @@ interface IncrementalCachedPageValue {
 interface IncrementalCachedAppPageValue {
     kind: "APP_PAGE";
     html: string;
-    rscData: Buffer;
+    rscData: Buffer | undefined;
     headers?: Record<string, undefined | string | string[]>;
     postponed?: string;
     status?: number;

package/dist/types/overrides.d.ts

@@ -34,13 +34,35 @@ export type CachedFile = {
     meta?: Meta;
 } | {
     type: "page";
-    html: string;
+    /** Absent when the build did not collect an `.html` file for this entry. */
+    html?: string;
     json: Object;
     meta?: Meta;
 } | {
     type: "app";
-    html: string;
-    rsc: string;
+    /**
+     * The prerendered HTML.
+     *
+     * Absent when the build did not collect an `.html` file for this entry. Note that
+     * Next.js writes the `.html` unconditionally when it prerenders an app page, so this
+     * is only expected to be absent for a malformed build output. A PPR route with an
+     * empty static shell is *not* one of those cases: the file is written, empty.
+     */
+    html?: string;
+    /**
+     * The RSC payload.
+     *
+     * Both `<page>.rsc` and `<page>.prefetch.rsc` are stored here, see `createAssets`.
+     *
+     * Absent when the build emitted neither file, which depends on the Next.js version:
+     * - `15.x`: only for fallback shells. A PPR route emits a `.prefetch.rsc` in place of
+     *   its `.rsc`, so the field is set but holds the *prefetch* payload, which this type
+     *   can not distinguish from a full one.
+     * - `>= 16.2`: `.prefetch.rsc` no longer exists and a PPR route only emits a `.rsc`
+     *   when it is fully static, so the field is absent for postponed PPR routes and for
+     *   fallback shells, and holds a full payload otherwise.
+     */
+    rsc?: string;
     meta?: Meta;
     segmentData?: Record<string, string>;
 } | {

package/dist/utils/cache.d.ts

@@ -9,6 +9,21 @@ import type { CacheValue, NextModeTagCacheWriteInput, OriginalTagCacheWriteInput
  * In this case, the cache entry is still valid and can be served, but it should trigger a background revalidation to update the cache.
  */
 export declare function isStale(key: string, tags: string[], lastModified?: number): Promise<boolean>;
+/**
+ * Next.js has no explicit way for a cache handler to report an entry as stale,
+ * the only lever we have is the `lastModified` we hand back to the incremental cache.
+ *
+ * Up to Next 16.2 we return `1` (i.e. right after the epoch), which is enough for Next to
+ * compute `revalidateAfter` in the past and mark the entry as stale.
+ * Starting with Next 16.3 the incremental cache also compares `lastModified + expire` to now, and
+ * forces a blocking revalidation (`isStale === -1`, surfacing as `x-nextjs-cache: REVALIDATED`)
+ * when that is in the past. An epoch based value always trips that check, so from that version on
+ * we go back just far enough for the entry to be stale while remaining inside its expire window.
+ *
+ * @param revalidate The revalidate value stored alongside the cache entry, in seconds
+ * @returns The `lastModified` to report to Next.js for a stale entry
+ */
+export declare function getStaleLastModified(revalidate?: number | false): number;
 /**
  * @param key The key for that specific cache entry
  * @param tags Array of tags associated with that cache entry

package/dist/utils/cache.js

@@ -1,4 +1,5 @@
 import { debug } from "../adapters/logger";
+import { CACHE_TAGS_HEADER } from "./cacheHeaders";
 import { compareSemver } from "./semver";
 /**
  *
@@ -24,6 +25,34 @@ export async function isStale(key, tags, lastModified) {
     }
     return (await globalThis.tagCache.isStale?.(key, lastModified)) ?? false;
 }
+/**
+ * Next.js has no explicit way for a cache handler to report an entry as stale,
+ * the only lever we have is the `lastModified` we hand back to the incremental cache.
+ *
+ * Up to Next 16.2 we return `1` (i.e. right after the epoch), which is enough for Next to
+ * compute `revalidateAfter` in the past and mark the entry as stale.
+ * Starting with Next 16.3 the incremental cache also compares `lastModified + expire` to now, and
+ * forces a blocking revalidation (`isStale === -1`, surfacing as `x-nextjs-cache: REVALIDATED`)
+ * when that is in the past. An epoch based value always trips that check, so from that version on
+ * we go back just far enough for the entry to be stale while remaining inside its expire window.
+ *
+ * @param revalidate The revalidate value stored alongside the cache entry, in seconds
+ * @returns The `lastModified` to report to Next.js for a stale entry
+ */
+export function getStaleLastModified(revalidate) {
+    // The `expire` check only exists from Next 16.3, before that the sentinel is what Next expects.
+    if (!compareSemver(globalThis.nextVersion, ">=", "16.3.0")) {
+        return 1;
+    }
+    if (typeof revalidate !== "number") {
+        // Without a revalidate value Next cannot derive an expire time either,
+        // so the historical sentinel is still safe here.
+        return 1;
+    }
+    // 1ms past the revalidate window. `expire` is always >= `revalidate`, so the entry is
+    // stale without being expired (when both are equal, being expired is the correct outcome).
+    return Date.now() - revalidate * 1000 - 1;
+}
 /**
  * @param key The key for that specific cache entry
  * @param tags Array of tags associated with that cache entry
@@ -62,8 +91,8 @@ export function getTagsFromValue(value) {
     }
     // The try catch is necessary for older version of next.js that may fail on this
     try {
-        const cacheTags = value.meta?.headers?.["x-next-cache-tags"]?.split(",") ?? [];
-        delete value.meta?.headers?.["x-next-cache-tags"];
+        const cacheTags = value.meta?.headers?.[CACHE_TAGS_HEADER]?.split(",") ?? [];
+        delete value.meta?.headers?.[CACHE_TAGS_HEADER];
         return cacheTags;
     }
     catch (e) {

package/dist/utils/cacheHeaders.d.ts

@@ -0,0 +1,52 @@
+import type { OutgoingHttpHeaders } from "node:http";
+/**
+ * The name of the `cache-control` response header.
+ */
+export declare const CACHE_CONTROL_HEADER = "cache-control";
+/**
+ * The name of the header Next.js uses to report the cache status of a response.
+ */
+export declare const NEXTJS_CACHE_HEADER = "x-nextjs-cache";
+/**
+ * The name of the header OpenNext uses to report the cache status of a response
+ * served by the cache interceptor.
+ */
+export declare const OPEN_NEXT_CACHE_HEADER = "x-opennext-cache";
+/**
+ * The name of the header Next.js uses to store the tags of a cache entry.
+ *
+ * Note that `types/cache.ts` repeats the literal, on purpose: it is a types only
+ * module and importing a value into it would give it a runtime dependency.
+ */
+export declare const CACHE_TAGS_HEADER = "x-next-cache-tags";
+/**
+ * The name of the header OpenNext uses to mark a request as an ISR revalidation.
+ */
+export declare const ISR_HEADER = "x-isr";
+/**
+ * The name of the header Next.js uses to authorize a revalidation request.
+ *
+ * Carries the preview mode id from the prerender manifest.
+ */
+export declare const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+/**
+ * The `cache-control` OpenNext forces on error responses so that they are never cached.
+ */
+export declare const NO_STORE_CACHE_CONTROL = "private, no-cache, no-store, max-age=0, must-revalidate";
+/**
+ * Overrides `cache-control` on error responses so that they are not cached.
+ *
+ * Next.js attaches cacheable `cache-control` headers to some error responses, and it writes
+ * `notFound()` results for ISR routes to the incremental cache. Without this the CDN would hold
+ * on to a 404 or a 500 - a transient one, such as a row that is not replicated yet, would stay
+ * at the edge for as long as the route's revalidate period, up to a year for an SSG route.
+ *
+ * Only 404 and 500 are overridden. Any other error status is assumed to be produced by the
+ * application, which is then responsible for setting its own cache headers.
+ *
+ * Set `OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS=true` to opt out and keep the original headers.
+ *
+ * @param headers The response headers, mutated in place
+ * @param statusCode The status code of the response
+ */
+export declare function fixCacheControlForError(headers: OutgoingHttpHeaders | Record<string, string | string[]>, statusCode: number): void;

package/dist/utils/cacheHeaders.js

@@ -0,0 +1,58 @@
+/**
+ * The name of the `cache-control` response header.
+ */
+export const CACHE_CONTROL_HEADER = "cache-control";
+/**
+ * The name of the header Next.js uses to report the cache status of a response.
+ */
+export const NEXTJS_CACHE_HEADER = "x-nextjs-cache";
+/**
+ * The name of the header OpenNext uses to report the cache status of a response
+ * served by the cache interceptor.
+ */
+export const OPEN_NEXT_CACHE_HEADER = "x-opennext-cache";
+/**
+ * The name of the header Next.js uses to store the tags of a cache entry.
+ *
+ * Note that `types/cache.ts` repeats the literal, on purpose: it is a types only
+ * module and importing a value into it would give it a runtime dependency.
+ */
+export const CACHE_TAGS_HEADER = "x-next-cache-tags";
+/**
+ * The name of the header OpenNext uses to mark a request as an ISR revalidation.
+ */
+export const ISR_HEADER = "x-isr";
+/**
+ * The name of the header Next.js uses to authorize a revalidation request.
+ *
+ * Carries the preview mode id from the prerender manifest.
+ */
+export const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+/**
+ * The `cache-control` OpenNext forces on error responses so that they are never cached.
+ */
+export const NO_STORE_CACHE_CONTROL = "private, no-cache, no-store, max-age=0, must-revalidate";
+/**
+ * Overrides `cache-control` on error responses so that they are not cached.
+ *
+ * Next.js attaches cacheable `cache-control` headers to some error responses, and it writes
+ * `notFound()` results for ISR routes to the incremental cache. Without this the CDN would hold
+ * on to a 404 or a 500 - a transient one, such as a row that is not replicated yet, would stay
+ * at the edge for as long as the route's revalidate period, up to a year for an SSG route.
+ *
+ * Only 404 and 500 are overridden. Any other error status is assumed to be produced by the
+ * application, which is then responsible for setting its own cache headers.
+ *
+ * Set `OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS=true` to opt out and keep the original headers.
+ *
+ * @param headers The response headers, mutated in place
+ * @param statusCode The status code of the response
+ */
+export function fixCacheControlForError(headers, statusCode) {
+    if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
+        return;
+    }
+    if (statusCode === 404 || statusCode === 500) {
+        headers[CACHE_CONTROL_HEADER] = NO_STORE_CACHE_CONTROL;
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -56,11 +56,12 @@
     "@types/express": "5.0.0",
     "@types/node": "20.17.6",
     "concurrently": "^9.2.1",
+    "next": "16.3.3",
     "tsc-alias": "^1.8.16",
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "next": ">=15.5.21 <16 || >=16.2.11"
+    "next": ">=15.5.24 <16 || >=16.3.3"
   },
   "bugs": {
     "url": "https://github.com/opennextjs/opennextjs-aws/issues"