af360 0.1.15 → 0.1.16

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

@@ -417,9 +417,6 @@ class Server {
         // wait. Also we can't `await` in the constructor.
         void this.matchers.reload();
         this.setAssetPrefix(assetPrefix);
-        this.responseCache = this.getResponseCache({
-            dev
-        });
     }
     getRouteMatchers() {
         // Create a new manifest loader that get's the manifests from the server.
@@ -1462,8 +1459,8 @@ class Server {
         const isAppPath = Array.isArray(appPaths);
         let page = pathname;
         if (isAppPath) {
-            // the last item in the array is the root page, if there are parallel routes
-            page = appPaths[appPaths.length - 1];
+            // Use the same direct entry as the build, independent of manifest order.
+            page = (0, _apppaths.selectAppPageEntry)(pathname, appPaths);
         }
         const result = await this.findPageComponents({
             locale: (0, _requestmeta.getRequestMeta)(ctx.req, 'locale'),

package/dist/node_modules/next/dist/server/dev/hot-reloader-turbopack.js

@@ -145,7 +145,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-        version: "15.5.24"
+        version: "15.5.27"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.

package/dist/node_modules/next/dist/server/dev/hot-reloader-webpack.js

@@ -262,7 +262,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "15.5.24"
+            version: "15.5.27"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     ImageError: null,
     ImageOptimizerCache: null,
+    canDecodeAvif: null,
     detectContentType: null,
     extractEtag: null,
     fetchExternalImage: null,
@@ -16,6 +17,7 @@ Object.defineProperty(exports, "__esModule", {
     getPreviouslyCachedImageOrNull: null,
     getSharp: null,
     imageOptimizer: null,
+    isAvifDecodeSafe: null,
     optimizeImage: null,
     sendResponse: null
 });
@@ -32,6 +34,9 @@ _export(exports, {
     ImageOptimizerCache: function() {
         return ImageOptimizerCache;
     },
+    canDecodeAvif: function() {
+        return canDecodeAvif;
+    },
     detectContentType: function() {
         return detectContentType;
     },
@@ -65,6 +70,9 @@ _export(exports, {
     imageOptimizer: function() {
         return imageOptimizer;
     },
+    isAvifDecodeSafe: function() {
+        return isAvifDecodeSafe;
+    },
     optimizeImage: function() {
         return optimizeImage;
     },
@@ -165,8 +173,7 @@ const BYPASS_TYPES = [
     ICNS,
     BMP,
     JXL,
-    HEIC,
-    AVIF
+    HEIC
 ];
 const BLUR_IMG_SIZE = 8 // should match `next-image-loader`
 ;
@@ -196,6 +203,7 @@ function getSharp(concurrency) {
         return _sharp;
     }
     try {
+        var _sharp_versions;
         // eslint-disable-next-line @next/internal/typechecked-require -- sharp 0.34 and 0.35 type the module differently, see SharpModule
         _sharp = require('sharp');
         _sharp.block({
@@ -213,6 +221,13 @@ function getSharp(concurrency) {
                 'VipsForeignLoadWebp'
             ]
         });
+        if (isAvifDecodeSafe(((_sharp_versions = _sharp.versions) == null ? void 0 : _sharp_versions.heif) ?? null)) {
+            _sharp.unblock({
+                operation: [
+                    'VipsForeignLoadHeif'
+                ]
+            });
+        }
         if (_sharp && _sharp.concurrency() > 1) {
             // Reducing concurrency should reduce the memory usage too.
             // We more aggressively reduce in dev but also reduce in prod.
@@ -232,6 +247,34 @@ function getSharp(concurrency) {
     }
     return _sharp;
 }
+function isAvifDecodeSafe(heifVersion) {
+    if (heifVersion === null) {
+        return false;
+    }
+    const [major = Number.NaN, minor = Number.NaN, patch = Number.NaN] = heifVersion.split('.').map((part)=>Number.parseInt(part, 10));
+    if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
+        return false;
+    }
+    return major > 1 || major === 1 && minor > 23 || major === 1 && minor === 23 && patch >= 2;
+}
+let _avifDecodeSafe = null;
+function canDecodeAvif(concurrency) {
+    if (_avifDecodeSafe === null) {
+        let heifVersion = null;
+        try {
+            var _getSharp_versions;
+            // Custom libvips builds do not report dependency versions, so the
+            // absence of a heif version is treated as unsafe.
+            heifVersion = ((_getSharp_versions = getSharp(concurrency).versions) == null ? void 0 : _getSharp_versions.heif) ?? null;
+        } catch  {
+            // Without sharp no AVIF can be decoded either, so treat it as unsafe
+            // and let the image pass through unoptimized.
+            heifVersion = null;
+        }
+        _avifDecodeSafe = isAvifDecodeSafe(heifVersion);
+    }
+    return _avifDecodeSafe;
+}
 function getSupportedMimeType(options, accept = '') {
     const mimeType = (0, _accept.mediaType)(accept, options);
     return accept.includes(mimeType) ? mimeType : '';
@@ -1000,7 +1043,7 @@ async function imageOptimizer(imageUpstream, paramsResult, nextConfig, opts) {
             upstreamEtag
         };
     }
-    if (BYPASS_TYPES.includes(upstreamType)) {
+    if (BYPASS_TYPES.includes(upstreamType) || upstreamType === AVIF && !canDecodeAvif(nextConfig.experimental.imgOptConcurrency)) {
         return {
             buffer: upstreamBuffer,
             contentType: upstreamType,

package/dist/node_modules/next/dist/server/lib/app-info-log.js

@@ -80,7 +80,7 @@ function logStartInfo({ networkUrl, appUrl, envInfo, experimentalFeatures, maxEx
     } else {
         bundlerSuffix = '';
     }
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"15.5.24"}`))}${bundlerSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"15.5.27"}`))}${bundlerSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:        ${appUrl}`);
     }

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

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "default", {
         return FileSystemCache;
     }
 });
+const _routecachekey = require("../route-cache-key");
 const _responsecache = require("../../response-cache");
 const _path = /*#__PURE__*/ _interop_require_default(require("../../../shared/lib/isomorphic/path"));
 const _constants = require("../../../lib/constants");
@@ -21,6 +22,7 @@ function _interop_require_default(obj) {
 }
 class FileSystemCache {
     static #_ = this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE;
+    static #_2 = this.seedReads = new Map();
     constructor(ctx){
         this.fs = ctx.fs;
         this.flushToDisk = ctx.flushToDisk;
@@ -40,6 +42,32 @@ class FileSystemCache {
         }
     }
     resetRequestCache() {}
+    getSeedReadState(key) {
+        return FileSystemCache.seedReads.get(`${this.serverDistDir}:${key}`);
+    }
+    beginSeedRead(key) {
+        const stateKey = `${this.serverDistDir}:${key}`;
+        let state = FileSystemCache.seedReads.get(stateKey);
+        if (!state) {
+            state = {
+                readers: 0,
+                version: 0
+            };
+            FileSystemCache.seedReads.set(stateKey, state);
+        }
+        state.readers++;
+        return {
+            stateKey,
+            state,
+            version: state.version
+        };
+    }
+    finishSeedRead(stateKey, state) {
+        state.readers--;
+        if (state.readers === 0 && !state.promotion) {
+            FileSystemCache.seedReads.delete(stateKey);
+        }
+    }
     async revalidateTag(...args) {
         let [tags] = args;
         tags = typeof tags === 'string' ? [
@@ -58,10 +86,18 @@ class FileSystemCache {
         }
     }
     async get(...args) {
-        var _FileSystemCache_memoryCache, _data_value, _data_value1, _data_value2, _data_value3;
+        var _FileSystemCache_memoryCache, _this_getSeedReadState, _data_value, _data_value1, _data_value2, _data_value3;
         const [key, ctx] = args;
         const { kind } = ctx;
+        let readKey = key;
+        let seedRead;
         let data = (_FileSystemCache_memoryCache = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache.get(key);
+        const activePromotion = (_this_getSeedReadState = this.getSeedReadState(key)) == null ? void 0 : _this_getSeedReadState.promotion;
+        if (!data && activePromotion) {
+            var _FileSystemCache_memoryCache1;
+            await activePromotion;
+            data = (_FileSystemCache_memoryCache1 = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache1.get(key);
+        }
         if (FileSystemCache.debug) {
             if (kind === _responsecache.IncrementalCacheKind.FETCH) {
                 console.log('get', key, ctx.tags, kind, !!data);
@@ -69,16 +105,40 @@ class FileSystemCache {
                 console.log('get', key, kind, !!data);
             }
         }
-        // let's check the disk for seed data
+        const isResponse = kind === _responsecache.IncrementalCacheKind.PAGES || kind === _responsecache.IncrementalCacheKind.APP_PAGE || kind === _responsecache.IncrementalCacheKind.APP_ROUTE;
+        if (!data && isResponse && key.startsWith(`/${_routecachekey.ROUTE_CACHE_DIRECTORY}/`) && process.env.NEXT_RUNTIME !== 'edge') {
+            const primaryPath = this.getFilePath(kind === _responsecache.IncrementalCacheKind.APP_ROUTE ? `${key}.body` : `${key}.html`, kind);
+            if (!this.fs.existsSync(primaryPath)) {
+                const marker = key.indexOf('/$/');
+                if (marker !== -1) {
+                    const legacyKey = key.slice(marker + 2);
+                    const legacyMetaPath = this.getFilePath(`${legacyKey}${_constants.NEXT_META_SUFFIX}`, kind);
+                    try {
+                        var _meta_routeCache;
+                        const meta = JSON.parse(this.fs.readFileSync(legacyMetaPath, 'utf8'));
+                        const namespaceEnd = key.indexOf('/$/');
+                        const ownerKey = meta.routeCache ? (0, _routecachekey.getRouteCacheKey)('/', meta.routeCache.owner) : undefined;
+                        if (((_meta_routeCache = meta.routeCache) == null ? void 0 : _meta_routeCache.key) === key && (meta.routeCache.isFallback === Boolean(ctx.isFallback) || // PPR also reads fallback shells through ordinary response and
+                        // navigation resume-data lookups, which set isFallback: false.
+                        kind === _responsecache.IncrementalCacheKind.APP_PAGE && ctx.isRoutePPREnabled && meta.postponed != null) && (ownerKey == null ? void 0 : ownerKey.slice(0, ownerKey.indexOf('/$/'))) === key.slice(0, namespaceEnd)) {
+                            readKey = legacyKey;
+                            seedRead = this.beginSeedRead(key);
+                        }
+                    } catch  {}
+                }
+            }
+        }
+        // Check the scoped disk entry first, or a verified immutable build seed
+        // only when its scoped primary payload is genuinely absent.
         if (!data && process.env.NEXT_RUNTIME !== 'edge') {
             try {
                 if (kind === _responsecache.IncrementalCacheKind.APP_ROUTE) {
-                    const filePath = this.getFilePath(`${key}.body`, _responsecache.IncrementalCacheKind.APP_ROUTE);
+                    const filePath = this.getFilePath(`${readKey}.body`, _responsecache.IncrementalCacheKind.APP_ROUTE);
                     const fileData = await this.fs.readFile(filePath);
                     const { mtime } = await this.fs.stat(filePath);
                     const meta = JSON.parse(await this.fs.readFile(filePath.replace(/\.body$/, _constants.NEXT_META_SUFFIX), 'utf8'));
                     data = {
-                        lastModified: mtime.getTime(),
+                        lastModified: meta.routeCacheLastModified ?? mtime.getTime(),
                         value: {
                             kind: _responsecache.CachedRouteKind.APP_ROUTE,
                             body: fileData,
@@ -87,7 +147,7 @@ class FileSystemCache {
                         }
                     };
                 } else {
-                    const filePath = this.getFilePath(kind === _responsecache.IncrementalCacheKind.FETCH ? key : `${key}.html`, kind);
+                    const filePath = this.getFilePath(kind === _responsecache.IncrementalCacheKind.FETCH ? readKey : `${readKey}.html`, kind);
                     const fileData = await this.fs.readFile(filePath, 'utf8');
                     const { mtime } = await this.fs.stat(filePath);
                     if (kind === _responsecache.IncrementalCacheKind.FETCH) {
@@ -119,12 +179,10 @@ class FileSystemCache {
                             }
                         }
                     } else if (kind === _responsecache.IncrementalCacheKind.APP_PAGE) {
-                        // We try to load the metadata file, but if it fails, we don't
-                        // error. We also don't load it if this is a fallback.
-                        let meta;
-                        try {
-                            meta = JSON.parse(await this.fs.readFile(filePath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), 'utf8'));
-                        } catch  {}
+                        // Metadata is required for both normal entries and fallback shells.
+                        // Promoted entries publish their primary payload last, so a missing
+                        // sidecar means the scoped entry is incomplete.
+                        const meta = JSON.parse(await this.fs.readFile(filePath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), 'utf8'));
                         let maybeSegmentData;
                         if (meta == null ? void 0 : meta.segmentPaths) {
                             // Collect all the segment data for this page.
@@ -134,7 +192,7 @@ class FileSystemCache {
                             // identical regardless.
                             const segmentData = new Map();
                             maybeSegmentData = segmentData;
-                            const segmentsDir = key + _constants.RSC_SEGMENTS_DIR_SUFFIX;
+                            const segmentsDir = readKey + _constants.RSC_SEGMENTS_DIR_SUFFIX;
                             await Promise.all(meta.segmentPaths.map(async (segmentPath)=>{
                                 const segmentDataFilePath = this.getFilePath(segmentsDir + segmentPath + _constants.RSC_SEGMENT_SUFFIX, _responsecache.IncrementalCacheKind.APP_PAGE);
                                 try {
@@ -148,10 +206,10 @@ class FileSystemCache {
                         }
                         let rscData;
                         if (!ctx.isFallback) {
-                            rscData = await this.fs.readFile(this.getFilePath(`${key}${ctx.isRoutePPREnabled ? _constants.RSC_PREFETCH_SUFFIX : _constants.RSC_SUFFIX}`, _responsecache.IncrementalCacheKind.APP_PAGE));
+                            rscData = await this.fs.readFile(this.getFilePath(`${readKey}${ctx.isRoutePPREnabled ? _constants.RSC_PREFETCH_SUFFIX : _constants.RSC_SUFFIX}`, _responsecache.IncrementalCacheKind.APP_PAGE));
                         }
                         data = {
-                            lastModified: mtime.getTime(),
+                            lastModified: meta.routeCacheLastModified ?? mtime.getTime(),
                             value: {
                                 kind: _responsecache.CachedRouteKind.APP_PAGE,
                                 html: fileData,
@@ -163,13 +221,13 @@ class FileSystemCache {
                             }
                         };
                     } else if (kind === _responsecache.IncrementalCacheKind.PAGES) {
-                        let meta;
+                        const meta = JSON.parse(await this.fs.readFile(filePath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), 'utf8'));
                         let pageData = {};
                         if (!ctx.isFallback) {
-                            pageData = JSON.parse(await this.fs.readFile(this.getFilePath(`${key}${_constants.NEXT_DATA_SUFFIX}`, _responsecache.IncrementalCacheKind.PAGES), 'utf8'));
+                            pageData = JSON.parse(await this.fs.readFile(this.getFilePath(`${readKey}${_constants.NEXT_DATA_SUFFIX}`, _responsecache.IncrementalCacheKind.PAGES), 'utf8'));
                         }
                         data = {
-                            lastModified: mtime.getTime(),
+                            lastModified: meta.routeCacheLastModified ?? mtime.getTime(),
                             value: {
                                 kind: _responsecache.CachedRouteKind.PAGES,
                                 html: fileData,
@@ -187,10 +245,15 @@ class FileSystemCache {
                     }
                 }
                 if (data) {
-                    var _FileSystemCache_memoryCache1;
-                    (_FileSystemCache_memoryCache1 = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache1.set(key, data);
+                    if (!seedRead) {
+                        var _FileSystemCache_memoryCache2;
+                        (_FileSystemCache_memoryCache2 = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache2.set(key, data);
+                    }
                 }
             } catch  {
+                if (seedRead) {
+                    this.finishSeedRead(seedRead.stateKey, seedRead.state);
+                }
                 return null;
             }
         }
@@ -206,6 +269,9 @@ class FileSystemCache {
                 // had a tag revalidated, if we want to be a background
                 // revalidation instead we return data.lastModified = -1
                 if ((0, _tagsmanifestexternal.isStale)(cacheTags, (data == null ? void 0 : data.lastModified) || Date.now())) {
+                    if (seedRead) {
+                        this.finishSeedRead(seedRead.stateKey, seedRead.state);
+                    }
                     return null;
                 }
             }
@@ -228,10 +294,92 @@ class FileSystemCache {
                 data = undefined;
             }
         }
+        if (seedRead && data) {
+            const { stateKey, state, version } = seedRead;
+            try {
+                if (state.version === version) {
+                    var _FileSystemCache_memoryCache3;
+                    await this.promoteSeed(key, readKey, data, ctx, stateKey, state, version);
+                    if (state.version === version && !((_FileSystemCache_memoryCache3 = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache3.get(key))) {
+                        var _FileSystemCache_memoryCache4;
+                        (_FileSystemCache_memoryCache4 = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache4.set(key, data);
+                    }
+                }
+            } finally{
+                this.finishSeedRead(stateKey, state);
+            }
+        }
         return data ?? null;
     }
+    async promoteSeed(key, seedKey, data, ctx, stateKey, state, version) {
+        const writeFileAtomic = this.fs.writeFileAtomic;
+        if (!this.flushToDisk || !writeFileAtomic || !data.value) return;
+        if (state.promotion) {
+            await state.promotion;
+            return;
+        }
+        const promotion = (async ()=>{
+            const value = data.value;
+            if (!value || state.version !== version || value.kind !== _responsecache.CachedRouteKind.PAGES && value.kind !== _responsecache.CachedRouteKind.APP_PAGE && value.kind !== _responsecache.CachedRouteKind.APP_ROUTE) {
+                return;
+            }
+            const kind = ctx.kind;
+            const primaryPath = this.getFilePath(value.kind === _responsecache.CachedRouteKind.APP_ROUTE ? `${key}.body` : `${key}.html`, kind);
+            if (this.fs.existsSync(primaryPath)) return;
+            const seedPrimaryPath = this.getFilePath(value.kind === _responsecache.CachedRouteKind.APP_ROUTE ? `${seedKey}.body` : `${seedKey}.html`, kind);
+            const seedMetaPath = seedPrimaryPath.replace(value.kind === _responsecache.CachedRouteKind.APP_ROUTE ? /\.body$/ : /\.html$/, _constants.NEXT_META_SUFFIX);
+            const meta = JSON.parse(await this.fs.readFile(seedMetaPath, 'utf8'));
+            meta.routeCacheLastModified = data.lastModified;
+            // Copy every ancillary seed file first. The scoped primary payload is
+            // the publication marker and is written only after metadata is complete.
+            const ancillaryFiles = [];
+            if (value.kind === _responsecache.CachedRouteKind.PAGES && !ctx.isFallback) {
+                ancillaryFiles.push({
+                    path: this.getFilePath(`${key}${_constants.NEXT_DATA_SUFFIX}`, kind),
+                    data: await this.fs.readFile(this.getFilePath(`${seedKey}${_constants.NEXT_DATA_SUFFIX}`, kind))
+                });
+            } else if (value.kind === _responsecache.CachedRouteKind.APP_PAGE) {
+                const rscSuffix = ctx.isRoutePPREnabled ? _constants.RSC_PREFETCH_SUFFIX : _constants.RSC_SUFFIX;
+                const seedRscPath = this.getFilePath(`${seedKey}${rscSuffix}`, kind);
+                // Next 15 PPR shells can include a full prefetch payload even when
+                // first read as a fallback. Preserve it for subsequent ordinary reads.
+                if (!ctx.isFallback || ctx.isRoutePPREnabled && this.fs.existsSync(seedRscPath)) {
+                    ancillaryFiles.push({
+                        path: this.getFilePath(`${key}${rscSuffix}`, kind),
+                        data: await this.fs.readFile(seedRscPath)
+                    });
+                }
+                ancillaryFiles.push(...await Promise.all((meta.segmentPaths ?? []).map(async (segmentPath)=>({
+                        path: this.getFilePath(key + _constants.RSC_SEGMENTS_DIR_SUFFIX + segmentPath + _constants.RSC_SEGMENT_SUFFIX, kind),
+                        data: await this.fs.readFile(this.getFilePath(seedKey + _constants.RSC_SEGMENTS_DIR_SUFFIX + segmentPath + _constants.RSC_SEGMENT_SUFFIX, kind))
+                    }))));
+            }
+            const writer = new _multifilewriter.MultiFileWriter(this.fs);
+            for (const file of ancillaryFiles)writer.append(file.path, file.data);
+            await writer.wait();
+            if (state.version !== version) return;
+            const metaPath = primaryPath.replace(value.kind === _responsecache.CachedRouteKind.APP_ROUTE ? /\.body$/ : /\.html$/, _constants.NEXT_META_SUFFIX);
+            await this.fs.mkdir(_path.default.dirname(metaPath));
+            await this.fs.writeFile(metaPath, JSON.stringify(meta));
+            if (state.version !== version || this.fs.existsSync(primaryPath)) return;
+            await writeFileAtomic.call(this.fs, primaryPath, await this.fs.readFile(seedPrimaryPath));
+        })();
+        state.promotion = promotion.catch((error)=>{
+            if (FileSystemCache.debug) {
+                console.log('FileSystemCache: failed to promote build seed', error);
+            }
+        });
+        try {
+            await state.promotion;
+        } finally{
+            if (state.promotion) state.promotion = undefined;
+            if (state.readers === 0) FileSystemCache.seedReads.delete(stateKey);
+        }
+    }
     async set(key, data, ctx) {
         var _FileSystemCache_memoryCache;
+        const seedState = this.getSeedReadState(key);
+        if (seedState) seedState.version++;
         (_FileSystemCache_memoryCache = FileSystemCache.memoryCache) == null ? void 0 : _FileSystemCache_memoryCache.set(key, {
             value: data,
             lastModified: Date.now()
@@ -240,6 +388,7 @@ class FileSystemCache {
             console.log('set', key);
         }
         if (!this.flushToDisk || !data) return;
+        await (seedState == null ? void 0 : seedState.promotion);
         // Create a new writer that will prepare to write all the files to disk
         // after their containing directory is created.
         const writer = new _multifilewriter.MultiFileWriter(this.fs);
@@ -279,6 +428,14 @@ class FileSystemCache {
                     segmentPaths
                 };
                 writer.append(htmlPath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), JSON.stringify(meta));
+            } else {
+                const meta = {
+                    headers: data.headers,
+                    status: data.status,
+                    postponed: undefined,
+                    segmentPaths: undefined
+                };
+                writer.append(htmlPath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), JSON.stringify(meta));
             }
         } else if (data.kind === _responsecache.CachedRouteKind.FETCH) {
             const filePath = this.getFilePath(key, _responsecache.IncrementalCacheKind.FETCH);
@@ -313,6 +470,10 @@ class FileSystemCache {
                     configurable: true
                 });
         }
+        // Scoped response artifacts live outside the compiled route and ASO files.
+        if ((kind === _responsecache.IncrementalCacheKind.PAGES || kind === _responsecache.IncrementalCacheKind.APP_PAGE || kind === _responsecache.IncrementalCacheKind.APP_ROUTE) && key.startsWith(`/${_routecachekey.ROUTE_CACHE_DIRECTORY}/`)) {
+            rootDir = _path.default.join(this.serverDistDir, '.');
+        }
         const filePath = _path.default.join(rootDir, key);
         if (!(filePath.startsWith(rootDir + _path.default.sep) || filePath === rootDir)) {
             throw Object.defineProperty(new Error(`Invalid file path: ${filePath}`), "__NEXT_ERROR_CODE", {

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);
         }