@evoscientist/webui 0.2.9 → 0.3.1

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(tags, durations) {
         tags = typeof tags === 'string' ? [
             tags
@@ -75,10 +103,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('FileSystemCache: get', key, ctx.tags, kind, !!data);
@@ -86,16 +122,40 @@ class FileSystemCache {
                 console.log('FileSystemCache: 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,
@@ -104,7 +164,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) {
@@ -136,12 +196,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.
@@ -151,7 +209,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 {
@@ -165,10 +223,10 @@ class FileSystemCache {
                         }
                         let rscData;
                         if (!ctx.isFallback && (!ctx.isRoutePPREnabled || (meta == null ? void 0 : meta.postponed) == null)) {
-                            rscData = await this.fs.readFile(this.getFilePath(`${key}${_constants.RSC_SUFFIX}`, _responsecache.IncrementalCacheKind.APP_PAGE));
+                            rscData = await this.fs.readFile(this.getFilePath(`${readKey}${_constants.RSC_SUFFIX}`, _responsecache.IncrementalCacheKind.APP_PAGE));
                         }
                         data = {
-                            lastModified: mtime.getTime(),
+                            lastModified: meta.routeCacheLastModified ?? mtime.getTime(),
                             value: {
                                 kind: _responsecache.CachedRouteKind.APP_PAGE,
                                 html: fileData,
@@ -180,13 +238,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,
@@ -204,10 +262,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;
             }
         }
@@ -223,6 +286,9 @@ class FileSystemCache {
                     if (FileSystemCache.debug) {
                         console.log('FileSystemCache: expired tags', cacheTags);
                     }
+                    if (seedRead) {
+                        this.finishSeedRead(seedRead.stateKey, seedRead.state);
+                    }
                     return null;
                 }
             }
@@ -246,10 +312,88 @@ class FileSystemCache {
                 return null;
             }
         }
+        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) {
+                if (!ctx.isFallback && (!ctx.isRoutePPREnabled || meta.postponed == null)) {
+                    ancillaryFiles.push({
+                        path: this.getFilePath(`${key}${_constants.RSC_SUFFIX}`, kind),
+                        data: await this.fs.readFile(this.getFilePath(`${seedKey}${_constants.RSC_SUFFIX}`, kind))
+                    });
+                }
+                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()
@@ -258,6 +402,7 @@ class FileSystemCache {
             console.log('FileSystemCache: 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);
@@ -299,6 +444,15 @@ class FileSystemCache {
                     prefetchHints: undefined
                 };
                 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,
+                    prefetchHints: 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);
@@ -333,6 +487,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");
@@ -89,7 +88,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);
@@ -127,7 +126,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)) {
@@ -150,20 +150,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);
@@ -307,6 +303,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) {
@@ -355,8 +354,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) {
@@ -429,7 +436,7 @@ class IncrementalCache {
         }
         let entry = null;
         const { isFallback } = ctx;
-        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) {
@@ -438,7 +445,7 @@ class IncrementalCache {
         } else {
             const now = performance.timeOrigin + performance.now();
             const lastModified = (cacheData == null ? void 0 : cacheData.lastModified) || now;
-            revalidateAfter = this.calculateRevalidate(cacheKey, lastModified, this.dev ?? false, ctx.isFallback);
+            revalidateAfter = this.calculateRevalidate(cacheControl, lastModified, this.dev ?? false, ctx.isFallback);
             // If the route's `expire` time has passed, force a blocking revalidation
             // by signalling `isStale = -1`. The response cache treats `-1` as "skip
             // the early SWR resolve" and awaits a fresh render before the user sees a
@@ -476,7 +483,7 @@ class IncrementalCache {
                 isFallback
             };
         }
-        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
@@ -497,6 +504,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
@@ -513,7 +523,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
@@ -535,9 +554,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/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