@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.3

package/assets/standalone/node_modules/next/dist/server/request/root-params.js

@@ -15,12 +15,13 @@ const _workunitasyncstorageexternal = require("../app-render/work-unit-async-sto
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _reflectutils = require("../../shared/lib/utils/reflect-utils");
 const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
+const _varyparams = require("../app-render/vary-params");
 function getRootParam(paramName) {
     const apiName = `\`import('next/root-params').${paramName}()\``;
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
         throw Object.defineProperty(new _invarianterror.InvariantError(`Missing workStore in ${apiName}`), "__NEXT_ERROR_CODE", {
-            value: "E764",
+            value: "E1032",
             enumerable: false,
             configurable: true
         });
@@ -28,7 +29,7 @@ function getRootParam(paramName) {
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (!workUnitStore) {
         throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} outside of a Server Component. This is not allowed.`), "__NEXT_ERROR_CODE", {
-            value: "E774",
+            value: "E1006",
             enumerable: false,
             configurable: true
         });
@@ -38,7 +39,7 @@ function getRootParam(paramName) {
         if (actionStore.isAppRoute) {
             // TODO(root-params): add support for route handlers
             throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside a Route Handler. Support for this API in Route Handlers is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
-                value: "E765",
+                value: "E1043",
                 enumerable: false,
                 configurable: true
             });
@@ -49,7 +50,7 @@ function getRootParam(paramName) {
             // Make sure we check if the phase is "action" - we should not error in the rerender
             // after an action revalidates or updates cookies (which will still have `actionStore.isAction === true`)
             throw Object.defineProperty(new Error(`${apiName} was used inside a Server Action. This is not supported. Functions from 'next/root-params' can only be called in the context of a route.`), "__NEXT_ERROR_CODE", {
-                value: "E766",
+                value: "E1014",
                 enumerable: false,
                 configurable: true
             });
@@ -57,44 +58,79 @@ function getRootParam(paramName) {
     }
     switch(workUnitStore.type){
         case 'unstable-cache':
-        case 'cache':
             {
-                throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside \`"use cache"\` or \`unstable_cache\`. Support for this API inside cache scopes is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
-                    value: "E760",
+                throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside \`unstable_cache\`. This is not supported. Use \`"use cache"\` instead.`), "__NEXT_ERROR_CODE", {
+                    value: "E1141",
                     enumerable: false,
                     configurable: true
                 });
             }
