@semiont/frontend 0.3.2 → 0.3.4

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

@@ -91,6 +91,7 @@ const _servestatic = require("./serve-static");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
 const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
 const _isprivateip = require("./is-private-ip");
+const _disklrucacheexternal = require("./lib/disk-lru-cache.external");
 const _url1 = require("../lib/url");
 const _invarianterror = require("../shared/lib/invariant-error");
 const _promises = require("dns/promises");
@@ -175,6 +176,24 @@ const BLUR_IMG_SIZE = 8 // should match `next-image-loader`
 const BLUR_QUALITY = 70 // should match `next-image-loader`
 ;
 let _sharp;
+async function initCacheEntries(cacheDir) {
+    const cacheKeys = await _fs.promises.readdir(cacheDir).catch(()=>[]);
+    const entries = [];
+    for (const cacheKey of cacheKeys){
+        try {
+            const { expireAt, buffer } = await readFromCacheDir(cacheDir, cacheKey);
+            entries.push({
+                key: cacheKey,
+                size: buffer.byteLength,
+                expireAt
+            });
+        } catch  {
+        // Skip entries that can't be read from disk
+        }
+    }
+    // Sort oldest-first so we can replay them chronologically into LRU
+    return entries.sort((a, b)=>a.expireAt - b.expireAt);
+}
 function getSharp(concurrency) {
     if (_sharp) {
         return _sharp;
@@ -228,7 +247,8 @@ function getImageEtag(image) {
         image
     ]);
 }
