@opennextjs/aws 4.1.5 → 4.1.7

package/dist/adapters/cache.d.ts

@@ -11,6 +11,7 @@ export default class Cache {
     getFetchCache(key: string, softTags?: string[], tags?: string[]): Promise<CacheHandlerValue | null>;
     getIncrementalCache(key: string): Promise<CacheHandlerValue | null>;
     set(key: string, data?: IncrementalCacheValue, ctx?: IncrementalCacheContext): Promise<void>;
+    private writeCache;
     revalidateTag(tags: string | string[], durations?: {
         expire?: number;
     }): Promise<void>;

package/dist/adapters/cache.js

@@ -1,6 +1,7 @@
 import { getStaleLastModified, getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
 import { CACHE_TAGS_HEADER } from "../utils/cacheHeaders";
+import { getPathFromRouteCacheKey } from "../utils/routeCacheKey";
 import { compareSemver } from "../utils/semver";
 import { debug, error, warn } from "./logger";
 export const SOFT_TAG_PREFIX = "_N_T_/";
@@ -195,11 +196,18 @@ export default class Cache {
         if (globalThis.openNextConfig.dangerous?.disableIncrementalCache) {
             return;
         }
-        // This one might not even be necessary anymore
-        // Better be safe than sorry
-        const detachedPromise = globalThis.__openNextAls
-            .getStore()
-            ?.pendingPromiseRunner.withResolvers();
+        const store = globalThis.__openNextAls.getStore();
+        const writePromise = this.writeCache(key, data, ctx);
+        // Next.js ignores the value returned by `set`, so the write is registered on the request's
+        // pending promise runner instead of being awaited. `FETCH` writes are awaited: Next.js runs
+        // them in a detached chain of its own that only covers the write while `set` waits for it.
+        if (data?.kind === "FETCH" || store === undefined) {
+            await writePromise;
+            return;
+        }
+        store.pendingPromiseRunner.add(writePromise);
+    }
+    async writeCache(key, data, ctx) {
         try {
             if (data === null || data === undefined) {
                 await globalThis.incrementalCache.delete(key);
@@ -292,10 +300,6 @@ export default class Cache {
         catch (e) {
             error("Failed to set cache", e);
         }
-        finally {
-            // We need to resolve the promise even if there was an error
-            detachedPromise?.resolve();
-        }
     }
     async revalidateTag(tags, durations) {
         const config = globalThis.openNextConfig.dangerous;
@@ -331,7 +335,8 @@ export default class Cache {
                 if (paths.length > 0) {
                     // TODO: we should introduce a new method in cdnInvalidationHandler to invalidate paths by tags for cdn that supports it
                     // It also means that we'll need to provide the tags used in every request to the wrapper or converter.
-                    await globalThis.cdnInvalidationHandler.invalidatePaths(paths.map((path) => ({
+                    // Fixed Next.js releases store route-scoped cache keys in the tag cache.
+                    await globalThis.cdnInvalidationHandler.invalidatePaths(paths.map(getPathFromRouteCacheKey).map((path) => ({
                         initialPath: path,
                         rawPath: path,
                         resolvedRoutes: [
@@ -405,7 +410,8 @@ export default class Cache {
                 const uniquePaths = Array.from(new Set(toInsert
                     // We need to filter fetch cache key as they are not in the CDN
                     .filter((t) => t.tag.startsWith(SOFT_TAG_PREFIX))
-                    .map((t) => `/${t.path}`)));
+                    // Fixed Next.js releases store route-scoped cache keys in the tag cache.
+                    .map((t) => getPathFromRouteCacheKey(`/${t.path}`))));
                 if (uniquePaths.length > 0) {
                     await globalThis.cdnInvalidationHandler.invalidatePaths(uniquePaths.map((path) => ({
                         initialPath: path,

package/dist/build/createAssets.js

@@ -5,6 +5,7 @@ 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 { useRouteCacheKeys } from "../utils/routeCacheKey.js";
 import * as buildHelper from "./helper.js";
 /**
  * Copy the static assets to the output folder
@@ -84,7 +85,7 @@ export function createCacheAssets(options) {
         relativePath.endsWith(".segment.rsc") ||
         (relativePath.endsWith(".html") && htmlPages.has(relativePath));
     // Merge cache files into a single file
-    const cacheFilesPath = {};
+    const cacheArtifacts = {};
     // Process each source directory
     sourceDirs.forEach((sourceDir) => {
         buildHelper.traverseFiles(sourceDir, ({ relativePath }) => !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
@@ -102,14 +103,18 @@ export function createCacheAssets(options) {
                     //
                     // 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)
+                    const legacyKey = relativePath
+                        .slice(0, -ext.length)
                         .replace(/\.prefetch$/, "")
-                        .concat(".cache");
-                    cacheFilesPath[newFilePath] = {
-                        [ext.slice(1)]: absolutePath,
-                        ...cacheFilesPath[newFilePath],
+                        .split(path.sep)
+                        .join(path.posix.sep);
+                    const artifactId = `${sourceDir}:${legacyKey}`;
+                    const existingArtifact = cacheArtifacts[artifactId];
+                    const fileType = ext.slice(1);
+                    cacheArtifacts[artifactId] = {
+                        ...existingArtifact,
+                        legacyKey,
+                        [fileType]: existingArtifact?.[fileType] ?? absolutePath,
                     };
                     break;
                 }
@@ -121,11 +126,21 @@ export function createCacheAssets(options) {
             }
         });
     });
+    const metaFiles = [];
     // Generate cache file
-    Object.entries(cacheFilesPath).forEach(([cacheFilePath, files]) => {
+    Object.values(cacheArtifacts).forEach(({ legacyKey, ...files }) => {
         const cacheFileMeta = files.meta
-            ? safeParseJsonFile(fs.readFileSync(files.meta, "utf8"), cacheFilePath)
+            ? safeParseJsonFile(fs.readFileSync(files.meta, "utf8"), files.meta)
             : undefined;
+        const cacheKey = useRouteCacheKeys(options.nextVersion) && cacheFileMeta?.routeCache?.key
+            ? cacheFileMeta.routeCache.key.replace(/^[/\\]+/, "")
+            : legacyKey;
+        const outputRoot = path.resolve(outputCachePath);
+        const cacheFilePath = path.resolve(outputRoot, `${cacheKey}.cache`);
+        if (!cacheFilePath.startsWith(`${outputRoot}${path.sep}`)) {
+            logger.warn(`Cache key resolves outside the cache output: ${cacheKey}`);
+            return;
+        }
         const cacheJson = files.json
             ? safeParseJsonFile(fs.readFileSync(files.json, "utf8"), cacheFilePath)
             : undefined;
@@ -159,9 +174,19 @@ export function createCacheAssets(options) {
         // Ensure directory exists before writing
         fs.mkdirSync(path.dirname(cacheFilePath), { recursive: true });
         fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
+        if (!options.config.dangerous?.disableTagCache &&
+            cacheFileMeta?.headers?.[CACHE_TAGS_HEADER]) {
+            cacheFileMeta.headers[CACHE_TAGS_HEADER]
+                .split(",")
+                .forEach((tag) => {
+                metaFiles.push({
+                    tag: { S: path.posix.join(buildId, tag.trim()) },
+                    path: { S: path.posix.join(buildId, cacheKey) },
+                    revalidatedAt: { N: "1" },
+                });
+            });
+        }
     });
-    // We need to traverse the cache to find every .meta file
-    const metaFiles = [];
     // Copy fetch-cache to cache folder
     const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
     if (fs.existsSync(fetchCachePath)) {
@@ -183,29 +208,6 @@ export function createCacheAssets(options) {
         });
     }
     if (!options.config.dangerous?.disableTagCache) {
-        // Compute dynamodb cache data
-        // Traverse files inside cache to find all meta files and cache tags associated with them
-        sourceDirs.forEach((sourceDir) => {
-            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?.[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
-                        metaFiles.push({
-                            tag: { S: path.posix.join(buildId, tag.trim()) },
-                            path: {
-                                S: path.posix.join(buildId, relativePath.replace(".meta", "")),
-                            },
-                            // We don't care about the revalidation time here, we just need to make sure it's there
-                            revalidatedAt: { N: "1" },
-                        });
-                    });
-                }
-            });
-        });
         if (metaFiles.length > 0) {
             useTagCache = true;
             const providerPath = path.join(outputDir, "dynamodb-provider");

package/dist/build/createServerBundle.js

@@ -168,6 +168,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                     ? ["experimentalIncrementalCacheHandler"]
                     : ["stableIncrementalCache"]),
                 ...(isAfter152 ? [] : ["composableCache"]),
+                ...(isAfter152 ? [] : ["topLevelComposableCache"]),
             ],
         }),
         openNextResolvePlugin({

package/dist/build/patch/patches/patchBackgroundRevalidation.d.ts

@@ -1,4 +1,4 @@
-export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        regex: \"!cachedResponse.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
+export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        pattern: \"!$ENTRY.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
 export declare const patchBackgroundRevalidation: {
     name: string;
     patches: {

package/dist/build/patch/patches/patchBackgroundRevalidation.js

@@ -6,7 +6,7 @@ rule:
   all:
     - has:
         kind: unary_expression
-        regex: "!cachedResponse.isStale"
+        pattern: "!$ENTRY.isStale"
     -  has:
          kind: member_expression
          regex: "context.isPrefetch"

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

@@ -1,2 +1,2 @@
-import type { InternalEvent, InternalResult, MiddlewareEvent } from "../../types/open-next";
-export declare function cacheInterceptor(event: MiddlewareEvent): Promise<InternalEvent | InternalResult>;
+import type { InternalEvent, InternalResult, MiddlewareEvent, ResolvedRoute } from "../../types/open-next";
+export declare function cacheInterceptor(event: MiddlewareEvent, resolvedRoutes?: ResolvedRoute[]): Promise<InternalEvent | InternalResult>;

package/dist/core/routing/cacheInterceptor.js

@@ -1,12 +1,14 @@
 import { createHash } from "node:crypto";
-import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
+import { AppPathsManifest, NextConfig, PagesManifest, PrerenderManifest, } from "../../adapters/config/index";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { isBinaryContentType } from "../../utils/binary";
 import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache";
 import { CACHE_CONTROL_HEADER, NO_STORE_CACHE_CONTROL, OPEN_NEXT_CACHE_HEADER, PRERENDER_REVALIDATE_HEADER, fixCacheControlForError, } from "../../utils/cacheHeaders";
+import { getDynamicRouteCachePathname, getPrerenderRouteCacheKey, getRouteCacheKey, getRouteCacheOwner, useRouteCacheKeys, } from "../../utils/routeCacheKey";
 import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
 import { generateMessageGroupId } from "./queue";
+import { dynamicRouteMatcher } from "./routeMatcher";
 const CACHE_ONE_YEAR = 60 * 60 * 24 * 365;
 const CACHE_ONE_MONTH = 60 * 60 * 24 * 30;
 /*
@@ -22,7 +24,7 @@ const VARY_HEADER = "RSC, Next-Router-State-Tree, Next-Router-Prefetch, Next-Rou
 const NEXT_SEGMENT_PREFETCH_HEADER = "next-router-segment-prefetch";
 const NEXT_PRERENDER_HEADER = "x-nextjs-prerender";
 const NEXT_POSTPONED_HEADER = "x-nextjs-postponed";
-async function computeCacheControl(path, body, host, revalidate, lastModified, isStaleFromTagCache = false) {
+async function computeCacheControl(path, body, host, revalidate, lastModified, isStaleFromTagCache = false, revalidationPath = path, revalidationKey = path) {
     let finalRevalidate = CACHE_ONE_YEAR;
     const existingRoute = Object.entries(PrerenderManifest?.routes ?? {}).find((p) => p[0] === path)?.[1];
     if (revalidate === undefined && existingRoute) {
@@ -64,7 +66,9 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
             isStaleFromTagCache,
         });
         if (isStale) {
-            let url = NextConfig.trailingSlash ? `${path}/` : path;
+            let url = NextConfig.trailingSlash && revalidationPath !== "/"
+                ? `${revalidationPath}/`
+                : revalidationPath;
             if (NextConfig.basePath) {
                 url = `${NextConfig.basePath}${url}`;
             }
@@ -75,8 +79,8 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
                     eTag: etag,
                     lastModified: lastModified ?? Date.now(),
                 },
-                MessageDeduplicationId: hash(`${path}-${lastModified}-${etag}`),
-                MessageGroupId: generateMessageGroupId(path),
+                MessageDeduplicationId: hash(`${revalidationKey}-${lastModified}-${etag}`),
+                MessageGroupId: generateMessageGroupId(revalidationKey),
             });
         }
         return {
@@ -104,18 +108,33 @@ function getBodyForAppRouter(event, cachedValue) {
     if (cachedValue.type !== "app") {
         throw new Error("getBodyForAppRouter called with non-app cache value");
     }
-    const segmentHeader = `${event.headers[NEXT_SEGMENT_PREFETCH_HEADER]}`;
-    const isSegmentResponse = Boolean(segmentHeader) &&
-        segmentHeader in (cachedValue.segmentData || {}) &&
-        !NextConfig.experimental?.prefetchInlining;
-    if (isSegmentResponse) {
-        return {
-            body: cachedValue.segmentData[segmentHeader],
-            additionalHeaders: {
-                [NEXT_PRERENDER_HEADER]: "1",
-                [NEXT_POSTPONED_HEADER]: "2",
-            },
-        };
+    const segmentHeader = event.headers[NEXT_SEGMENT_PREFETCH_HEADER];
+    // A request from the client Segment Cache has to be answered with the segment it asked
+    // for. The full page payload is not a different-but-valid answer: the router never
+    // records the prefetch as satisfied and re-requests it forever.
+    // This mirrors how Next serves a cached app page - see the `segmentPrefetchHeader`
+    // branch of `packages/next/src/build/templates/app-page.ts`, which responds with the
+    // matching segment or an empty 404, and never with the full page.
+    //
+    // `experimental.prefetchInlining` is deliberately not consulted. Next normalizes every
+    // truthy value - including the 16.2+ default - into `{ maxSize, maxBundleSize }`, so it
+    // must never be read as a flag. More importantly it has no say here: inlining only
+    // changes *which* segments the build emits (an emitted segment then being a bundle that
+    // already holds its inlined ancestors), and `segmentData` holds exactly the segments
+    // that were emitted, which is exactly the set the router asks for.
+    if (typeof segmentHeader === "string" && cachedValue.segmentData) {
+        if (Object.hasOwn(cachedValue.segmentData, segmentHeader)) {
+            return {
+                body: cachedValue.segmentData[segmentHeader],
+                additionalHeaders: {
+                    [NEXT_PRERENDER_HEADER]: "1",
+                    [NEXT_POSTPONED_HEADER]: "2",
+                },
+            };
+        }
+        // The entry holds segments, but not this one. Next answers with an empty 404 here -
+        // let the server do that rather than serving a payload of a different shape.
+        return undefined;
     }
     // `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`.
@@ -138,7 +157,7 @@ function getBodyForAppRouter(event, cachedValue) {
  * 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) {
+async function generateResult(event, localizedPath, cachedValue, lastModified, isStaleFromTagCache = false, cacheKey = localizedPath, revalidationPath = localizedPath) {
     debug("Returning result from experimental cache");
     let body;
     let type = "application/octet-stream";
@@ -170,7 +189,7 @@ async function generateResult(event, localizedPath, cachedValue, lastModified, i
         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);
+    const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified, isStaleFromTagCache, revalidationPath, cacheKey);
     const statusCode = computeStatusCode(event.rewriteStatusCode, cachedValue.meta?.status);
     const headers = {
         ...cacheControl,
@@ -232,10 +251,83 @@ function decodePathParams(pathname) {
         .map((segment) => escapePathDelimiters(decodeURIComponent(segment), true))
         .join("/");
 }
-export async function cacheInterceptor(event) {
+let routeCacheManifests;
+function getRouteCacheManifests() {
+    routeCacheManifests ??= {
+        prerenderManifest: {
+            routes: PrerenderManifest?.routes ?? {},
+            dynamicRoutes: PrerenderManifest?.dynamicRoutes ?? {},
+        },
+        appPaths: Object.keys(AppPathsManifest ?? {}),
+        pagesManifest: PagesManifest ?? {},
+        locales: NextConfig.i18n?.locales,
+    };
+    return routeCacheManifests;
+}
+/**
+ * Computes the key of the cache entry serving the request.
+ *
+ * Next.js 15.5.27 and 16.3.8 scope the key by the route owning the entry. It is computed from:
+ * - the prerender manifest for prerendered routes,
+ * - the dynamic route Next.js would render for entries cached at runtime.
+ *
+ * @param event The incoming event
+ * @param localizedPath The localized and decoded path, without basePath nor trailing slash
+ * @param resolvedRoutes Ordered route matches for the final internal pathname
+ * @returns The cache key, or `undefined` when the path is not served by an ISR route
+ */
+function getCacheKey(event, localizedPath, resolvedRoutes) {
+    if (!useRouteCacheKeys(globalThis.nextVersion)) {
+        const isISR = Object.keys(PrerenderManifest?.routes ?? {}).includes(localizedPath) ||
+            Object.values(PrerenderManifest?.dynamicRoutes ?? {}).some((dr) => new RegExp(dr.routeRegex).test(localizedPath));
+        // The route is keyed as `/` in the prerender manifest, but the generated
+        // cache asset for the index route is uploaded as `/index`.
+        if (!isISR)
+            return undefined;
+        return localizedPath === "/" ? "/index" : localizedPath;
+    }
+    const manifests = getRouteCacheManifests();
+    if (Object.hasOwn(manifests.prerenderManifest.routes, localizedPath)) {
+        const manifestKey = getPrerenderRouteCacheKey(localizedPath, manifests);
+        const selectedRoute = resolvedRoutes?.[0];
+        // The routing handler always supplies matches. An empty list there means
+        // ownership could not be proven and scoped interception must fail closed.
+        if (resolvedRoutes && !selectedRoute)
+            return undefined;
+        if (!selectedRoute)
+            return manifestKey;
+        const selectedOwner = getRouteCacheOwner(selectedRoute.route, manifests);
+        if (!selectedOwner)
+            return undefined;
+        const selectedKey = getRouteCacheKey(localizedPath, selectedOwner);
+        return selectedKey === manifestKey ? manifestKey : undefined;
+    }
+    // Not prerendered, the entry might have been cached at runtime by a dynamic route.
+    // Dynamic routes are sorted by specificity, the first match is the one Next.js renders.
+    const dynamicRoute = resolvedRoutes
+        ? resolvedRoutes[0]
+        : dynamicRouteMatcher(event.rawPath)[0];
+    const dynamicPrerender = dynamicRoute
+        ? manifests.prerenderManifest.dynamicRoutes[dynamicRoute.route]
+        : undefined;
+    if (!dynamicRoute ||
+        !dynamicPrerender ||
+        dynamicPrerender.fallback !== null) {
+        return undefined;
+    }
+    const owner = getRouteCacheOwner(dynamicRoute.route, manifests);
+    return owner
+        ? getRouteCacheKey(getDynamicRouteCachePathname(localizedPath, manifests.locales), owner)
+        : undefined;
+}
+export async function cacheInterceptor(event, resolvedRoutes) {
     if (Boolean(event.headers["next-action"]) ||
         Boolean(event.headers[PRERENDER_REVALIDATE_HEADER]))
         return event;
+    // Only GET and HEAD can be answered from the cache. A form posted without
+    // JavaScript carries its server action id in the body, not in the next-action header.
+    if (event.method !== "GET" && event.method !== "HEAD")
+        return event;
     // Check for Next.js preview mode cookies
     const cookies = event.headers.cookie || "";
     const hasPreviewData = cookies.includes("__prerender_bypass") ||
@@ -244,14 +336,21 @@ export async function cacheInterceptor(event) {
         debug("Preview mode detected, passing through to handler");
         return event;
     }
-    // We localize the path in case i18n is enabled
-    let localizedPath = localizePath(event);
-    // If using basePath we need to remove it from the path
-    if (NextConfig.basePath) {
-        localizedPath = localizedPath.replace(NextConfig.basePath, "");
-    }
+    const basePath = NextConfig.basePath;
+    const pathWithoutBasePath = !basePath
+        ? event.rawPath
+        : event.rawPath === basePath
+            ? "/"
+            : event.rawPath.startsWith(`${basePath}/`)
+                ? event.rawPath.slice(basePath.length)
+                : event.rawPath;
+    // Locale detection must inspect the first segment after basePath.
+    let localizedPath = localizePath({ ...event, rawPath: pathWithoutBasePath });
     // We also need to remove trailing slash
     localizedPath = localizedPath.replace(/\/$/, "");
+    // Revalidation must request the original encoded spelling so route selection
+    // cannot switch from an encoded catch-all to a more specific canonical route.
+    const revalidationPath = localizedPath || "/";
     // Then we decode the path params
     try {
         localizedPath = decodePathParams(localizedPath) || "/";
@@ -261,14 +360,10 @@ export async function cacheInterceptor(event) {
         // partially decode the path and select a different route identity.
         return event;
     }
-    // The route is keyed as `/` in the prerender manifest, but the generated
-    // cache asset for the app index route is uploaded as `/index`.
-    const cacheKey = localizedPath === "/" ? "/index" : localizedPath;
     debug("Checking cache for", localizedPath, PrerenderManifest);
-    const isISR = Object.keys(PrerenderManifest?.routes ?? {}).includes(localizedPath) ||
-        Object.values(PrerenderManifest?.dynamicRoutes ?? {}).some((dr) => new RegExp(dr.routeRegex).test(localizedPath));
-    debug("isISR", isISR);
-    if (isISR) {
+    const cacheKey = getCacheKey(event, localizedPath, resolvedRoutes);
+    debug("cacheKey", cacheKey);
+    if (cacheKey) {
         try {
             const cachedData = await globalThis.incrementalCache.get(cacheKey);
             debug("cached data in interceptor", cachedData);
@@ -294,12 +389,12 @@ export async function cacheInterceptor(event) {
             switch (cachedData?.value?.type) {
                 case "app":
                 case "page": {
-                    const result = await generateResult(event, localizedPath, cachedData.value, cachedData.lastModified, _isStale);
+                    const result = await generateResult(event, localizedPath, cachedData.value, cachedData.lastModified, _isStale, cacheKey, revalidationPath);
                     // 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);
+                    const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified, _isStale, revalidationPath, cacheKey);
                     return {
                         type: "core",
                         statusCode: cachedData.value.meta?.status ?? 307,
@@ -313,7 +408,7 @@ export async function cacheInterceptor(event) {
                     };
                 }
                 case "route": {
-                    const cacheControl = await computeCacheControl(localizedPath, cachedData.value.body, host, cachedData.value.revalidate, cachedData.lastModified, _isStale);
+                    const cacheControl = await computeCacheControl(localizedPath, cachedData.value.body, host, cachedData.value.revalidate, cachedData.lastModified, _isStale, revalidationPath, cacheKey);
                     const isBinary = isBinaryContentType(String(cachedData.value.meta?.headers?.["content-type"]));
                     const statusCode = computeStatusCode(event.rewriteStatusCode, cachedData.value.meta?.status);
                     const headers = {

package/dist/core/routing/matcher.js

@@ -123,7 +123,8 @@ export function handleRewrites(event, rewrites) {
         const pathToUse = rewrite.locale === false ? rawPath : localizedRawPath;
         debug("urlParts", { pathname, protocol, hostname, queryString });
         const toDestinationPath = compile(escapeRegex(pathname, { isPath: true }));
-        const toDestinationHost = compile(escapeRegex(hostname));
+        // A literal numeric port is URL syntax, not a path-to-regexp parameter.
+        const toDestinationHost = compile(escapeRegex(hostname).replace(/:(\d+)$/, "\\:$1"));
         const toDestinationQuery = compile(escapeRegex(queryString));
         const params = {
             // params for the source

package/dist/core/routingHandler.js

@@ -157,6 +157,12 @@ export default async function routingHandler(event, { assetResolver }) {
         }
         const isNextImageRoute = eventOrResult.rawPath.startsWith("/_next/image");
         const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
+        // Resolve against the final internal pathname after every rewrite phase.
+        // These ordered matches are also the authoritative cache owner candidates.
+        const resolvedRoutes = [
+            ...staticRouteMatcher(eventOrResult.rawPath),
+            ...dynamicRouteMatcher(eventOrResult.rawPath),
+        ];
         // If we still haven't found a route, we show the 404 page
         // We need to ensure that rewrites are applied before showing the 404 page
         if (!(isRouteFoundBeforeAllRewrites ||
@@ -175,9 +181,10 @@ export default async function routingHandler(event, { assetResolver }) {
             };
         }
         if (globalThis.openNextConfig.dangerous?.enableCacheInterception &&
+            !isExternalRewrite &&
             !isInternalResult(eventOrResult)) {
             debug("Cache interception enabled");
-            eventOrResult = await cacheInterceptor(eventOrResult);
+            eventOrResult = await cacheInterceptor(eventOrResult, resolvedRoutes);
             if (isInternalResult(eventOrResult)) {
                 applyMiddlewareHeaders(eventOrResult, headers);
                 return eventOrResult;
@@ -185,10 +192,6 @@ export default async function routingHandler(event, { assetResolver }) {
         }
         // We apply the headers from the middleware response last
         applyMiddlewareHeaders(eventOrResult, headers);
-        const resolvedRoutes = [
-            ...foundStaticRoute,
-            ...foundDynamicRoute,
-        ];
         debug("resolvedRoutes", resolvedRoutes);
         return {
             internalEvent: eventOrResult,

package/dist/core/util.js

@@ -33,6 +33,19 @@ const nextServer = new NextServer.default({
         cacheHandler: cacheHandlerPath,
         cacheMaxMemorySize: 0, // We need to disable memory cache
         //#endOverride
+        // Next.js 16 promoted `cacheHandlers` out of `experimental` to a top-level
+        // config key. At runtime `route-module.js#loadCustomCacheHandlers` reads
+        // `nextConfig.cacheHandlers` (top-level) — the nested `experimental` copy
+        // below is ignored on Next >= 16, so the composable ("use cache") handler
+        // must also be registered here or Next falls back to its in-memory default
+        // and composable entries never reach the incremental cache override.
+        // Older Next versions ignore this unknown top-level key and read the
+        // `experimental` copy instead; setting both is safe across versions.
+        //#override topLevelComposableCache
+        cacheHandlers: {
+            default: composableCacheHandlerPath,
+        },
+        //#endOverride
         experimental: {
             ...NextConfig.experimental,
             // This uses the request.headers.host as the URL

package/dist/overrides/incrementalCache/fs-dev.js

@@ -2,24 +2,49 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const buildId = process.env.OPEN_NEXT_BUILD_ID;
-const basePath = path.join(getMonorepoRelativePath(), `cache/${buildId}`);
-const getCacheKey = (key) => {
-    return path.join(basePath, `${key}.cache`);
+const basePath = path.join(getMonorepoRelativePath(), "cache");
+/**
+ * Resolves a cache entry using the same layout as the build's cache assets.
+ *
+ * @param key The cache entry key
+ * @param cacheType The cache namespace, defaulting to the page/route cache
+ * @returns The file path for the entry
+ */
+const getCacheKey = (key, cacheType = "cache") => {
+    return path.join(basePath, cacheType === "fetch" ? "__fetch" : "", `${buildId}`, cacheType === "fetch" ? key : `${key}.${cacheType}`);
 };
 const cache = {
     name: "fs-dev",
-    get: async (key) => {
-        const fileData = await fs.readFile(getCacheKey(key), "utf-8");
+    /**
+     * Reads an entry from the selected cache namespace.
+     *
+     * @param key The cache entry key
+     * @param cacheType The cache namespace, defaulting to the page/route cache
+     * @returns The cached value and its last modification time
+     * @throws When the entry cannot be read or contains invalid JSON
+     */
+    get: async (key, cacheType) => {
+        const cacheKey = getCacheKey(key, cacheType);
+        const fileData = await fs.readFile(cacheKey, "utf-8");
         const data = JSON.parse(fileData);
-        const { mtime } = await fs.stat(getCacheKey(key));
+        const { mtime } = await fs.stat(cacheKey);
         return {
             value: data,
             lastModified: mtime.getTime(),
         };
     },
-    set: async (key, value, isFetch) => {
+    /**
+     * Writes an entry to the selected cache namespace.
+     *
+     * @param key The cache entry key
+     * @param value The value to persist
+     * @param cacheType The cache namespace, defaulting to the page/route cache
+     * @returns A promise that resolves when the entry has been written
+     * @throws When serialization or a file system operation fails
+     */
+    set: async (key, value, cacheType) => {
         const data = JSON.stringify(value);
-        const cacheKey = getCacheKey(key);
+        const cacheKey = getCacheKey(key, cacheType);
         // We need to create the directory before writing the file
         await fs.mkdir(path.dirname(cacheKey), { recursive: true });
         await fs.writeFile(cacheKey, data);

package/dist/overrides/queue/sqs-lite.js

@@ -29,21 +29,33 @@ const awsFetch = (body) => {
 };
 const queue = {
     send: async ({ MessageBody, MessageDeduplicationId, MessageGroupId }) => {
-        try {
-            const { REVALIDATION_QUEUE_URL } = process.env;
-            const result = await awsFetch(JSON.stringify({
-                QueueUrl: REVALIDATION_QUEUE_URL,
-                MessageBody: JSON.stringify(MessageBody),
-                MessageDeduplicationId,
-                MessageGroupId,
-            }));
-            if (result.status !== 200) {
-                throw new RecoverableError(`Failed to send message: ${result.status}`);
+        const send = (async () => {
+            try {
+                const { REVALIDATION_QUEUE_URL } = process.env;
+                const result = await awsFetch(JSON.stringify({
+                    QueueUrl: REVALIDATION_QUEUE_URL,
+                    MessageBody: JSON.stringify(MessageBody),
+                    MessageDeduplicationId,
+                    MessageGroupId,
+                }));
+                if (result.status !== 200) {
+                    throw new RecoverableError(`Failed to send message: ${result.status}`);
+                }
             }
+            catch (e) {
+                error(e);
+            }
+        })();
+        // Enqueuing revalidation should not block the response. When the wrapper
+        // provides a `waitUntil`, hand the send to it and return immediately so the
+        // SQS round trip runs after the body is flushed; otherwise (edge, or a
+        // wrapper without `waitUntil`) fall back to awaiting it inline.
+        const waitUntil = globalThis.__openNextAls.getStore()?.waitUntil;
+        if (waitUntil) {
+            waitUntil(send);
+            return;
         }
-        catch (e) {
-            error(e);
-        }
+        await send;
     },
     name: "sqs",
 };

package/dist/overrides/queue/sqs.js

@@ -8,12 +8,24 @@ const sqsClient = new SQSClient({
 });
 const queue = {
     send: async ({ MessageBody, MessageDeduplicationId, MessageGroupId }) => {
-        await sqsClient.send(new SendMessageCommand({
+        const send = sqsClient
+            .send(new SendMessageCommand({
             QueueUrl: REVALIDATION_QUEUE_URL,
             MessageBody: JSON.stringify(MessageBody),
             MessageDeduplicationId,
             MessageGroupId,
-        }));
+        }))
+            .then(() => undefined);
+        // Enqueuing revalidation should not block the response. When the wrapper
+        // provides a `waitUntil`, hand the send to it and return immediately so the
+        // SQS round trip runs after the body is flushed; otherwise (edge, or a
+        // wrapper without `waitUntil`) fall back to awaiting it inline.
+        const waitUntil = globalThis.__openNextAls.getStore()?.waitUntil;
+        if (waitUntil) {
+            waitUntil(send);
+            return;
+        }
+        await send;
     },
     name: "sqs",
 };

package/dist/overrides/wrappers/aws-apigw-streaming.js

@@ -1,5 +1,6 @@
 import { Readable } from "node:stream";
 import { debug } from "../../adapters/logger";
+import { DetachedPromiseRunner } from "../../utils/promise";
 function formatWarmerResponse(event) {
     const result = new Promise((resolve) => {
         setTimeout(() => {
@@ -42,6 +43,15 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
         debug(err);
         responseStream.end();
     });
+    // AWS provides no native `waitUntil`, so back it with the shared
+    // `DetachedPromiseRunner`, which tracks the deferred promises and awaits
+    // (and logs the failures of) them before the stream closes. This keeps
+    // the Lambda alive for deferred work (background revalidation, cache
+    // write-through) that starts after the response body is sent — matching
+    // the `waitUntil` the Cloudflare wrappers pass through, and enabling the
+    // `withWaitUntil` route preloading that otherwise falls back to `none`.
+    const promiseRunner = new DetachedPromiseRunner();
+    const waitUntil = (promise) => promiseRunner.add(promise);
     const streamCreator = {
         writeHeaders: (_prelude) => {
             // No content-encoding header — API Gateway streaming does not
@@ -55,7 +65,10 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             return responseStream;
         },
     };
-    const response = await handler(internalEvent, { streamCreator });
+    const response = await handler(internalEvent, {
+        streamCreator,
+        waitUntil,
+    });
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;
     if (isUsingEdge) {
         debug("Headers has not been set, we must be in the edge runtime");
@@ -66,6 +79,8 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
         });
         Readable.fromWeb(response.body).pipe(stream);
     }
+    // Keep the invocation alive until deferred `waitUntil` work settles.
+    await promiseRunner.await();
 });
 export default {
     wrapper: handler,

package/dist/overrides/wrappers/aws-lambda-streaming.js

@@ -1,6 +1,7 @@
 import { Readable } from "node:stream";
 import zlib from "node:zlib";
 import { debug, error } from "../../adapters/logger";
+import { DetachedPromiseRunner } from "../../utils/promise";
 function formatWarmerResponse(event) {
     const result = new Promise((resolve) => {
         setTimeout(() => {
@@ -64,7 +65,19 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             return compressedStream ?? responseStream;
         },
     };
-    const response = await handler(internalEvent, { streamCreator });
+    // AWS provides no native `waitUntil`, so back it with the shared
+    // `DetachedPromiseRunner`, which tracks the deferred promises and awaits
+    // (and logs the failures of) them before the stream closes. This keeps
+    // the Lambda alive for deferred work (background revalidation, cache
+    // write-through) that starts after the response body is sent — matching
+    // the `waitUntil` the Cloudflare wrappers pass through, and enabling the
+    // `withWaitUntil` route preloading that otherwise falls back to `none`.
+    const promiseRunner = new DetachedPromiseRunner();
+    const waitUntil = (promise) => promiseRunner.add(promise);
+    const response = await handler(internalEvent, {
+        streamCreator,
+        waitUntil,
+    });
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;
     if (isUsingEdge) {
         debug("Headers has not been set, we must be in the edge runtime");
@@ -75,6 +88,8 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
         });
         Readable.fromWeb(response.body).pipe(stream);
     }
+    // Keep the invocation alive until deferred `waitUntil` work settles.
+    await promiseRunner.await();
     // return converter.convertTo(response);
 });
 export default {

package/dist/types/next-types.d.ts

@@ -73,7 +73,10 @@ export interface NextConfig {
         serverActions?: boolean;
         appDir?: boolean;
         optimizeCss?: boolean;
-        prefetchInlining?: boolean;
+        prefetchInlining?: boolean | {
+            maxSize: number;
+            maxBundleSize: number;
+        };
     };
     images: ImageConfig;
     poweredByHeader?: boolean;
@@ -148,11 +151,14 @@ export interface MiddlewareManifest {
 export interface PrerenderManifest {
     routes: Record<string, {
         initialRevalidateSeconds: number | false;
+        srcRoute?: string | null;
+        dataRoute?: string | null;
     }>;
     dynamicRoutes: {
         [route: string]: {
             routeRegex: string;
             fallback: string | false | null;
+            fallbackSourceRoute?: string;
             dataRouteRegex: string;
         };
     };

package/dist/utils/promise.js

@@ -61,13 +61,17 @@ function provideNextAfterProvider() {
     // This is needed by some lib that relies on the vercel request context to properly await stuff.
     // Remove this when vercel builder is updated to provide '@next/request-context'.
     const VERCEL_REQUEST_CONTEXT_SYMBOL = Symbol.for("@vercel/request-context");
-    const store = globalThis.__openNextAls.getStore();
-    const waitUntil = store?.waitUntil ??
-        ((promise) => store?.pendingPromiseRunner.add(promise));
+    // `get` resolves the store on every call rather than capturing it here: the
+    // object is published on `globalThis`, which every request in the isolate
+    // shares, so a captured store could belong to a different request.
     const nextAfterContext = {
-        get: () => ({
-            waitUntil,
-        }),
+        get: () => {
+            const store = globalThis.__openNextAls.getStore();
+            return {
+                waitUntil: store?.waitUntil ??
+                    ((promise) => store?.pendingPromiseRunner.add(promise)),
+            };
+        },
     };
     //@ts-expect-error
     globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = nextAfterContext;

package/dist/utils/routeCacheKey.d.ts

@@ -0,0 +1,124 @@
+import type { PrerenderManifest } from "../types/next-types.js";
+/**
+ * Next.js 15.5.27 and 16.3.8 introduced response cache keys scoped by the route
+ * owning each pages, app page, or app route entry:
+ * `/route-cache/<kind>/<sha256(sourceRoute)>/$<normalizedPathname>`.
+ *
+ * The helpers below mirror Next.js so that the build time cache population and the cache
+ * interceptor compute the exact same key Next.js uses when reading and writing the cache.
+ * https://github.com/vercel/next.js/blob/v16.3.8/packages/next/src/server/lib/route-cache-key.ts
+ */
+export type RouteCacheKind = "PAGES" | "APP_PAGE" | "APP_ROUTE";
+export interface RouteCacheOwner {
+    kind: RouteCacheKind;
+    /**
+     * The page pathname for the pages router (i.e. `/blog/[slug]`).
+     * The app entry for the app router (i.e. `/(group)/blog/[slug]/page`).
+     */
+    sourceRoute: string;
+}
+export interface RouteCacheManifests {
+    prerenderManifest: Pick<PrerenderManifest, "routes" | "dynamicRoutes">;
+    /** The keys of the app paths manifest */
+    appPaths: string[];
+    pagesManifest: Record<string, string>;
+    /** The i18n locales */
+    locales?: string[];
+}
+/**
+ * Whether the Next.js version uses scoped route cache keys.
+ *
+ * @param nextVersion The Next.js version
+ */
+export declare function useRouteCacheKeys(nextVersion: string): boolean;
+/**
+ * Mirrors `normalizePagePath` from Next.js.
+ *
+ * @example
+ *     normalizePagePath("/") === "/index"
+ *     normalizePagePath("/index/foo") === "/index/index/foo"
+ */
+export declare function normalizePagePath(page: string): string;
+/**
+ * Mirrors `denormalizePagePath` from Next.js, the inverse of `normalizePagePath`.
+ *
+ * @example
+ *     denormalizePagePath("/index") === "/"
+ *     denormalizePagePath("/index/index/foo") === "/index/foo"
+ */
+export declare function denormalizePagePath(page: string): string;
+/**
+ * Mirrors `normalizeAppPath` from Next.js: removes groups, parallel slots and the leaf
+ * `page`/`route` segment from an app entry.
+ *
+ * @example
+ *     normalizeAppPath("/(group)/@modal/blog/[slug]/page") === "/blog/[slug]"
+ */
+export declare function normalizeAppPath(entry: string): string;
+/**
+ * Mirrors `selectAppPageEntry` from Next.js: selects the app entry rendering `route`,
+ * a route can have multiple entries when it uses parallel routes.
+ *
+ * @param route The route, i.e. `/blog/[slug]`
+ * @param appPaths The keys of the app paths manifest
+ * @returns The app entry, or `undefined` when no entry renders the route
+ */
+export declare function selectAppPageEntry(route: string, appPaths: string[]): string | undefined;
+/**
+ * Computes the owner of the cache entries for a route.
+ *
+ * @param sourceRoute The route owning the entry, i.e. `/blog/[slug]`
+ * @param manifests.appPaths The keys of the app paths manifest
+ * @param manifests.pagesManifest The pages manifest
+ * @returns The owner, or `undefined` when the route is not handled by an app entry nor a page
+ */
+export declare function getRouteCacheOwner(sourceRoute: string, { appPaths, pagesManifest, }: {
+    appPaths: string[];
+    pagesManifest: Record<string, string>;
+}): RouteCacheOwner | undefined;
+/**
+ * Mirrors `normalizeLocalePath` from Next.js: removes the locale prefix from a pathname.
+ *
+ * @example
+ *     normalizeLocalePath("/en/isr", ["en", "fr"]) === "/isr"
+ *     normalizeLocalePath("/en", ["en", "fr"]) === "/"
+ */
+export declare function normalizeLocalePath(pathname: string, locales?: string[]): string;
+/**
+ * Mirrors how Next.js resolves the cache pathname of a dynamic route: a route resolving to
+ * `/index` (i.e. a root catch-all rendering `/index`) is cached as `/`, or as `/<locale>` with i18n.
+ *
+ * @example
+ *     getDynamicRouteCachePathname("/index") === "/"
+ *     getDynamicRouteCachePathname("/en/index", ["en", "fr"]) === "/en"
+ *
+ * @param pathname The localized pathname, i.e. `/en/blog/hello` with i18n
+ * @param locales The i18n locales
+ */
+export declare function getDynamicRouteCachePathname(pathname: string, locales?: string[]): string;
+/**
+ * Computes the cache key of an entry from the prerender manifest, i.e. a prerendered
+ * route (`routes`) or a fallback shell (`dynamicRoutes`).
+ *
+ * @param pathname The pathname of the entry, as keyed in the prerender manifest
+ * @param manifests The manifests used to compute the owner
+ * @returns The cache key, or `undefined` when the pathname is not in the prerender manifest
+ * or when its owner could not be found.
+ */
+export declare function getPrerenderRouteCacheKey(pathname: string, manifests: RouteCacheManifests): string | undefined;
+/**
+ * Mirrors `getRouteCacheKey` from Next.js.
+ *
+ * @param pathname The pathname of the entry, i.e. `/blog/hello` (`/en/blog/hello` with i18n)
+ * @param owner The owner of the entry
+ * @returns The cache key, i.e. `/route-cache/APP_PAGE/<sha256>/$/blog/hello`
+ */
+export declare function getRouteCacheKey(pathname: string, owner: RouteCacheOwner): string;
+/**
+ * Returns the normalized pathname of a route cache key, i.e. `/blog/hello` for
+ * `/route-cache/APP_PAGE/<sha256>/$/blog/hello`.
+ * Keys that are not route cache keys are returned unchanged.
+ *
+ * @param key The cache key, with or without the leading `/`
+ */
+export declare function getPathFromRouteCacheKey(key: string): string;

package/dist/utils/routeCacheKey.js

@@ -0,0 +1,210 @@
+import { createHash } from "node:crypto";
+import { compareSemver } from "./semver.js";
+const ROUTE_CACHE_DIRECTORY = "route-cache";
+const ROUTE_CACHE_KEY_PREFIX = /^\/?route-cache\/(?:PAGES|APP_PAGE|APP_ROUTE)\/[0-9a-f]{64}\/\$(?=\/)/;
+const DYNAMIC_ROUTE_REGEX = /\/\[[^/]+?\](?=\/|$)/;
+/**
+ * Whether the Next.js version uses scoped route cache keys.
+ *
+ * @param nextVersion The Next.js version
+ */
+export function useRouteCacheKeys(nextVersion) {
+    return ((compareSemver(nextVersion, ">=", "15.5.27") &&
+        compareSemver(nextVersion, "<", "16.0.0")) ||
+        compareSemver(nextVersion, ">=", "16.3.8"));
+}
+/**
+ * Mirrors `normalizePagePath` from Next.js.
+ *
+ * @example
+ *     normalizePagePath("/") === "/index"
+ *     normalizePagePath("/index/foo") === "/index/index/foo"
+ */
+export function normalizePagePath(page) {
+    if (/^\/index(\/|$)/.test(page) && !DYNAMIC_ROUTE_REGEX.test(page)) {
+        return `/index${page}`;
+    }
+    if (page === "/") {
+        return "/index";
+    }
+    return page.startsWith("/") ? page : `/${page}`;
+}
+/**
+ * Mirrors `denormalizePagePath` from Next.js, the inverse of `normalizePagePath`.
+ *
+ * @example
+ *     denormalizePagePath("/index") === "/"
+ *     denormalizePagePath("/index/index/foo") === "/index/foo"
+ */
+export function denormalizePagePath(page) {
+    if (page.startsWith("/index/") && !DYNAMIC_ROUTE_REGEX.test(page)) {
+        return page.slice(6);
+    }
+    return page === "/index" ? "/" : page;
+}
+/**
+ * Mirrors `normalizeAppPath` from Next.js: removes groups, parallel slots and the leaf
+ * `page`/`route` segment from an app entry.
+ *
+ * @example
+ *     normalizeAppPath("/(group)/@modal/blog/[slug]/page") === "/blog/[slug]"
+ */
+export function normalizeAppPath(entry) {
+    const pathname = entry.split("/").reduce((acc, segment, index, segments) => {
+        if (!segment)
+            return acc;
+        // Groups are ignored.
+        if (segment.startsWith("(") && segment.endsWith(")"))
+            return acc;
+        // Parallel segments are ignored.
+        if (segment.startsWith("@"))
+            return acc;
+        // The last segment (if it's a leaf) is ignored.
+        if ((segment === "page" || segment === "route") &&
+            index === segments.length - 1) {
+            return acc;
+        }
+        return `${acc}/${segment}`;
+    }, "");
+    return pathname === "" ? "/" : pathname;
+}
+function compareAppPaths(a, b) {
+    const aHasSlot = a.includes("/@");
+    const bHasSlot = b.includes("/@");
+    if (aHasSlot && !bHasSlot)
+        return -1;
+    if (!aHasSlot && bHasSlot)
+        return 1;
+    return a.localeCompare(b);
+}
+/**
+ * Mirrors `selectAppPageEntry` from Next.js: selects the app entry rendering `route`,
+ * a route can have multiple entries when it uses parallel routes.
+ *
+ * @param route The route, i.e. `/blog/[slug]`
+ * @param appPaths The keys of the app paths manifest
+ * @returns The app entry, or `undefined` when no entry renders the route
+ */
+export function selectAppPageEntry(route, appPaths) {
+    let entry;
+    for (const appPath of appPaths) {
+        if (normalizeAppPath(appPath).replace(/%5F/g, "_") !== route)
+            continue;
+        if (entry === undefined || compareAppPaths(entry, appPath) < 0) {
+            entry = appPath;
+        }
+    }
+    return entry;
+}
+/**
+ * Computes the owner of the cache entries for a route.
+ *
+ * @param sourceRoute The route owning the entry, i.e. `/blog/[slug]`
+ * @param manifests.appPaths The keys of the app paths manifest
+ * @param manifests.pagesManifest The pages manifest
+ * @returns The owner, or `undefined` when the route is not handled by an app entry nor a page
+ */
+export function getRouteCacheOwner(sourceRoute, { appPaths, pagesManifest, }) {
+    const appEntry = selectAppPageEntry(sourceRoute, appPaths);
+    if (appEntry) {
+        return {
+            kind: appEntry.endsWith("/route") ? "APP_ROUTE" : "APP_PAGE",
+            sourceRoute: appEntry,
+        };
+    }
+    if (Object.hasOwn(pagesManifest, sourceRoute)) {
+        return { kind: "PAGES", sourceRoute };
+    }
+    return undefined;
+}
+/**
+ * Mirrors `normalizeLocalePath` from Next.js: removes the locale prefix from a pathname.
+ *
+ * @example
+ *     normalizeLocalePath("/en/isr", ["en", "fr"]) === "/isr"
+ *     normalizeLocalePath("/en", ["en", "fr"]) === "/"
+ */
+export function normalizeLocalePath(pathname, locales) {
+    const segment = pathname.split("/", 2)[1]?.toLowerCase();
+    const locale = locales?.find((l) => l.toLowerCase() === segment);
+    if (!locale) {
+        return pathname;
+    }
+    return pathname.slice(locale.length + 1) || "/";
+}
+/**
+ * Mirrors how Next.js resolves the cache pathname of a dynamic route: a route resolving to
+ * `/index` (i.e. a root catch-all rendering `/index`) is cached as `/`, or as `/<locale>` with i18n.
+ *
+ * @example
+ *     getDynamicRouteCachePathname("/index") === "/"
+ *     getDynamicRouteCachePathname("/en/index", ["en", "fr"]) === "/en"
+ *
+ * @param pathname The localized pathname, i.e. `/en/blog/hello` with i18n
+ * @param locales The i18n locales
+ */
+export function getDynamicRouteCachePathname(pathname, locales) {
+    if (normalizeLocalePath(pathname, locales) !== "/index") {
+        return pathname;
+    }
+    return pathname.slice(0, -"/index".length) || "/";
+}
+/**
+ * Computes the cache key of an entry from the prerender manifest, i.e. a prerendered
+ * route (`routes`) or a fallback shell (`dynamicRoutes`).
+ *
+ * @param pathname The pathname of the entry, as keyed in the prerender manifest
+ * @param manifests The manifests used to compute the owner
+ * @returns The cache key, or `undefined` when the pathname is not in the prerender manifest
+ * or when its owner could not be found.
+ */
+export function getPrerenderRouteCacheKey(pathname, manifests) {
+    const { routes, dynamicRoutes } = manifests.prerenderManifest;
+    const prerender = Object.hasOwn(routes, pathname)
+        ? routes[pathname]
+        : undefined;
+    const fallback = !prerender && Object.hasOwn(dynamicRoutes, pathname)
+        ? dynamicRoutes[pathname]
+        : undefined;
+    if (!prerender && !fallback) {
+        return undefined;
+    }
+    const sourceRoute = prerender
+        ? prerender.srcRoute
+        : (fallback?.fallbackSourceRoute ?? pathname);
+    let owner;
+    if (sourceRoute) {
+        owner = getRouteCacheOwner(sourceRoute, manifests);
+    }
+    else {
+        // Static routes have no `srcRoute`, the pathname is the route.
+        // Pages routes are localized while the page itself is not.
+        owner = getRouteCacheOwner(pathname, manifests);
+        if (!owner && manifests.locales?.length) {
+            const pagesOwner = getRouteCacheOwner(normalizeLocalePath(pathname, manifests.locales), manifests);
+            owner = pagesOwner?.kind === "PAGES" ? pagesOwner : undefined;
+        }
+    }
+    return owner ? getRouteCacheKey(pathname, owner) : undefined;
+}
+/**
+ * Mirrors `getRouteCacheKey` from Next.js.
+ *
+ * @param pathname The pathname of the entry, i.e. `/blog/hello` (`/en/blog/hello` with i18n)
+ * @param owner The owner of the entry
+ * @returns The cache key, i.e. `/route-cache/APP_PAGE/<sha256>/$/blog/hello`
+ */
+export function getRouteCacheKey(pathname, owner) {
+    const source = createHash("sha256").update(owner.sourceRoute).digest("hex");
+    return `/${ROUTE_CACHE_DIRECTORY}/${owner.kind}/${source}/$${normalizePagePath(pathname)}`;
+}
+/**
+ * Returns the normalized pathname of a route cache key, i.e. `/blog/hello` for
+ * `/route-cache/APP_PAGE/<sha256>/$/blog/hello`.
+ * Keys that are not route cache keys are returned unchanged.
+ *
+ * @param key The cache key, with or without the leading `/`
+ */
+export function getPathFromRouteCacheKey(key) {
+    return key.replace(ROUTE_CACHE_KEY_PREFIX, "");
+}

package/package.json

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