+        case 'cache':
+            {
+                if (!workUnitStore.rootParams) {
+                    throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside \`"use cache"\` nested within \`unstable_cache\`. Root params are not available in this context.`), "__NEXT_ERROR_CODE", {
+                        value: "E1140",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                workUnitStore.readRootParamNames.add(paramName);
+                return Promise.resolve(workUnitStore.rootParams[paramName]);
+            }
         case 'prerender':
-        case 'prerender-client':
         case 'prerender-ppr':
         case 'prerender-legacy':
             {
                 return createPrerenderRootParamPromise(paramName, workStore, workUnitStore, apiName);
             }
+        case 'validation-client':
+        case 'prerender-client':
+            {
+                throw Object.defineProperty(new _invarianterror.InvariantError(`${apiName} must not be used within a client component. Next.js should be preventing ${apiName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                    value: "E1062",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        case 'request':
+            {
+                if (process.env.__NEXT_CACHE_COMPONENTS && workUnitStore.validationSamples) {
+                    const { assertRootParamInSamples } = require('../app-render/instant-validation/instant-samples');
+                    // If we error, make sure we return a rejected promise instead of erroring synchronously.
+                    try {
+                        assertRootParamInSamples(workStore, workUnitStore.validationSamples.params, paramName);
+                    } catch (err) {
+                        return Promise.reject(err);
+                    }
+                }
+                break;
+            }
         case 'private-cache':
         case 'prerender-runtime':
-        case 'request':
             {
                 break;
             }
+        case 'generate-static-params':
+            {
+                if (!(paramName in workUnitStore.rootParams)) {
+                    throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside \`generateStaticParams\`, but the \`${paramName}\` parameter was not provided by a parent \`generateStaticParams\`. In \`generateStaticParams\`, root params are only available for segments nested below the segment that provides them.`), "__NEXT_ERROR_CODE", {
+                        value: "E1142",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                break;
+            }
         default:
             {
                 workUnitStore;
             }
     }
+    (0, _varyparams.accumulateRootVaryParam)(paramName);
     return Promise.resolve(workUnitStore.rootParams[paramName]);
 }
 function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, apiName) {
     switch(prerenderStore.type){
-        case 'prerender-client':
-            {
-                throw Object.defineProperty(new _invarianterror.InvariantError(`${apiName} must not be used within a client component. Next.js should be preventing ${apiName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-                    value: "E693",
-                    enumerable: false,
-                    configurable: true
-                });
-            }
         case 'prerender':
         case 'prerender-legacy':
         case 'prerender-ppr':
@@ -130,6 +166,7 @@ function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, a
             }
     }
     // If the param is not a fallback param, we just return the statically available value.
+    (0, _varyparams.accumulateRootVaryParam)(paramName);
     return Promise.resolve(underlyingParams[paramName]);
 }
 /** Deliberately async -- we want to create a rejected promise, not error synchronously. */ async function makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName) {

package/assets/standalone/node_modules/next/dist/server/request/search-params.js

@@ -32,6 +32,8 @@ _export(exports, {
         return makeErroringSearchParamsForUseCache;
     }
 });
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _varyparams = require("../app-render/vary-params");
 const _reflect = require("../web/spec-extension/adapters/reflect");
 const _dynamicrendering = require("../app-render/dynamic-rendering");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
@@ -41,7 +43,15 @@ const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-
 const _reflectutils = require("../../shared/lib/utils/reflect-utils");
 const _utils = require("./utils");
 const _stagedrendering = require("../app-render/staged-rendering");
-function createSearchParamsFromClient(underlyingSearchParams, workStore) {
+function createSearchParamsFromClient(underlyingSearchParams) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workUnitStore) {
         switch(workUnitStore.type){
@@ -50,6 +60,10 @@ function createSearchParamsFromClient(underlyingSearchParams, workStore) {
             case 'prerender-ppr':
             case 'prerender-legacy':
                 return createStaticPrerenderSearchParams(workStore, workUnitStore);
+            case 'validation-client':
+                {
+                    return createClientSearchParamsInValidation(underlyingSearchParams, workStore, workUnitStore);
+                }
             case 'prerender-runtime':
                 throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
                     value: "E769",
@@ -64,16 +78,35 @@ function createSearchParamsFromClient(underlyingSearchParams, workStore) {
                     enumerable: false,
                     configurable: true
                 });
+            case 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1133",
+                    enumerable: false,
+                    configurable: true
+                });
             case 'request':
-                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore);
+                // Client searchParams are not runtime prefetchable
+                const isRuntimePrefetchable = false;
+                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore, isRuntimePrefetchable);
             default:
                 workUnitStore;
         }
     }
     (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
 }
-const createServerSearchParamsForMetadata = createServerSearchParamsForServerPage;
-function createServerSearchParamsForServerPage(underlyingSearchParams, workStore) {
+function createServerSearchParamsForMetadata(underlyingSearchParams, isRuntimePrefetchable) {
+    const metadataVaryParamsAccumulator = (0, _varyparams.getMetadataVaryParamsAccumulator)();
+    return createServerSearchParamsForServerPage(underlyingSearchParams, metadataVaryParamsAccumulator, isRuntimePrefetchable);
+}
+function createServerSearchParamsForServerPage(underlyingSearchParams, varyParamsAccumulator, isRuntimePrefetchable) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workUnitStore) {
         switch(workUnitStore.type){
@@ -82,6 +115,12 @@ function createServerSearchParamsForServerPage(underlyingSearchParams, workStore
             case 'prerender-ppr':
             case 'prerender-legacy':
                 return createStaticPrerenderSearchParams(workStore, workUnitStore);
+            case 'validation-client':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in a client validation.'), "__NEXT_ERROR_CODE", {
+                    value: "E1066",
+                    enumerable: false,
+                    configurable: true
+                });
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
@@ -90,17 +129,31 @@ function createServerSearchParamsForServerPage(underlyingSearchParams, workStore
                     enumerable: false,
                     configurable: true
                 });
+            case 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1128",
+                    enumerable: false,
+                    configurable: true
+                });
             case 'prerender-runtime':
-                return createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore);
+                return createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
             case 'request':
-                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore);
+                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore, isRuntimePrefetchable);
             default:
                 workUnitStore;
         }
     }
     (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
 }
-function createPrerenderSearchParamsForClientPage(workStore) {
+function createPrerenderSearchParamsForClientPage() {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
     if (workStore.forceStatic) {
         // When using forceStatic we override all other logic and always just return an empty
         // dictionary object.
@@ -114,6 +167,12 @@ function createPrerenderSearchParamsForClientPage(workStore) {
                 // We're prerendering in a mode that aborts (cacheComponents) and should stall
                 // the promise to ensure the RSC side is considered dynamic
                 return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`');
+            case 'validation-client':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a client validation.'), "__NEXT_ERROR_CODE", {
+                    value: "E1061",
+                    enumerable: false,
+                    configurable: true
+                });
             case 'prerender-runtime':
                 throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
                     value: "E768",
@@ -128,6 +187,12 @@ function createPrerenderSearchParamsForClientPage(workStore) {
                     enumerable: false,
                     configurable: true
                 });
+            case 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1124",
+                    enumerable: false,
+                    configurable: true
+                });
             case 'prerender-ppr':
             case 'prerender-legacy':
             case 'request':