-async function writeToCacheDir(dir, extension, maxAge, expireAt, buffer, etag, upstreamEtag) {
+async function writeToCacheDir(cacheDir, cacheKey, extension, maxAge, expireAt, buffer, etag, upstreamEtag) {
+    const dir = (0, _path.join)(/* turbopackIgnore: true */ cacheDir, cacheKey);
     const filename = (0, _path.join)(/* turbopackIgnore: true */ dir, `${maxAge}.${expireAt}.${etag}.${upstreamEtag}.${extension}`);
     await _fs.promises.rm(dir, {
         recursive: true,
@@ -239,6 +259,39 @@ async function writeToCacheDir(dir, extension, maxAge, expireAt, buffer, etag, u
     });
     await _fs.promises.writeFile(filename, buffer);
 }
+async function readFromCacheDir(cacheDir, cacheKey) {
+    const dir = (0, _path.join)(/* turbopackIgnore: true */ cacheDir, cacheKey);
+    const files = await _fs.promises.readdir(dir);
+    const file = files[0];
+    if (!file) {
+        throw Object.defineProperty(new Error(`Invariant: cache entry "${cacheKey}" not found in dir "${cacheDir}"`), "__NEXT_ERROR_CODE", {
+            value: "E1069",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const [maxAgeSt, expireAtSt, etag, upstreamEtag, extension] = file.split('.', 5);
+    const filePath = (0, _path.join)(/* turbopackIgnore: true */ dir, file);
+    const buffer = await _fs.promises.readFile(/* turbopackIgnore: true */ filePath);
+    const expireAt = Number(expireAtSt);
+    const maxAge = Number(maxAgeSt);
+    return {
+        maxAge,
+        expireAt,
+        etag,
+        upstreamEtag,
+        buffer,
+        extension
+    };
+}
+async function deleteFromCacheDir(cacheDir, cacheKey) {
+    return _fs.promises.rm((0, _path.join)(/* turbopackIgnore: true */ cacheDir, cacheKey), {
+        recursive: true,
+        force: true
+    }).catch((err)=>{
+        _log.error(`Failed to delete cache key ${cacheKey}`, err);
+    });
+}
 async function detectContentType(buffer, skipMetadata, concurrency) {
     if (buffer.byteLength === 0) {
         return null;
@@ -630,45 +683,81 @@ class ImageOptimizerCache {
             mimeType
         ]);
     }
-    constructor({ distDir, nextConfig }){
+    constructor({ distDir, nextConfig, cacheHandler }){
         this.cacheDir = (0, _path.join)(/* turbopackIgnore: true */ distDir, 'cache', 'images');
         this.nextConfig = nextConfig;
+        this.cacheHandler = cacheHandler;
+        // Eagerly start LRU initialization for filesystem cache
+        if (!cacheHandler && nextConfig.images.maximumDiskCacheSize !== 0 && nextConfig.experimental.isrFlushToDisk) {
+            this.isDiskCacheEnabled = true;
+            this.cacheDiskLRU = (0, _disklrucacheexternal.getOrInitDiskLRU)(this.cacheDir, nextConfig.images.maximumDiskCacheSize, initCacheEntries, deleteFromCacheDir);
+        }
     }
     async get(cacheKey) {
-        try {
-            const cacheDir = (0, _path.join)(/* turbopackIgnore: true */ this.cacheDir, cacheKey);
-            const files = await _fs.promises.readdir(cacheDir);
-            const now = Date.now();
-            for (const file of files){
-                const [maxAgeSt, expireAtSt, etag, upstreamEtag, extension] = file.split('.', 5);
-                const buffer = await _fs.promises.readFile(/* turbopackIgnore: true */ (0, _path.join)(/* turbopackIgnore: true */ cacheDir, file));
-                const expireAt = Number(expireAtSt);
-                const maxAge = Number(maxAgeSt);
+        // If a custom cache handler is provided, use it
+        if (this.cacheHandler) {
+            try {
+                const cacheData = await this.cacheHandler.get(cacheKey, {
+                    kind: _responsecache.IncrementalCacheKind.IMAGE,
+                    isFallback: false
+                });
+                if (!(cacheData == null ? void 0 : cacheData.value)) {
+                    return null;
+                }
+                if (cacheData.value.kind !== _responsecache.CachedRouteKind.IMAGE) {
+                    return null;
+                }
+                const now = Date.now();
+                const lastModified = cacheData.lastModified || now;
+                const revalidate = typeof cacheData.value.revalidate === 'number' ? cacheData.value.revalidate : this.nextConfig.images.minimumCacheTTL;
+                const revalidateAfter = Math.max(revalidate, this.nextConfig.images.minimumCacheTTL) * 1000 + lastModified;
+                const isStale = revalidateAfter < now;
                 return {
-                    value: {
-                        kind: _responsecache.CachedRouteKind.IMAGE,
-                        etag,
-                        buffer,
-                        extension,
-                        upstreamEtag
-                    },
-                    revalidateAfter: Math.max(maxAge, this.nextConfig.images.minimumCacheTTL) * 1000 + Date.now(),
+                    value: cacheData.value,
+                    revalidateAfter,
                     cacheControl: {
-                        revalidate: maxAge,
+                        revalidate,
                         expire: undefined
                     },
-                    isStale: now > expireAt
+                    isStale
                 };
+            } catch (_) {
+            // failed to get from custom cache handler, treat as cache miss
             }
+            return null;
+        }
+        // If the filesystem cache is disabled, return early
+        if (!this.isDiskCacheEnabled) {
+            return null;
+        }
+        // Fall back to filesystem cache
+        try {
+            const now = Date.now();
+            const { maxAge, expireAt, etag, upstreamEtag, buffer, extension } = await readFromCacheDir(this.cacheDir, cacheKey);
+            // Promote entry in LRU (mark as recently used)
+            const lru = await this.cacheDiskLRU;
+            lru == null ? void 0 : lru.get(cacheKey);
+            return {
+                value: {
+                    kind: _responsecache.CachedRouteKind.IMAGE,
+                    etag,
+                    buffer,
+                    extension,
+                    upstreamEtag
+                },
+                revalidateAfter: Math.max(maxAge, this.nextConfig.images.minimumCacheTTL) * 1000 + Date.now(),
+                cacheControl: {
+                    revalidate: maxAge,
+                    expire: undefined
+                },
+                isStale: now > expireAt
+            };
         } catch (_) {
         // failed to read from cache dir, treat as cache miss
         }
         return null;
     }
     async set(cacheKey, value, { cacheControl }) {
-        if (!this.nextConfig.experimental.isrFlushToDisk) {
-            return;
-        }
         if ((value == null ? void 0 : value.kind) !== _responsecache.CachedRouteKind.IMAGE) {
             throw Object.defineProperty(new Error('invariant attempted to set non-image to image-cache'), "__NEXT_ERROR_CODE", {
                 value: "E366",
@@ -684,9 +773,43 @@ class ImageOptimizerCache {
                 configurable: true
             });
         }
+        // If a custom cache handler is provided, use it
+        if (this.cacheHandler) {
+            try {
+                // Apply minimumCacheTTL at write time, similar to the implementation in the fallback filesystem cache
+                const effectiveRevalidate = Math.max(revalidate, this.nextConfig.images.minimumCacheTTL);
+                const valueWithRevalidate = {
+                    ...value,
+                    revalidate: effectiveRevalidate
+                };
+                await this.cacheHandler.set(cacheKey, valueWithRevalidate, {
+                    cacheControl: {
+                        revalidate: effectiveRevalidate,
+                        expire: cacheControl == null ? void 0 : cacheControl.expire
+                    }
+                });
+            } catch (err) {
+                _log.error(`Failed to write image to custom cache ${cacheKey}`, err);
+            }
+            return;
+        }
+        // If the filesystem cache is disabled, return early
+        if (!this.isDiskCacheEnabled) {
+            return;
+        }
+        // Fall back to filesystem cache
         const expireAt = Math.max(revalidate, this.nextConfig.images.minimumCacheTTL) * 1000 + Date.now();
         try {
-            await writeToCacheDir((0, _path.join)(/* turbopackIgnore: true */ this.cacheDir, cacheKey), value.extension, revalidate, expireAt, value.buffer, value.etag, value.upstreamEtag);
+            const lru = await this.cacheDiskLRU;
+            const success = lru == null ? void 0 : lru.set(cacheKey, value.buffer.byteLength);
+            if (success === false) {
+                throw Object.defineProperty(new Error(`image of size ${value.buffer.byteLength} could not be tracked by lru cache`), "__NEXT_ERROR_CODE", {
+                    value: "E1070",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            await writeToCacheDir(this.cacheDir, cacheKey, value.extension, revalidate, expireAt, value.buffer, value.etag, value.upstreamEtag);
         } catch (err) {
             _log.error(`Failed to write image to cache ${cacheKey}`, err);
         }
@@ -889,9 +1012,11 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
 }
 async function fetchInternalImage(href, _req, _res, handleRequest) {
     try {
+        // Coerce HEAD to GET to avoid issues with the image optimizer
+        const method = !_req.method || _req.method === 'HEAD' ? 'GET' : _req.method;
         const mocked = (0, _mockrequest.createRequestResponseMocks)({
             url: href,
-            method: _req.method || 'GET',
+            method,
             socket: _req.socket
         });
         await handleRequest(mocked.req, mocked.res, _url.default.parse(href, true));
@@ -1076,7 +1201,12 @@ function sendResponse(req, res, url, extension, buffer, etag, isStatic, xCache,
     const result = setResponseHeaders(req, res, url, etag, contentType, isStatic, xCache, imagesConfig, maxAge, isDev);
     if (!result.finished) {
         res.setHeader('Content-Length', Buffer.byteLength(buffer));
-        res.end(buffer);
+        // A response body must not be sent for HEAD requests
+        if (req.method === 'HEAD') {
+            res.end();
+        } else {
+            res.end(buffer);
+        }
     }
 }
 async function getImageSize(buffer) {

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

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    getStartServerInfo: null,
+    getEnvInfo: null,
+    logExperimentalInfo: null,
     logStartInfo: null
 });
 function _export(target, all) {
@@ -13,8 +14,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    getStartServerInfo: function() {
-        return getStartServerInfo;
+    getEnvInfo: function() {
+        return getEnvInfo;
+    },
+    logExperimentalInfo: function() {
+        return logExperimentalInfo;
     },
     logStartInfo: function() {
         return logStartInfo;
@@ -24,14 +28,7 @@ const _env = require("@next/env");
 const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
 const _picocolors = require("../../lib/picocolors");
-const _constants = require("../../shared/lib/constants");
-const _config = /*#__PURE__*/ _interop_require_default(require("../config"));
 const _configschema = require("../config-schema");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -73,7 +70,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-function logStartInfo({ networkUrl, appUrl, envInfo, experimentalFeatures, logBundler, cacheComponents }) {
+function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
     let versionSuffix = '';
     const parts = [];
     if (logBundler) {
@@ -85,13 +82,10 @@ function logStartInfo({ networkUrl, appUrl, envInfo, experimentalFeatures, logBu
             parts.push('webpack');
         }
     }
-    if (cacheComponents) {
-        parts.push('Cache Components');
-    }
     if (parts.length > 0) {
         versionSuffix = ` (${parts.join(', ')})`;
     }
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.1.6"}`))}${versionSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.2.0"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }
@@ -108,6 +102,11 @@ function logStartInfo({ networkUrl, appUrl, envInfo, experimentalFeatures, logBu
         _log.bootstrap(`- Debugger port: ${debugPort}`);
     }
     if (envInfo == null ? void 0 : envInfo.length) _log.bootstrap(`- Environments: ${envInfo.join(', ')}`);
+}
+function logExperimentalInfo({ experimentalFeatures, cacheComponents }) {
+    if (cacheComponents) {
+        _log.bootstrap(`- Cache Components enabled`);
+    }
     if (experimentalFeatures == null ? void 0 : experimentalFeatures.length) {
         _log.bootstrap(`- Experiments (use with caution):`);
         for (const exp of experimentalFeatures){
@@ -125,30 +124,9 @@ function logStartInfo({ networkUrl, appUrl, envInfo, experimentalFeatures, logBu
     // New line after the bootstrap info
     _log.info('');
 }
-async function getStartServerInfo({ dir, dev, debugPrerender }) {
-    let experimentalFeatures = [];
-    let cacheComponents = false;
-    const config = await (0, _config.default)(dev ? _constants.PHASE_DEVELOPMENT_SERVER : _constants.PHASE_PRODUCTION_BUILD, dir, {
-        reportExperimentalFeatures (features) {
-            experimentalFeatures = features.sort(({ key: a }, { key: b })=>a.localeCompare(b));
-        },
-        debugPrerender,
-        silent: false
-    });
-    cacheComponents = !!config.cacheComponents;
-    // we need to reset env if we are going to create
-    // the worker process with the esm loader so that the
-    // initial env state is correct
-    let envInfo = [];
+function getEnvInfo(dir) {
     const { loadedEnvFiles } = (0, _env.loadEnvConfig)(dir, true, console, false);
-    if (loadedEnvFiles.length > 0) {
-        envInfo = loadedEnvFiles.map((f)=>f.path);
-    }
-    return {
-        envInfo,
-        experimentalFeatures,
-        cacheComponents
-    };
+    return loadedEnvFiles.map((f)=>f.path);
 }
 
 //# sourceMappingURL=app-info-log.js.map

package/standalone/node_modules/next/dist/server/lib/cache-control.js

@@ -16,7 +16,7 @@ function getCacheControlHeader({ revalidate, expire }) {
     } else if (typeof revalidate === 'number') {
         return `s-maxage=${revalidate}${swrHeader}`;
     }
-    return `s-maxage=${_constants.CACHE_ONE_YEAR}${swrHeader}`;
+    return `s-maxage=${_constants.CACHE_ONE_YEAR_SECONDS}${swrHeader}`;
 }
 
 //# sourceMappingURL=cache-control.js.map

package/standalone/node_modules/next/dist/server/lib/clone-response.js

@@ -40,22 +40,6 @@ function cloneResponse(original) {
         enumerable: true,
         writable: false
     });
-    // The Fetch Standard allows users to skip consuming the response body by
-    // relying on garbage collection to release connection resources.
-    // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection
-    //
-    // To cancel the stream you then need to cancel both resulting branches.
-    // Teeing a stream will generally lock it for the duration, preventing other
-    // readers from locking it.
-    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee
-    // cloned2 is stored in a react cache and cloned for subsequent requests.
-    // It is the original request, and is is garbage collected by a
-    // FinalizationRegistry in Undici, but since we're tee-ing the stream
-    // ourselves, we need to cancel clone1's stream (the response returned from
-    // our dedupe fetch) when clone1 is reclaimed, otherwise we leak memory.
-    if (registry && cloned1.body) {
-        registry.register(cloned1, new WeakRef(cloned1.body));
-    }
     const cloned2 = new Response(body2, {
         status: original.status,
         statusText: original.statusText,
@@ -68,6 +52,22 @@ function cloneResponse(original) {
         enumerable: true,
         writable: false
     });
+    // The Fetch Standard allows users to skip consuming the response body by
+    // relying on garbage collection to release connection resources.
+    // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection
+    //
+    // To cancel the stream you then need to cancel both resulting branches.
+    // Teeing a stream will generally lock it for the duration, preventing other
+    // readers from locking it.
+    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee
+    if (registry) {
+        if (cloned1.body) {
+            registry.register(cloned1, new WeakRef(cloned1.body));
+        }
+        if (cloned2.body) {
+            registry.register(cloned2, new WeakRef(cloned2.body));
+        }
+    }
     return [
         cloned1,
         cloned2

package/standalone/node_modules/next/dist/server/lib/cpu-profile.js

@@ -1,28 +1,59 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "saveCpuProfile", {
+    enumerable: true,
+    get: function() {
+        return saveCpuProfile;
+    }
+});
 const privateCpuProfileName = process.env.__NEXT_PRIVATE_CPU_PROFILE;
 const isCpuProfileEnabled = process.env.NEXT_CPU_PROF || privateCpuProfileName;
+const cpuProfileDir = process.env.NEXT_CPU_PROF_DIR;
+let session = null;
+let profileSaved = false;
 if (isCpuProfileEnabled) {
     const { Session } = require('inspector');
-    const fs = require('fs');
-    const session = new Session();
+    session = new Session();
     session.connect();
     session.post('Profiler.enable');
     session.post('Profiler.start');
-    function saveProfile() {
-        session.post('Profiler.stop', (error, param)=>{
-            if (error) {
-                console.error('Cannot generate CPU profiling:', error);
-                return;
-            }
-            // Write profile to disk
-            const filename = `${privateCpuProfileName || 'CPU.main'}.${Date.now()}.cpuprofile`;
-            fs.writeFileSync(`./${filename}`, JSON.stringify(param.profile));
-            process.exit(0);
-        });
+    process.on('exit', ()=>{
+        saveCpuProfile();
+    });
+}
+function saveCpuProfile() {
+    if (!session || profileSaved || !isCpuProfileEnabled) {
+        return;
     }
-    process.on('SIGINT', saveProfile);
-    process.on('SIGTERM', saveProfile);
-    process.on('exit', saveProfile);
+    profileSaved = true;
+    const fs = require('fs');
+    const path = require('path');
+    session.post('Profiler.stop', (error, param)=>{
+        if (error) {
+            console.error('Cannot generate CPU profiling:', error);
+            return;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const baseName = privateCpuProfileName || 'cpu-profile';
+        const filename = `${baseName}-${timestamp}.cpuprofile`;
+        let outputPath;
+        if (cpuProfileDir) {
+            if (!fs.existsSync(cpuProfileDir)) {
+                fs.mkdirSync(cpuProfileDir, {
+                    recursive: true
+                });
+            }
+            outputPath = path.join(cpuProfileDir, filename);
+        } else {
+            outputPath = `./${filename}`;
+        }
+        fs.writeFileSync(outputPath, JSON.stringify(param.profile));
+        const { green } = require('../../lib/picocolors');
+        console.log(`\n${green('CPU profile saved:')} ${outputPath}`);
+        console.log('Open in Chrome DevTools → Performance tab → Load profile');
+    });
 }
 
 //# sourceMappingURL=cpu-profile.js.map

package/standalone/node_modules/next/dist/server/lib/dev-bundler-service.js

@@ -46,10 +46,10 @@ class DevBundlerService {
         // Return the very first error we found.
         return errors[0];
     }
-    async revalidate({ urlPath, revalidateHeaders, opts: revalidateOpts }) {
+    async revalidate({ urlPath, headers, opts: revalidateOpts }) {
         const mocked = (0, _mockrequest.createRequestResponseMocks)({
             url: urlPath,
-            headers: revalidateHeaders
+            headers
         });
         await this.handler(mocked.req, mocked.res);
         await mocked.res.hasStreamed;

package/standalone/node_modules/next/dist/server/lib/disk-lru-cache.external.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getOrInitDiskLRU: null,
+    resetDiskLRU: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getOrInitDiskLRU: function() {
+        return getOrInitDiskLRU;
+    },
+    resetDiskLRU: function() {
+        return resetDiskLRU;
+    }
+});
+const _fs = require("fs");
+const _lrucache = require("./lru-cache");
+/**
+ * Module-level LRU singleton for disk cache eviction.
+ * Initialized once on first `set()`, shared across all consumers.
+ * Once resolved, the promise stays resolved — subsequent calls just await the cached result.
+ */ let _diskLRUPromise = null;
+async function getOrInitDiskLRU(cacheDir, maxDiskSize, readEntries, evictEntry) {
+    if (!_diskLRUPromise) {
+        _diskLRUPromise = (async ()=>{
+            let maxSize = maxDiskSize;
+            if (typeof maxSize === 'undefined') {
+                // Ensure cacheDir exists before checking disk space
+                await _fs.promises.mkdir(cacheDir, {
+                    recursive: true
+                });
+                // Since config was not provided, default to 50% of available disk space
+                const { bavail, bsize } = await _fs.promises.statfs(cacheDir);
+                maxSize = Math.floor(bavail * bsize / 2);
+            }
+            const lru = new _lrucache.LRUCache(maxSize, (size)=>size, (cacheKey)=>evictEntry(cacheDir, cacheKey));
+            const entries = await readEntries(cacheDir);
+            for (const entry of entries){
+                lru.set(entry.key, entry.size);
+            }
+            return lru;
+        })();
+    }
+    return _diskLRUPromise;
+}
+function resetDiskLRU() {
+    _diskLRUPromise = null;
+}
+
+//# sourceMappingURL=disk-lru-cache.external.js.map

package/standalone/node_modules/next/dist/server/lib/find-page-file.js

@@ -28,6 +28,7 @@ const _fs = require("fs");
 const _log = require("../../build/output/log");
 const _picocolors = require("../../lib/picocolors");
 const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
+const _escaperegexp = require("../../shared/lib/escape-regexp");
 async function isTrueCasePagePath(pagePath, pagesDir) {
     const pageSegments = (0, _path.normalize)(pagePath).split(_path.sep).filter(Boolean);
     const segmentExistsPromises = pageSegments.map(async (segment, i)=>{
@@ -61,13 +62,32 @@ async function findPageFile(pagesDir, normalizedPagePath, pageExtensions, isAppD
     return existingPath;
 }
 function createValidFileMatcher(pageExtensions, appDirPath) {
-    const getExtensionRegexString = (extensions)=>`(?:${extensions.join('|')})`;
-    const validExtensionFileRegex = new RegExp('\\.' + getExtensionRegexString(pageExtensions) + '$');
-    const leafOnlyPageFileRegex = new RegExp(`(^(page|route)|[\\\\/](page|route))\\.${getExtensionRegexString(pageExtensions)}$`);
-    const leafOnlyRouteFileRegex = new RegExp(`(^route|[\\\\/]route)\\.${getExtensionRegexString(pageExtensions)}$`);
-    const leafOnlyLayoutFileRegex = new RegExp(`(^(layout)|[\\\\/](layout))\\.${getExtensionRegexString(pageExtensions)}$`);
-    const rootNotFoundFileRegex = new RegExp(`^not-found\\.${getExtensionRegexString(pageExtensions)}$`);
-    const leafOnlyDefaultFileRegex = new RegExp(`(^(default)|[\\\\/](default))\\.${getExtensionRegexString(pageExtensions)}$`);
+    // Helper to create extension regex pattern
+    const extPattern = `(?:${pageExtensions.map((extension)=>(0, _escaperegexp.escapeStringRegexp)(extension)).join('|')})`;
+    // Pattern factory for "leaf" files that can appear at start of path or after separator
+    // e.g., 'page.tsx', '/path/page.tsx', '\\path\\route.js'
+    const createLeafPattern = (fileNames)=>{
+        const names = fileNames.length === 1 ? fileNames[0] : `(${fileNames.join('|')})`;
+        return new RegExp(`(^${names}|[\\\\/]${names})\\.${extPattern}$`);
+    };
+    // Pattern factory for root-only files (no path separator allowed)
+    const createRootOnlyPattern = (fileName)=>new RegExp(`^${fileName}\\.${extPattern}$`);
+    // All file matching patterns
+    const validExtensionFileRegex = new RegExp(`\\.${extPattern}$`);
+    const leafOnlyPageFileRegex = createLeafPattern([
+        'page',
+        'route'
+    ]);
+    const leafOnlyRouteFileRegex = createLeafPattern([
+        'route'
+    ]);
+    const leafOnlyLayoutFileRegex = createLeafPattern([
+        'layout'
+    ]);
+    const leafOnlyDefaultFileRegex = createLeafPattern([
+        'default'
+    ]);
+    const rootNotFoundFileRegex = createRootOnlyPattern('not-found');
     /** TODO-METADATA: support other metadata routes
    *  regex for:
    *

package/standalone/node_modules/next/dist/server/lib/implicit-tags.js

@@ -47,7 +47,7 @@ const getDerivedTags = (pathname)=>{
     }
     return expirationsByCacheKind;
 }
-async function getImplicitTags(page, url, fallbackRouteParams) {
+async function getImplicitTags(page, pathname, fallbackRouteParams) {
     const tags = new Set();
     // Add the derived tags from the page.
     const derivedTags = getDerivedTags(page);
@@ -57,8 +57,8 @@ async function getImplicitTags(page, url, fallbackRouteParams) {
     }
     // Add the tags from the pathname. If the route has unknown params, we don't
     // want to add the pathname as a tag, as it will be invalid.
-    if (url.pathname && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
-        const tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${url.pathname}`;
+    if (pathname && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
+        const tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`;
         tags.add(tag);
     }
     if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {

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

@@ -164,7 +164,7 @@ class FileSystemCache {
                             }));
                         }
                         let rscData;
-                        if (!ctx.isFallback && !ctx.isRoutePPREnabled) {
+                        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));
                         }
                         data = {
@@ -268,7 +268,8 @@ class FileSystemCache {
                 headers: data.headers,
                 status: data.status,
                 postponed: undefined,
-                segmentPaths: undefined
+                segmentPaths: undefined,
+                prefetchHints: undefined
             };
             writer.append(filePath.replace(/\.body$/, _constants.NEXT_META_SUFFIX), JSON.stringify(meta, null, 2));
         } else if (data.kind === _responsecache.CachedRouteKind.PAGES || data.kind === _responsecache.CachedRouteKind.APP_PAGE) {
@@ -294,7 +295,8 @@ class FileSystemCache {
                     headers: data.headers,
                     status: data.status,
                     postponed: data.postponed,
-                    segmentPaths
+                    segmentPaths,
+                    prefetchHints: undefined
                 };
                 writer.append(htmlPath.replace(/\.html$/, _constants.NEXT_META_SUFFIX), JSON.stringify(meta));
             }