af360 0.1.14 → 0.1.16

package/dist/node_modules/next/dist/server/lib/incremental-cache/index.js

@@ -20,11 +20,10 @@ _export(exports, {
         return IncrementalCache;
     }
 });
+const _routecachekey = require("../route-cache-key");
 const _responsecache = require("../../response-cache");
 const _filesystemcache = /*#__PURE__*/ _interop_require_default(require("./file-system-cache"));
-const _normalizepagepath = require("../../../shared/lib/page-path/normalize-page-path");
 const _constants = require("../../../lib/constants");
-const _toroute = require("../to-route");
 const _sharedcachecontrolsexternal = require("./shared-cache-controls.external");
 const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
 const _invarianterror = require("../../../shared/lib/invariant-error");
@@ -88,7 +87,7 @@ async function hashString(cacheString) {
 const MAIN_KEY_PREFIX = 'v4';
 class IncrementalCache {
     static #_ = this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE;
-    constructor({ fs, dev, flushToDisk, minimalMode, serverDistDir, requestHeaders, maxMemoryCacheSize, getPrerenderManifest, fetchCacheKeyPrefix, CurCacheHandler, allowedRevalidateHeaderKeys }){
+    constructor({ fs, dev, flushToDisk, minimalMode, serverDistDir, requestHeaders, maxMemoryCacheSize, getPrerenderManifest, fetchCacheKeyPrefix, CurCacheHandler, allowedRevalidateHeaderKeys, locales }){
         var _this_prerenderManifest_preview, _this_prerenderManifest;
         this.locks = new Map();
         this.hasCustomCacheHandler = Boolean(CurCacheHandler);
@@ -123,7 +122,8 @@ class IncrementalCache {
         this.requestHeaders = requestHeaders;
         this.allowedRevalidateHeaderKeys = allowedRevalidateHeaderKeys;
         this.prerenderManifest = getPrerenderManifest();
-        this.cacheControls = new _sharedcachecontrolsexternal.SharedCacheControls(this.prerenderManifest);
+        this.locales = locales;
+        this.cacheControls = new _sharedcachecontrolsexternal.SharedCacheControls(this.prerenderManifest, locales);
         this.fetchCacheKeyPrefix = fetchCacheKeyPrefix;
         let revalidatedTags = [];
         if (requestHeaders[_constants.PRERENDER_REVALIDATE_HEADER] === ((_this_prerenderManifest = this.prerenderManifest) == null ? void 0 : (_this_prerenderManifest_preview = _this_prerenderManifest.preview) == null ? void 0 : _this_prerenderManifest_preview.previewModeId)) {
@@ -146,20 +146,16 @@ class IncrementalCache {
             });
         }
     }
-    calculateRevalidate(pathname, fromTime, dev, isFallback) {
+    calculateRevalidate(cacheControl, fromTime, dev, isFallback) {
         // in development we don't have a prerender-manifest
         // and default to always revalidating to allow easier debugging
         if (dev) return Math.floor(performance.timeOrigin + performance.now() - 1000);
-        const cacheControl = this.cacheControls.get((0, _toroute.toRoute)(pathname));
         // if an entry isn't present in routes we fallback to a default
         // of revalidating after 1 second unless it's a fallback request.
         const initialRevalidateSeconds = cacheControl ? cacheControl.revalidate : isFallback ? false : 1;
         const revalidateAfter = typeof initialRevalidateSeconds === 'number' ? initialRevalidateSeconds * 1000 + fromTime : initialRevalidateSeconds;
         return revalidateAfter;
     }
-    _getPathname(pathname, fetchCache) {
-        return fetchCache ? pathname : (0, _normalizepagepath.normalizePagePath)(pathname);
-    }
     resetRequestCache() {
         var _this_cacheHandler_resetRequestCache, _this_cacheHandler;
         (_this_cacheHandler = this.cacheHandler) == null ? void 0 : (_this_cacheHandler_resetRequestCache = _this_cacheHandler.resetRequestCache) == null ? void 0 : _this_cacheHandler_resetRequestCache.call(_this_cacheHandler);
@@ -303,6 +299,9 @@ class IncrementalCache {
     }
     async get(cacheKey, ctx) {
         var _this_cacheHandler, _cacheData_value;
+        if (ctx.kind === _responsecache.IncrementalCacheKind.IMAGE) {
+            throw new _invarianterror.InvariantError('Images must use the image optimizer cache');
+        }
         // Unlike other caches if we have a resume data cache, we use it even if
         // testmode would normally disable it or if requestHeaders say 'no-cache'.
         if (ctx.kind === _responsecache.IncrementalCacheKind.FETCH) {
@@ -323,8 +322,16 @@ class IncrementalCache {
         if (this.disableForTestmode || this.dev && (ctx.kind !== _responsecache.IncrementalCacheKind.FETCH || this.requestHeaders['cache-control'] === 'no-cache')) {
             return null;
         }
-        cacheKey = this._getPathname(cacheKey, ctx.kind === _responsecache.IncrementalCacheKind.FETCH);
-        const cacheData = await ((_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.get(cacheKey, ctx));
+        let storageKey = cacheKey;
+        let handlerContext = ctx;
+        if (ctx.kind !== _responsecache.IncrementalCacheKind.FETCH) {
+            // Ownership scopes the key and metadata inside Next.js. Storage handlers
+            // only need the resulting key and the existing cache options.
+            const { route, ...responseContext } = ctx;
+            storageKey = (0, _routecachekey.getRouteCacheKey)(cacheKey, route);
+            handlerContext = responseContext;
+        }
+        const cacheData = await ((_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.get(storageKey, handlerContext));
         if (ctx.kind === _responsecache.IncrementalCacheKind.FETCH) {
             var _cacheData_value1;
             if (!cacheData) {
@@ -370,14 +377,14 @@ class IncrementalCache {
             });
         }
         let entry = null;
-        const cacheControl = this.cacheControls.get((0, _toroute.toRoute)(cacheKey));
+        const cacheControl = this.cacheControls.get(cacheKey, ctx.route);
         let isStale;
         let revalidateAfter;
         if ((cacheData == null ? void 0 : cacheData.lastModified) === -1) {
             isStale = -1;
             revalidateAfter = -1 * _constants.CACHE_ONE_YEAR;
         } else {
-            revalidateAfter = this.calculateRevalidate(cacheKey, (cacheData == null ? void 0 : cacheData.lastModified) || performance.timeOrigin + performance.now(), this.dev ?? false, ctx.isFallback);
+            revalidateAfter = this.calculateRevalidate(cacheControl, (cacheData == null ? void 0 : cacheData.lastModified) || performance.timeOrigin + performance.now(), this.dev ?? false, ctx.isFallback);
             isStale = revalidateAfter !== false && revalidateAfter < performance.timeOrigin + performance.now() ? true : undefined;
         }
         if (cacheData) {
@@ -388,7 +395,7 @@ class IncrementalCache {
                 value: cacheData.value
             };
         }
-        if (!cacheData && this.prerenderManifest.notFoundRoutes.includes(cacheKey)) {
+        if (!cacheData && this.prerenderManifest.notFoundRoutes.includes(cacheKey) && (0, _routecachekey.isRouteCacheOwner)(cacheKey, ctx.route, this.prerenderManifest.routes[cacheKey], this.locales)) {
             // for the first hit after starting the server the cache
             // may not have a way to save notFound: true so if
             // the prerender-manifest marks this as notFound then we
@@ -408,6 +415,9 @@ class IncrementalCache {
         return entry;
     }
     async set(pathname, data, ctx) {
+        if ('kind' in ctx && ctx.kind === _responsecache.IncrementalCacheKind.IMAGE) {
+            throw new _invarianterror.InvariantError('Images must use the image optimizer cache');
+        }
         // Even if we otherwise disable caching for testMode or if no fetchCache is
         // configured we still always stash results in the resume data cache if one
         // exists. This is because this is a transient in memory cache that
@@ -421,7 +431,16 @@ class IncrementalCache {
             }
         }
         if (this.disableForTestmode || this.dev && !ctx.fetchCache) return;
-        pathname = this._getPathname(pathname, ctx.fetchCache);
+        let storageKey = pathname;
+        let handlerContext = ctx;
+        if (!ctx.fetchCache) {
+            const { route, ...responseContext } = ctx;
+            if (!route) {
+                throw new _invarianterror.InvariantError('Response cache requires a source route');
+            }
+            storageKey = (0, _routecachekey.getRouteCacheKey)(pathname, route);
+            handlerContext = responseContext;
+        }
         // FetchCache has upper limit of 2MB per-entry currently
         const itemSize = JSON.stringify(data).length;
         if (ctx.fetchCache && itemSize > 2 * 1024 * 1024 && // We ignore the size limit when custom cache handler is being used, as it
@@ -443,9 +462,9 @@ class IncrementalCache {
         try {
             var _this_cacheHandler;
             if (!ctx.fetchCache && ctx.cacheControl) {
-                this.cacheControls.set((0, _toroute.toRoute)(pathname), ctx.cacheControl);
+                this.cacheControls.set(storageKey, ctx.cacheControl);
             }
-            await ((_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.set(pathname, data, ctx));
+            await ((_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.set(storageKey, data, handlerContext));
         } catch (error) {
             console.warn('Failed to update prerender cache for', pathname, error);
         }

package/dist/node_modules/next/dist/server/lib/incremental-cache/memory-cache.external.js

@@ -14,7 +14,7 @@ let memoryCache;
 function getMemoryCache(maxMemoryCacheSize) {
     if (!memoryCache) {
         memoryCache = new _lrucache.LRUCache(maxMemoryCacheSize, function length({ value }) {
-            var _JSON_stringify;
+            var _value_postponed, _JSON_stringify;
             if (!value) {
                 return 25;
             } else if (value.kind === _types.CachedRouteKind.REDIRECT) {
@@ -28,10 +28,10 @@ function getMemoryCache(maxMemoryCacheSize) {
             } else if (value.kind === _types.CachedRouteKind.FETCH) {
                 return JSON.stringify(value.data || '').length;
             } else if (value.kind === _types.CachedRouteKind.APP_ROUTE) {
-                return value.body.length;
+                return Math.max(1, value.body.length);
             }
             // rough estimate of size of cache value
-            return value.html.length + (((_JSON_stringify = JSON.stringify(value.kind === _types.CachedRouteKind.APP_PAGE ? value.rscData : value.pageData)) == null ? void 0 : _JSON_stringify.length) || 0);
+            return Math.max(1, (value.kind === _types.CachedRouteKind.APP_PAGE ? ((_value_postponed = value.postponed) == null ? void 0 : _value_postponed.length) || 0 : 0) + value.html.length + (((_JSON_stringify = JSON.stringify(value.kind === _types.CachedRouteKind.APP_PAGE ? value.rscData : value.pageData)) == null ? void 0 : _JSON_stringify.length) || 0));
         });
     }
     return memoryCache;

package/dist/node_modules/next/dist/server/lib/incremental-cache/shared-cache-controls.external.js

@@ -8,6 +8,9 @@ Object.defineProperty(exports, "SharedCacheControls", {
         return SharedCacheControls;
     }
 });
+const _routecachekey = require("../route-cache-key");
+const _normalizelocalepath = require("../../../shared/lib/i18n/normalize-locale-path");
+const _routekind = require("../../route-kind");
 class SharedCacheControls {
     static #_ = /**
    * The in-memory cache of cache lives for routes. This cache is populated when
@@ -16,8 +19,9 @@ class SharedCacheControls {
     constructor(/**
      * The prerender manifest that contains the initial cache controls for
      * routes.
-     */ prerenderManifest){
+     */ prerenderManifest, locales){
         this.prerenderManifest = prerenderManifest;
+        this.locales = locales;
     }
     /**
    * Try to get the cache control value for a route. This will first try to get
@@ -25,16 +29,17 @@ class SharedCacheControls {
    * in-memory cache, it will be sourced from the prerender manifest.
    *
    * @param route the route to get the cache control for
+   * @param owner the source route that owns the response
    * @returns the cache control for the route, or undefined if the values
    *          are not present in the in-memory cache or the prerender manifest
-   */ get(route) {
+   */ get(route, owner) {
         // This is a copy on write cache that is updated when the cache is updated.
         // If the cache is never written to, then the values will be sourced from
         // the prerender manifest.
-        let cacheControl = SharedCacheControls.cacheControls.get(route);
+        let cacheControl = SharedCacheControls.cacheControls.get((0, _routecachekey.getRouteCacheKey)(route, owner));
         if (cacheControl) return cacheControl;
         let prerenderData = this.prerenderManifest.routes[route];
-        if (prerenderData) {
+        if (prerenderData && (0, _routecachekey.isRouteCacheOwner)(route, owner, prerenderData, this.locales)) {
             const { initialRevalidateSeconds, initialExpireSeconds } = prerenderData;
             if (typeof initialRevalidateSeconds !== 'undefined') {
                 return {
@@ -43,8 +48,9 @@ class SharedCacheControls {
                 };
             }
         }
-        const dynamicPrerenderData = this.prerenderManifest.dynamicRoutes[route];
-        if (dynamicPrerenderData) {
+        const dynamicPathname = owner.kind === _routekind.RouteKind.PAGES ? (0, _normalizelocalepath.normalizeLocalePath)(route, this.locales).pathname : route;
+        const dynamicPrerenderData = this.prerenderManifest.dynamicRoutes[dynamicPathname];
+        if (dynamicPrerenderData && (0, _routecachekey.isRouteCacheOwner)(route, owner, dynamicPrerenderData, this.locales)) {
             const { fallbackRevalidate, fallbackExpire } = dynamicPrerenderData;
             if (typeof fallbackRevalidate !== 'undefined') {
                 return {
@@ -53,6 +59,8 @@ class SharedCacheControls {
                 };
             }
         }
+        // A new runtime pathname has no initial lifetime. Its own render supplies
+        // one instead of borrowing a sibling route's build-time metadata.
         return undefined;
     }
     /**

package/dist/node_modules/next/dist/server/lib/match-next-data-pathname.js

@@ -9,7 +9,9 @@ Object.defineProperty(exports, "matchNextDataPathname", {
     }
 });
 const _pathmatch = require("../../shared/lib/router/utils/path-match");
-const matcher = (0, _pathmatch.getPathMatch)('/_next/data/:path*');
+const matcher = (0, _pathmatch.getPathMatch)('/_next/data/:path*', {
+    sensitive: true
+});
 function matchNextDataPathname(pathname) {
     if (typeof pathname !== 'string') return false;
     return matcher(pathname);

package/dist/node_modules/next/dist/server/lib/node-fs-methods.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "nodeFs", {
     }
 });
 const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _nodecrypto = require("node:crypto");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -19,6 +20,19 @@ const nodeFs = {
     readFile: _fs.default.promises.readFile,
     readFileSync: _fs.default.readFileSync,
     writeFile: (f, d)=>_fs.default.promises.writeFile(f, d),
+    writeFileAtomic: async (f, d)=>{
+        const temporary = `${f}.${(0, _nodecrypto.randomUUID)()}.tmp`;
+        try {
+            await _fs.default.promises.writeFile(temporary, d);
+            await _fs.default.promises.link(temporary, f);
+            return true;
+        } catch (error) {
+            if (error.code === 'EEXIST') return false;
+            throw error;
+        } finally{
+            await _fs.default.promises.unlink(temporary).catch(()=>{});
+        }
+    },
     mkdir: (dir)=>_fs.default.promises.mkdir(dir, {
             recursive: true
         }),

package/dist/node_modules/next/dist/server/lib/route-cache-key.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ROUTE_CACHE_DIRECTORY: null,
+    getResponseCacheOwner: null,
+    getRouteCacheKey: null,
+    isRouteCacheOwner: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ROUTE_CACHE_DIRECTORY: function() {
+        return ROUTE_CACHE_DIRECTORY;
+    },
+    getResponseCacheOwner: function() {
+        return getResponseCacheOwner;
+    },
+    getRouteCacheKey: function() {
+        return getRouteCacheKey;
+    },
+    isRouteCacheOwner: function() {
+        return isRouteCacheOwner;
+    }
+});
+const _normalizepagepath = require("../../shared/lib/page-path/normalize-page-path");
+const _normalizelocalepath = require("../../shared/lib/i18n/normalize-locale-path");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _apppathnamenormalizer = require("../normalizers/built/app/app-pathname-normalizer");
+const _routekind = require("../route-kind");
+const ROUTE_CACHE_DIRECTORY = 'route-cache';
+const appPathnameNormalizer = new _apppathnamenormalizer.AppPathnameNormalizer();
+function getResponseCacheOwner(definition) {
+    return {
+        kind: definition.kind,
+        // Pages module names can include a trailing /index in Turbopack. Their
+        // pathname matches the manifest's source in both bundlers. App modules
+        // retain groups and parallel slots in their cache identity.
+        sourceRoute: definition.kind === _routekind.RouteKind.PAGES ? definition.pathname : definition.page
+    };
+}
+function isRouteCacheOwner(pathname, owner, prerender, locales) {
+    if (!prerender) {
+        return false;
+    }
+    // Pages have JSON data routes, App Pages have RSC data routes, and App
+    // Route Handlers have no separate data route.
+    const kind = prerender.dataRoute === null ? _routekind.RouteKind.APP_ROUTE : prerender.dataRoute.endsWith('.json') ? _routekind.RouteKind.PAGES : prerender.dataRoute.endsWith('.rsc') ? _routekind.RouteKind.APP_PAGE : undefined;
+    if (kind !== owner.kind) {
+        return false;
+    }
+    const source = 'srcRoute' in prerender ? prerender.srcRoute : prerender.fallbackSourceRoute;
+    const prerenderOwner = source ?? (kind === _routekind.RouteKind.PAGES ? (0, _normalizelocalepath.normalizeLocalePath)(pathname, locales).pathname : pathname);
+    return prerenderOwner === (kind === _routekind.RouteKind.PAGES ? owner.sourceRoute : appPathnameNormalizer.normalize(owner.sourceRoute));
+}
+function getRouteCacheKey(pathname, owner) {
+    if (!owner) {
+        throw new _invarianterror.InvariantError('Response cache requires a source route');
+    }
+    const { sourceRoute } = owner;
+    let source;
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        const sha256 = require('next/dist/compiled/hash.js/sha256');
+        source = sha256().update(new TextEncoder().encode(sourceRoute)).digest('hex');
+    } else {
+        const { createHash } = require('crypto');
+        source = createHash('sha256').update(sourceRoute).digest('hex');
+    }
+    return `/${ROUTE_CACHE_DIRECTORY}/${owner.kind}/${source}/$${(0, _normalizepagepath.normalizePagePath)(pathname)}`;
+}
+
+//# sourceMappingURL=route-cache-key.js.map

package/dist/node_modules/next/dist/server/lib/start-server.js

@@ -179,7 +179,7 @@ async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server
 async function startServer(serverOptions) {
     const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"15.5.21"})`;
+    process.title = `next-server (v${"15.5.27"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{

package/dist/node_modules/next/dist/server/next-server.js

@@ -510,7 +510,10 @@ class NextNodeServer extends _baseserver.default {
         }
         process.env.NEXT_DEPLOYMENT_ID = this.nextConfig.experimental.useSkewCookie ? '' : this.nextConfig.deploymentId || '';
         if (!this.minimalMode) {
-            this.imageResponseCache = new _responsecache.default(this.minimalMode);
+            this.imageResponseCache = new _responsecache.default({
+                minimalMode: this.minimalMode,
+                route: 'image'
+            });
         }
         const { appDocumentPreloading } = this.nextConfig.experimental;
         const isDefaultEnabled = typeof appDocumentPreloading === 'undefined';
@@ -658,6 +661,7 @@ class NextNodeServer extends _baseserver.default {
         }
     }
     async getIncrementalCache({ requestHeaders }) {
+        var _this_nextConfig_i18n;
         const dev = !!this.renderOpts.dev;
         let CacheHandler;
         const { cacheHandler } = this.nextConfig;
@@ -679,12 +683,10 @@ class NextNodeServer extends _baseserver.default {
             maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
             flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
             getPrerenderManifest: ()=>this.getPrerenderManifest(),
+            locales: (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales,
             CurCacheHandler: CacheHandler
         });
     }
-    getResponseCache() {
-        return new _responsecache.default(this.minimalMode);
-    }
     getPublicDir() {
         return (0, _path.join)(this.dir, _constants.CLIENT_PUBLIC_FILES_PATH);
     }
@@ -850,8 +852,8 @@ class NextNodeServer extends _baseserver.default {
             const isAppPath = Array.isArray(appPaths);
             let page = ctx.pathname;
             if (isAppPath) {
-                // When it's an array, we need to pass all parallel routes to the loader.
-                page = appPaths[0];
+                // Match the build owner while passing all parallel paths to the loader.
+                page = (0, _apppaths.selectAppPageEntry)(ctx.pathname, appPaths);
             }
             for (const edgeFunctionsPage of edgeFunctionsPages){
                 if (edgeFunctionsPage === page) {

package/dist/node_modules/next/dist/server/response-cache/index.js

@@ -9,12 +9,13 @@ Object.defineProperty(exports, "default", {
     }
 });
 0 && __export(require("./types"));
+const _types = _export_star(require("./types"), exports);
+const _invarianterror = require("../../shared/lib/invariant-error");
 const _batcher = require("../../lib/batcher");
 const _lrucache = require("../lib/lru-cache");
 const _log = require("../../build/output/log");
 const _scheduler = require("../../lib/scheduler");
 const _utils = require("./utils");
-_export_star(require("./types"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
@@ -74,7 +75,7 @@ function _export_star(from, to) {
     return invocationID === TTL_SENTINEL ? undefined : invocationID;
 }
 class ResponseCache {
-    constructor(minimal_mode, maxSize = DEFAULT_MAX_SIZE, ttl = DEFAULT_TTL_MS){
+    constructor({ minimalMode, route, maxSize = DEFAULT_MAX_SIZE, ttl = DEFAULT_TTL_MS }){
         this.batcher = _batcher.Batcher.create({
             // Ensure on-demand revalidate doesn't block normal requests, it should be
             // safe to run an on-demand revalidate for the same key as a normal request.
@@ -95,7 +96,11 @@ class ResponseCache {
    * Used to detect when the cache size may be too small.
    * Bounded to prevent memory growth.
    */ this.evictedInvocationIDs = new Set();
-        this.minimal_mode = minimal_mode;
+        if (!route) {
+            throw new _invarianterror.InvariantError('Response cache requires a source route');
+        }
+        this.route = route;
+        this.minimal_mode = minimalMode;
         this.maxSize = maxSize;
         this.ttl = ttl;
         // Create the LRU cache with eviction tracking
@@ -150,7 +155,7 @@ class ResponseCache {
                 (0, _log.warnOnce)(`Response cache entry was evicted for invocation ${context.invocationID}. ` + `Consider increasing NEXT_PRIVATE_RESPONSE_CACHE_MAX_SIZE (current: ${this.maxSize}).`);
             }
         }
-        const { incrementalCache, isOnDemandRevalidate = false, isFallback = false, isRoutePPREnabled = false, isPrefetch = false, waitUntil, routeKind, invocationID } = context;
+        const { incrementalCache, isOnDemandRevalidate = false, isFallback = false, isRoutePPREnabled = false, isPrefetch = false, waitUntil, invocationID } = context;
         const response = await this.batcher.batch({
             key,
             isOnDemandRevalidate
@@ -161,7 +166,6 @@ class ResponseCache {
                 isFallback,
                 isRoutePPREnabled,
                 isPrefetch,
-                routeKind,
                 invocationID
             }, resolve);
             // we need to ensure background revalidates are
@@ -186,11 +190,7 @@ class ResponseCache {
         let resolved = false;
         try {
             // Get the previous cache entry if not in minimal mode
-            previousIncrementalCacheEntry = !this.minimal_mode ? await context.incrementalCache.get(key, {
-                kind: (0, _utils.routeKindToIncrementalCacheKind)(context.routeKind),
-                isRoutePPREnabled: context.isRoutePPREnabled,
-                isFallback: context.isFallback
-            }) : null;
+            previousIncrementalCacheEntry = !this.minimal_mode ? await context.incrementalCache.get(key, this.getCacheContext(context.isRoutePPREnabled, context.isFallback)) : null;
             if (previousIncrementalCacheEntry && !context.isOnDemandRevalidate) {
                 resolve(previousIncrementalCacheEntry);
                 resolved = true;
@@ -277,8 +277,7 @@ class ResponseCache {
                 } else {
                     await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
                         cacheControl: incrementalResponseCacheEntry.cacheControl,
-                        isRoutePPREnabled,
-                        isFallback
+                        ...this.getCacheContext(isRoutePPREnabled, isFallback)
                     });
                 }
             }
@@ -290,18 +289,35 @@ class ResponseCache {
                 const revalidate = Math.min(Math.max(previousIncrementalCacheEntry.cacheControl.revalidate || 3, 3), 30);
                 const expire = previousIncrementalCacheEntry.cacheControl.expire === undefined ? undefined : Math.max(revalidate + 3, previousIncrementalCacheEntry.cacheControl.expire);
                 await incrementalCache.set(key, previousIncrementalCacheEntry.value, {
+                    ...this.getCacheContext(isRoutePPREnabled, isFallback),
                     cacheControl: {
                         revalidate: revalidate,
                         expire: expire
-                    },
-                    isRoutePPREnabled,
-                    isFallback
+                    }
                 });
             }
             // We haven't resolved yet, so let's throw to indicate an error.
             throw err;
         }
     }
+    getCacheContext(isRoutePPREnabled, isFallback) {
+        if (this.route === 'image') {
+            return {
+                kind: _types.IncrementalCacheKind.IMAGE,
+                isFallback: false
+            };
+        }
+        const kind = (0, _utils.routeKindToIncrementalCacheKind)(this.route.kind);
+        if (kind === _types.IncrementalCacheKind.IMAGE) {
+            throw new _invarianterror.InvariantError('Images must use the image response cache');
+        }
+        return {
+            route: this.route,
+            kind,
+            isRoutePPREnabled,
+            isFallback
+        };
+    }
 }
 
 //# sourceMappingURL=index.js.map

package/dist/node_modules/next/dist/server/route-matcher-providers/app-page-route-matcher-provider.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "AppPageRouteMatcherProvider", {
         return AppPageRouteMatcherProvider;
     }
 });
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _isapppageroute = require("../../lib/is-app-page-route");
 const _constants = require("../../shared/lib/constants");
 const _app = require("../normalizers/built/app");
@@ -35,8 +36,7 @@ class AppPageRouteMatcherProvider extends _manifestroutematcherprovider.Manifest
         // Format the routes.
         const matchers = [];
         for (const [pathname, appPaths] of Object.entries(allAppPaths)){
-            // TODO-APP: (wyattjoh) this is a hack right now, should be more deterministic
-            const page = appPaths[0];
+            const page = (0, _apppaths.selectAppPageEntry)(pathname, appPaths);
             const filename = this.normalizers.filename.normalize(manifest[page]);
             const bundlePath = this.normalizers.bundlePath.normalize(page);
             matchers.push(new _apppageroutematcher.AppPageRouteMatcher({

package/dist/node_modules/next/dist/server/route-modules/pages/pages-handler.js

@@ -30,6 +30,7 @@ const _redirectstatuscode = require("../../../client/components/redirect-status-
 const _isbot = require("../../../shared/lib/router/utils/is-bot");
 const _addpathprefix = require("../../../shared/lib/router/utils/add-path-prefix");
 const _removetrailingslash = require("../../../shared/lib/router/utils/remove-trailing-slash");
+const _routecachekey = require("../../lib/route-cache-key");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -81,8 +82,12 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
             cacheKey = cacheKey === '/index' ? '/' : cacheKey;
         }
         if (hasStaticPaths && !isDraftMode) {
+            var _nextConfig_i18n;
             const decodedPathname = (0, _removetrailingslash.removeTrailingSlash)(locale ? (0, _addpathprefix.addPathPrefix)(resolvedPathname, `/${locale}`) : resolvedPathname);
-            const isPrerendered = Boolean(prerenderManifest.routes[decodedPathname]) || prerenderManifest.notFoundRoutes.includes(decodedPathname);
+            const isPrerendered = (Boolean(prerenderManifest.routes[decodedPathname]) || prerenderManifest.notFoundRoutes.includes(decodedPathname)) && // A sibling's positive or negative prerender cannot admit parameters
+            // that this route excluded. Development computes static paths on demand
+            // instead of reading build-time prerender metadata.
+            (routeModule.isDev || (0, _routecachekey.isRouteCacheOwner)(decodedPathname, routeModule.cacheOwner, prerenderManifest.routes[decodedPathname], (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.locales));
             const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage];
             if (prerenderInfo) {
                 if (prerenderInfo.fallback === false && !isPrerendered) {

package/dist/node_modules/next/dist/server/route-modules/route-module.js

@@ -25,6 +25,7 @@ const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
 const _incrementalcache = require("../lib/incremental-cache");
 const _handlers = require("../use-cache/handlers");
 const _interopdefault = require("../app-render/interop-default");
+const _routecachekey = require("../lib/route-cache-key");
 const _responsecache = /*#__PURE__*/ _interop_require_default(require("../response-cache"));
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _routerservercontext = require("../lib/router-utils/router-server-context");
@@ -41,6 +42,7 @@ class RouteModule {
     constructor({ userland, definition, distDir, relativeProjectDir }){
         this.userland = userland;
         this.definition = definition;
+        this.cacheOwner = (0, _routecachekey.getResponseCacheOwner)(definition);
         this.isDev = process.env.NODE_ENV === 'development';
         this.distDir = distDir;
         this.relativeProjectDir = relativeProjectDir;
@@ -227,6 +229,7 @@ class RouteModule {
         if (process.env.NEXT_RUNTIME === 'edge') {
             return globalThis.__incrementalCache;
         } else {
+            var _nextConfig_i18n;
             let CacheHandler;
             const { cacheHandler } = nextConfig;
             if (cacheHandler) {
@@ -250,7 +253,8 @@ class RouteModule {
                 maxMemoryCacheSize: nextConfig.cacheMaxMemorySize,
                 flushToDisk: nextConfig.experimental.isrFlushToDisk,
                 getPrerenderManifest: ()=>prerenderManifest,
-                CurCacheHandler: CacheHandler
+                CurCacheHandler: CacheHandler,
+                locales: (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.locales
             });
         }
     }
@@ -478,7 +482,10 @@ class RouteModule {
     getResponseCache(req) {
         if (!this.responseCache) {
             const minimalMode = (0, _requestmeta.getRequestMeta)(req, 'minimalMode') ?? false;
-            this.responseCache = new _responsecache.default(minimalMode);
+            this.responseCache = new _responsecache.default({
+                minimalMode,
+                route: this.cacheOwner
+            });
         }
         return this.responseCache;
     }

package/dist/node_modules/next/dist/shared/lib/canary-only.js

@@ -22,7 +22,7 @@ _export(exports, {
 });
 function isStableBuild() {
     var _process_env___NEXT_VERSION;
-    return !((_process_env___NEXT_VERSION = "15.5.21") == null ? void 0 : _process_env___NEXT_VERSION.includes('canary')) && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
+    return !((_process_env___NEXT_VERSION = "15.5.27") == null ? void 0 : _process_env___NEXT_VERSION.includes('canary')) && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
 }
 class CanaryOnlyError extends Error {
     constructor(arg){