@@ -158,10 +223,17 @@ function createStaticPrerenderSearchParams(workStore, prerenderStore) {
             return prerenderStore;
     }
 }
-function createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore) {
-    return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedSearchParams(underlyingSearchParams));
+function createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable) {
+    const underlyingSearchParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingSearchParams)(varyParamsAccumulator, underlyingSearchParams) : underlyingSearchParams;
+    const result = makeUntrackedSearchParams(underlyingSearchParamsWithVarying);
+    const { stagedRendering } = workUnitStore;
+    if (!stagedRendering) {
+        return result;
+    }
+    const stage = isRuntimePrefetchable ? _stagedrendering.RenderStage.EarlyRuntime : _stagedrendering.RenderStage.Runtime;
+    return stagedRendering.waitForStage(stage).then(()=>result);
 }
-function createRenderSearchParams(underlyingSearchParams, workStore, requestStore) {
+function createRenderSearchParams(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
     if (workStore.forceStatic) {
         // When using forceStatic we override all other logic and always just return an empty
         // dictionary object.
@@ -171,7 +243,14 @@ function createRenderSearchParams(underlyingSearchParams, workStore, requestStor
             // Semantically we only need the dev tracking when running in `next dev`
             // but since you would never use next dev with production NODE_ENV we use this
             // as a proxy so we can statically exclude this code from production builds.
-            return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore);
+            return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
+        } else if (requestStore.asyncApiPromises) {
+            if (requestStore.validationSamples) {
+                const { createExhaustiveSearchParamsProxy } = require('../app-render/instant-validation/instant-samples');
+                const declaredKeys = new Set(Object.keys(requestStore.validationSamples.searchParams ?? {}));
+                underlyingSearchParams = createExhaustiveSearchParamsProxy(underlyingSearchParams, declaredKeys, workStore.route);
+            }
+            return (isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedSearchParamsParent : requestStore.asyncApiPromises.sharedSearchParamsParent).then(()=>underlyingSearchParams);
         } else {
             return makeUntrackedSearchParams(underlyingSearchParams);
         }
@@ -252,7 +331,15 @@ function makeErroringSearchParams(workStore, prerenderStore) {
     CachedSearchParams.set(workStore, proxiedPromise);
     return proxiedPromise;
 }
-function makeErroringSearchParamsForUseCache(workStore) {
+function makeErroringSearchParamsForUseCache() {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
     const cachedSearchParams = CachedSearchParamsForUseCache.get(workStore);
     if (cachedSearchParams) {
         return cachedSearchParams;
@@ -285,22 +372,22 @@ function makeUntrackedSearchParams(underlyingSearchParams) {
     CachedSearchParams.set(underlyingSearchParams, promise);
     return promise;
 }
-function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore) {
+function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
     if (requestStore.asyncApiPromises) {
         // Do not cache the resulting promise. If we do, we'll only show the first "awaited at"
         // across all segments that receive searchParams.
-        return makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore);
+        return makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
     } else {
         const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
         if (cachedSearchParams) {
             return cachedSearchParams;
         }
-        const promise = makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore);
+        const promise = makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
         CachedSearchParams.set(requestStore, promise);
         return promise;
     }
 }
-function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore) {
+function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
     const promiseInitialized = {
         current: false
     };
@@ -310,7 +397,7 @@ function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, wo
         // We wrap each instance of searchParams in a `new Promise()`.
         // This is important when all awaits are in third party which would otherwise
         // track all the way to the internal params.
-        const sharedSearchParamsParent = requestStore.asyncApiPromises.sharedSearchParamsParent;
+        const sharedSearchParamsParent = isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedSearchParamsParent : requestStore.asyncApiPromises.sharedSearchParamsParent;
         promise = new Promise((resolve, reject)=>{
             sharedSearchParamsParent.then(()=>resolve(proxiedUnderlying), reject);
         });
@@ -428,5 +515,12 @@ function createSearchAccessError(route, expression) {
         configurable: true
     });
 }
