af360 0.1.15 → 0.1.16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/node_modules/next/dist/shared/lib/router/utils/app-paths.js

@@ -4,7 +4,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     normalizeAppPath: null,
-    normalizeRscURL: null
+    normalizeRscURL: null,
+    selectAppPageEntry: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -18,6 +19,9 @@ _export(exports, {
     },
     normalizeRscURL: function() {
         return normalizeRscURL;
+    },
+    selectAppPageEntry: function() {
+        return selectAppPageEntry;
     }
 });
 const _ensureleadingslash = require("../../page-path/ensure-leading-slash");
@@ -43,6 +47,18 @@ function normalizeAppPath(route) {
         return pathname + "/" + segment;
     }, ''));
 }
+function selectAppPageEntry(pathname, appPaths, normalizePathname) {
+    if (normalizePathname === void 0) normalizePathname = (appPath)=>normalizeAppPath(appPath).replace(/%5F/g, '_');
+    let entry;
+    for (const appPath of appPaths){
+        if (normalizePathname(appPath) !== pathname) continue;
+        if (entry === undefined || entry < appPath) entry = appPath;
+    }
+    if (entry === undefined) {
+        throw new Error("Invariant: no direct app page entry found for " + pathname);
+    }
+    return entry;
+}
 function normalizeRscURL(url) {
     return url.replace(/\.rsc($|\?)/, // $1 ensures `?` is preserved
     '$1');

package/dist/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -81,7 +81,7 @@ function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "15.5.24"
+        nextVersion: "15.5.27"
     };
     return traits;
 }

package/dist/node_modules/next/dist/telemetry/events/version.js

@@ -36,12 +36,12 @@ function hasBabelConfig(dir) {
 function eventCliSession(dir, nextConfig, event) {
     var _nextConfig_experimental_staleTimes, _nextConfig_experimental_staleTimes1, _nextConfig_experimental_reactCompiler, _nextConfig_experimental_reactCompiler1;
     // This should be an invariant, if it fails our build tooling is broken.
-    if (typeof "15.5.24" !== 'string') {
+    if (typeof "15.5.27" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "15.5.24",
+        nextVersion: "15.5.27",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,

package/dist/node_modules/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "15.5.24",
+  "version": "15.5.27",
   "description": "The React Framework",
   "main": "./dist/server/next.js",
   "license": "MIT",
@@ -82,7 +82,7 @@
     "next": "./dist/bin/next"
   },
   "dependencies": {
-    "@next/env": "15.5.24",
+    "@next/env": "15.5.27",
     "@swc/helpers": "0.5.15",
     "caniuse-lite": "^1.0.30001579",
     "postcss": "8.4.31",
@@ -111,15 +111,15 @@
     }
   },
   "optionalDependencies": {
-    "sharp": "^0.34.3 || ^0.35.3",
-    "@next/swc-darwin-arm64": "15.5.24",
-    "@next/swc-darwin-x64": "15.5.24",
-    "@next/swc-linux-arm64-gnu": "15.5.24",
-    "@next/swc-linux-arm64-musl": "15.5.24",
-    "@next/swc-linux-x64-gnu": "15.5.24",
-    "@next/swc-linux-x64-musl": "15.5.24",
-    "@next/swc-win32-arm64-msvc": "15.5.24",
-    "@next/swc-win32-x64-msvc": "15.5.24"
+    "sharp": "^0.34.3 || ^0.35.4",
+    "@next/swc-darwin-arm64": "15.5.27",
+    "@next/swc-darwin-x64": "15.5.27",
+    "@next/swc-linux-arm64-gnu": "15.5.27",
+    "@next/swc-linux-arm64-musl": "15.5.27",
+    "@next/swc-linux-x64-gnu": "15.5.27",
+    "@next/swc-linux-x64-musl": "15.5.27",
+    "@next/swc-win32-arm64-msvc": "15.5.27",
+    "@next/swc-win32-x64-msvc": "15.5.27"
   },
   "keywords": [
     "react",

package/dist/node_modules/source-map-js/lib/quick-sort.js

@@ -112,6 +112,15 @@ function cloneSort(comparator) {
   return templateFn(comparator);
 }
 
+let isEvalAllowed = (function () {
+  try {
+    new Function('return 0')();
+    return true;
+  } catch {
+    return false;
+  }
+})();
+
 /**
  * Sort the given array in-place with the given comparator function.
  *
@@ -123,7 +132,7 @@ function cloneSort(comparator) {
 
 let sortCache = new WeakMap();
 exports.quickSort = function (ary, comparator, start = 0) {
-  let doQuickSort = sortCache.get(comparator);
+  let doQuickSort = isEvalAllowed ? sortCache.get(comparator) : SortTemplate(comparator);
   if (doQuickSort === void 0) {
     doQuickSort = cloneSort(comparator);
     sortCache.set(comparator, doQuickSort);