af360 0.1.14 → 0.1.16

package/dist/node_modules/next/dist/lib/has-necessary-dependencies.js

@@ -18,6 +18,8 @@ async function hasNecessaryDependencies(baseDir, requiredPackages) {
         try {
             const pkgPath = await _fs.promises.realpath((0, _resolvefrom.resolveFrom)(baseDir, `${p.pkg}/package.json`));
             const pkgDir = (0, _path.dirname)(pkgPath);
+            // Default to the package.json, if the file we want isn't there we can still read the package.json
+            resolutions.set((0, _path.join)(p.pkg, 'package.json'), pkgPath);
             if (p.exportsRestrict) {
                 const fileNameToVerify = (0, _path.relative)(p.pkg, p.file);
                 if (fileNameToVerify) {

package/dist/node_modules/next/dist/lib/verify-typescript-setup.js

@@ -97,6 +97,25 @@ async function verifyTypeScriptSetup({ dir, distDir, cacheDir, intentDirs, tscon
         }
         // Ensure TypeScript and necessary `@types/*` are installed:
         let deps = await (0, _hasnecessarydependencies.hasNecessaryDependencies)(dir, requiredPackages);
+        // TypeScript 7's native compiler no longer ships the JavaScript compiler API
+        // (`typescript/lib/typescript.js`) that Next.js loads via `require('typescript')`.
+        // This causes surprising errors so proactively reject it.
+        const installedTypescriptPackageJsonPath = deps.resolved.get(_path.default.join('typescript', 'package.json'));
+        if (installedTypescriptPackageJsonPath) {
+            const installedTypescriptVersion = require(installedTypescriptPackageJsonPath).version;
+            if (installedTypescriptVersion && // Use the lowest prerelease sentinel `7.0.0-0` so that TypeScript 7
+            // prereleases (e.g. `7.0.0-beta`, `7.0.0-rc`, or nightly `7.0.0-dev.*`
+            // builds published to the `next` dist-tag) are also rejected.
+            _semver.default.gte(installedTypescriptVersion, '7.0.0-0', {
+                includePrerelease: true
+            })) {
+                throw Object.defineProperty(new _compileerror.CompileError(`TypeScript ${installedTypescriptVersion} is not supported by this version of Next.js. ` + `The TypeScript 7 native compiler does not provide the JavaScript compiler API that Next.js requires. ` + `Install TypeScript 6 (e.g. ${(0, _picocolors.bold)('npm install --save-dev typescript@^6')}) or upgrade to a Next.js v16.2.11 or later to get support for TypeScript 7.`), "__NEXT_ERROR_CODE", {
+                    value: "E798",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        }
         if (((_deps_missing = deps.missing) == null ? void 0 : _deps_missing.length) > 0) {
             const missingPackages = deps.missing.map((pkg)=>({
                     ...pkg,

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.21"
+        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.21"
+            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;
     },
@@ -195,7 +203,31 @@ 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({
+            operation: [
+                'VipsForeignLoad'
+            ]
+        });
+        _sharp.unblock({
+            operation: [
+                'VipsForeignLoadJpeg',
+                'VipsForeignLoadNsgif',
+                'VipsForeignLoadPng',
+                'VipsForeignLoadSvg',
+                'VipsForeignLoadTiff',
+                '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.
@@ -215,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 : '';
@@ -809,7 +869,10 @@ async function optimizeImage({ buffer, contentType, quality, width, height, conc
     }
     if (contentType === AVIF) {
         transformer.avif({
-            quality: Math.max(quality - 20, 1),
+            // Scale the quality to try and match webp. This ratio was derived
+            // from sharp's default 80 (webp) and 50 (avif), and then verified
+            // using dssim and ssimulacra2 visual quality tests.
+            quality: Math.max(Math.round(quality * (50 / 80)), 1),
             effort: 3
         });
     } else if (contentType === WEBP) {
@@ -980,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.21"}`))}${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);
@@ -290,18 +447,22 @@ class FileSystemCache {
         // Wait for all FS operations to complete.
         await writer.wait();
     }
-    getFilePath(pathname, kind) {
+    getFilePath(key, kind) {
+        let rootDir;
         switch(kind){
             case _responsecache.IncrementalCacheKind.FETCH:
                 // we store in .next/cache/fetch-cache so it can be persisted
                 // across deploys
-                return _path.default.join(this.serverDistDir, '..', 'cache', 'fetch-cache', pathname);
+                rootDir = _path.default.join(this.serverDistDir, '..', 'cache', 'fetch-cache');
+                break;
             case _responsecache.IncrementalCacheKind.PAGES:
-                return _path.default.join(this.serverDistDir, 'pages', pathname);
+                rootDir = _path.default.join(this.serverDistDir, 'pages');
+                break;
             case _responsecache.IncrementalCacheKind.IMAGE:
             case _responsecache.IncrementalCacheKind.APP_PAGE:
             case _responsecache.IncrementalCacheKind.APP_ROUTE:
-                return _path.default.join(this.serverDistDir, 'app', pathname);
+                rootDir = _path.default.join(this.serverDistDir, 'app');
+                break;
             default:
                 throw Object.defineProperty(new Error(`Unexpected file path kind: ${kind}`), "__NEXT_ERROR_CODE", {
                     value: "E479",
@@ -309,6 +470,19 @@ 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", {
+                value: "E799",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return filePath;
     }
 }