+function createClientSearchParamsInValidation(underlyingSearchParams, workStore, workUnitStore) {
+    var _workUnitStore_validationSamples;
+    const { createExhaustiveSearchParamsProxy } = require('../app-render/instant-validation/instant-samples');
+    const declaredKeys = new Set(Object.keys(((_workUnitStore_validationSamples = workUnitStore.validationSamples) == null ? void 0 : _workUnitStore_validationSamples.searchParams) ?? {}));
+    underlyingSearchParams = createExhaustiveSearchParamsProxy(underlyingSearchParams, declaredKeys, workStore.route);
+    return Promise.resolve(underlyingSearchParams);
+}
 
 //# sourceMappingURL=search-params.js.map

package/assets/standalone/node_modules/next/dist/server/require-hook.js

@@ -35,15 +35,26 @@ const resolveFilename = // @ts-expect-error
 mod._resolveFilename;
 let resolve = process.env.NEXT_MINIMAL ? __non_webpack_require__.resolve : require.resolve;
 const hookPropertyMap = new Map();
-const defaultOverrides = {
-    'styled-jsx': path.dirname(resolve('styled-jsx/package.json')),
-    'styled-jsx/style': resolve('styled-jsx/style'),
-    'styled-jsx/style.js': resolve('styled-jsx/style')
+const defaultOverrides = {};
+try {
+    Object.assign(defaultOverrides, {
+        'styled-jsx': path.dirname(resolve('styled-jsx/package.json')),
+        'styled-jsx/style': resolve('styled-jsx/style'),
+        'styled-jsx/style.js': resolve('styled-jsx/style')
+    });
+} catch (_) {}
+const toResolveMap = (map)=>{
+    const resolveMap = [];
+    for (const [key, value] of Object.entries(map)){
+        try {
+            resolveMap.push([
+                key,
+                resolve(value)
+            ]);
+        } catch  {}
+    }
+    return resolveMap;
 };
-const toResolveMap = (map)=>Object.entries(map).map(([key, value])=>[
-            key,
-            resolve(value)
-        ]);
 function addHookAliases(aliases = []) {
     for (const [key, value] of aliases){
         hookPropertyMap.set(key, value);

package/assets/standalone/node_modules/next/dist/server/response-cache/utils.js

@@ -61,6 +61,7 @@ async function toResponseCacheEntry(response) {
         isMiss: response.isMiss,
         isStale: response.isStale,
         cacheControl: response.cacheControl,
+        isFallback: response.isFallback,
         value: ((_response_value = response.value) == null ? void 0 : _response_value.kind) === _types.CachedRouteKind.PAGES ? {
             kind: _types.CachedRouteKind.PAGES,
             html: _renderresult.default.fromStatic(response.value.html, _constants.HTML_CONTENT_TYPE_HEADER),

package/assets/standalone/node_modules/next/dist/server/resume-data-cache/cache-store.js

@@ -24,29 +24,34 @@ const _encryptionutils = require("../app-render/encryption-utils");
 const _constants = require("../use-cache/constants");
 function parseUseCacheCacheStore(entries) {
     const store = new Map();
-    for (const [key, { value, tags, stale, timestamp, expire, revalidate }] of entries){
+    for (const [key, { entry, hasExplicitRevalidate, hasExplicitExpire, readRootParamNames }] of entries){
         store.set(key, Promise.resolve({
-            // Create a ReadableStream from the Uint8Array
-            value: new ReadableStream({
-                start (controller) {
-                    // Enqueue the Uint8Array to the stream
-                    controller.enqueue((0, _encryptionutils.stringToUint8Array)(atob(value)));
-                    // Close the stream
-                    controller.close();
-                }
-            }),
-            tags,
-            stale,
-            timestamp,
-            expire,
-            revalidate
+            entry: {
+                // Create a ReadableStream from the Uint8Array
+                value: new ReadableStream({
+                    start (controller) {
+                        // Enqueue the Uint8Array to the stream
+                        controller.enqueue((0, _encryptionutils.stringToUint8Array)(atob(entry.value)));
+                        // Close the stream
+                        controller.close();
+                    }
+                }),
+                tags: entry.tags,
+                stale: entry.stale,
+                timestamp: entry.timestamp,
+                expire: entry.expire,
+                revalidate: entry.revalidate
+            },
+            hasExplicitRevalidate,
+            hasExplicitExpire,
+            readRootParamNames: readRootParamNames ? new Set(readRootParamNames) : undefined
         }));
     }
     return store;
 }
 async function serializeUseCacheCacheStore(entries, isCacheComponentsEnabled) {
     return Promise.all(Array.from(entries).map(([key, value])=>{
-        return value.then(async (entry)=>{
+        return value.then(async ({ entry, hasExplicitRevalidate, hasExplicitExpire, readRootParamNames })=>{
             if (isCacheComponentsEnabled && (entry.revalidate === 0 || entry.expire < _constants.DYNAMIC_EXPIRE)) {
                 // The entry was omitted from the prerender result, and subsequently
                 // does not need to be included in the serialized RDC.
@@ -64,13 +69,20 @@ async function serializeUseCacheCacheStore(entries, isCacheComponentsEnabled) {
             return [
                 key,
                 {
-                    // Encode the value as a base64 string.
-                    value: btoa(binaryString),
-                    tags: entry.tags,
-                    stale: entry.stale,
-                    timestamp: entry.timestamp,
-                    expire: entry.expire,
-                    revalidate: entry.revalidate
+                    entry: {
+                        // Encode the value as a base64 string.
+                        value: btoa(binaryString),
+                        tags: entry.tags,
+                        stale: entry.stale,
+                        timestamp: entry.timestamp,
+                        expire: entry.expire,
+                        revalidate: entry.revalidate
+                    },
+                    hasExplicitRevalidate,
+                    hasExplicitExpire,
+                    readRootParamNames: readRootParamNames ? [
+                        ...readRootParamNames
+                    ] : undefined
                 }
             ];
         }).catch(()=>{

package/assets/standalone/node_modules/next/dist/server/resume-data-cache/resume-data-cache.js

@@ -50,13 +50,22 @@ async function stringifyResumeDataCache(resumeDataCache, isCacheComponentsEnable
         return deflateSync(JSON.stringify(json)).toString('base64');
     }
 }
-function createPrerenderResumeDataCache() {
-    return {
-        cache: new Map(),
-        fetch: new Map(),
-        encryptedBoundArgs: new Map(),
-        decryptedBoundArgs: new Map()
-    };
+function createPrerenderResumeDataCache(source) {
+    if (source) {
+        return {
+            cache: new Map(source.cache),
+            fetch: new Map(source.fetch),
+            encryptedBoundArgs: new Map(source.encryptedBoundArgs),
+            decryptedBoundArgs: new Map(source.decryptedBoundArgs)
+        };
+    } else {
+        return {
+            cache: new Map(),
+            fetch: new Map(),
+            encryptedBoundArgs: new Map(),
+            decryptedBoundArgs: new Map()
+        };
+    }
 }
 function createRenderResumeDataCache(resumeDataCacheOrPersistedCache, maxPostponedStateSizeBytes) {
     if (process.env.NEXT_RUNTIME === 'edge') {

package/assets/standalone/node_modules/next/dist/server/revalidation-utils.js

@@ -138,15 +138,20 @@ async function revalidateTags(tagsWithProfile, incrementalCache, workStore) {
     }
     await Promise.all(promises);
 }
-async function executeRevalidates(workStore, state) {
+function executeRevalidates(workStore, state) {
+    const promises = [];
     const pendingRevalidatedTags = (state == null ? void 0 : state.pendingRevalidatedTags) ?? workStore.pendingRevalidatedTags ?? [];
-    const pendingRevalidates = (state == null ? void 0 : state.pendingRevalidates) ?? workStore.pendingRevalidates ?? {};
+    if (pendingRevalidatedTags.length > 0) {
+        promises.push(revalidateTags(pendingRevalidatedTags, workStore.incrementalCache, workStore));
+    }
+    const pendingRevalidates = Object.values((state == null ? void 0 : state.pendingRevalidates) ?? workStore.pendingRevalidates ?? {});
+    promises.push(...pendingRevalidates);
     const pendingRevalidateWrites = (state == null ? void 0 : state.pendingRevalidateWrites) ?? workStore.pendingRevalidateWrites ?? [];
-    return Promise.all([
-        revalidateTags(pendingRevalidatedTags, workStore.incrementalCache, workStore),
-        ...Object.values(pendingRevalidates),
-        ...pendingRevalidateWrites
-    ]);
+    promises.push(...pendingRevalidateWrites);
+    if (promises.length === 0) {
+        return false;
+    }
+    return Promise.all(promises).then(()=>undefined);
 }
 
 //# sourceMappingURL=revalidation-utils.js.map

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

@@ -13,6 +13,7 @@ const _routekind = require("../../route-kind");
 const _filecacheroutematcherprovider = require("./file-cache-route-matcher-provider");
 const _app = require("../../normalizers/built/app");
 const _normalizecatchallroutes = require("../../../build/normalize-catchall-routes");
+const _apppaths = require("../../../shared/lib/router/utils/app-paths");
 class DevAppPageRouteMatcherProvider extends _filecacheroutematcherprovider.FileCacheRouteMatcherProvider {
     constructor(appDir, extensions, reader, isTurbopack){
         super(appDir, reader);
@@ -60,7 +61,7 @@ class DevAppPageRouteMatcherProvider extends _filecacheroutematcherprovider.File
         // Make sure to sort parallel routes to make the result deterministic.
         appPaths = Object.fromEntries(Object.entries(appPaths).map(([k, v])=>[
                 k,
-                v.sort()
+                v.sort(_apppaths.compareAppPaths)
             ]));
         const matchers = [];
         for (const filename of routeFilenames){

package/assets/standalone/node_modules/next/dist/server/route-modules/app-page/helpers/prerender-manifest-matcher.js

@@ -38,7 +38,10 @@ class PrerenderManifestMatcher {
             }
             const match = matcher.matcher(pathname);
             if (match) {
-                return matcher.route;
+                return {
+                    source: matcher.source,
+                    route: matcher.route
+                };
             }
         }
         return null;